-/*
+/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
+ *
* lttng-abi.c
*
* LTTng ABI
*
* Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- *
* Mimic system calls for:
* - session creation, returns a file descriptor or failure.
* - channel creation, returns a file descriptor or failure.
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/err.h>
-#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_all() */
+#include <wrapper/compiler_attributes.h>
+#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
#include <wrapper/ringbuffer/vfs.h>
#include <wrapper/ringbuffer/backend.h>
#include <wrapper/ringbuffer/frontend.h>
*/
static struct proc_dir_entry *lttng_proc_dentry;
-static const struct file_operations lttng_fops;
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
+static const struct proc_ops lttng_proc_ops;
+#else
+static const struct file_operations lttng_proc_ops;
+#endif
+
static const struct file_operations lttng_session_fops;
static const struct file_operations lttng_channel_fops;
static const struct file_operations lttng_metadata_fops;
static struct file_operations lttng_stream_ring_buffer_file_operations;
static int put_u64(uint64_t val, unsigned long arg);
+static int put_u32(uint32_t val, unsigned long arg);
/*
* Teardown management: opened file descriptors keep a refcount on the module,
return lttng_add_preemptible_to_ctx(ctx);
case LTTNG_KERNEL_CONTEXT_MIGRATABLE:
return lttng_add_migratable_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL:
+ case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER:
+ return lttng_add_callstack_to_ctx(ctx, context_param->ctx);
+ case LTTNG_KERNEL_CONTEXT_CGROUP_NS:
+ return lttng_add_cgroup_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_IPC_NS:
+ return lttng_add_ipc_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_MNT_NS:
+ return lttng_add_mnt_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_NET_NS:
+ return lttng_add_net_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_PID_NS:
+ return lttng_add_pid_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_USER_NS:
+ return lttng_add_user_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_UTS_NS:
+ return lttng_add_uts_ns_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_UID:
+ return lttng_add_uid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_EUID:
+ return lttng_add_euid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_SUID:
+ return lttng_add_suid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_GID:
+ return lttng_add_gid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_EGID:
+ return lttng_add_egid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_SGID:
+ return lttng_add_sgid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VUID:
+ return lttng_add_vuid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VEUID:
+ return lttng_add_veuid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VSUID:
+ return lttng_add_vsuid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VGID:
+ return lttng_add_vgid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VEGID:
+ return lttng_add_vegid_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_VSGID:
+ return lttng_add_vsgid_to_ctx(ctx);
default:
return -EINVAL;
}
}
}
-static const struct file_operations lttng_fops = {
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
+static const struct proc_ops lttng_proc_ops = {
+ .proc_ioctl = lttng_ioctl,
+#ifdef CONFIG_COMPAT
+ .proc_compat_ioctl = lttng_ioctl,
+#endif /* CONFIG_COMPAT */
+};
+#else
+static const struct file_operations lttng_proc_ops = {
.owner = THIS_MODULE,
.unlocked_ioctl = lttng_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = lttng_ioctl,
-#endif
+#endif /* CONFIG_COMPAT */
};
+#endif
static
int lttng_abi_create_channel(struct file *session_file,
transport_name = "<unknown>";
break;
}
- if (atomic_long_add_unless(&session_file->f_count,
- 1, INT_MAX) == INT_MAX) {
+ if (!atomic_long_add_unless(&session_file->f_count, 1, LONG_MAX)) {
+ ret = -EOVERFLOW;
goto refcount_error;
}
/*
return ret;
}
+static
+int lttng_abi_session_set_name(struct lttng_session *session,
+ struct lttng_kernel_session_name *name)
+{
+ size_t len;
+
+ len = strnlen(name->name, LTTNG_KERNEL_SESSION_NAME_LEN);
+
+ if (len == LTTNG_KERNEL_SESSION_NAME_LEN) {
+ /* Name is too long/malformed */
+ return -EINVAL;
+ }
+
+ strcpy(session->name, name->name);
+ return 0;
+}
+
+static
+int lttng_abi_session_set_creation_time(struct lttng_session *session,
+ struct lttng_kernel_session_creation_time *time)
+{
+ size_t len;
+
+ len = strnlen(time->iso8601, LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN);
+
+ if (len == LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN) {
+ /* Time is too long/malformed */
+ return -EINVAL;
+ }
+
+ strcpy(session->creation_time, time->iso8601);
+ return 0;
+}
+
+static
+enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker)
+{
+ switch (tracker->type) {
+ case LTTNG_KERNEL_TRACKER_PID:
+ return TRACKER_PID;
+ case LTTNG_KERNEL_TRACKER_VPID:
+ return TRACKER_VPID;
+ case LTTNG_KERNEL_TRACKER_UID:
+ return TRACKER_UID;
+ case LTTNG_KERNEL_TRACKER_VUID:
+ return TRACKER_VUID;
+ case LTTNG_KERNEL_TRACKER_GID:
+ return TRACKER_GID;
+ case LTTNG_KERNEL_TRACKER_VGID:
+ return TRACKER_VGID;
+ default:
+ return TRACKER_UNKNOWN;
+ }
+}
+
/**
* lttng_session_ioctl - lttng session fd ioctl
*
* LTTNG_KERNEL_METADATA
* Returns a LTTng metadata file descriptor
* LTTNG_KERNEL_SESSION_TRACK_PID
- * Add PID to session tracker
+ * Add PID to session PID tracker
* LTTNG_KERNEL_SESSION_UNTRACK_PID
- * Remove PID from session tracker
+ * Remove PID from session PID tracker
+ * LTTNG_KERNEL_SESSION_TRACK_ID
+ * Add ID to tracker
+ * LTTNG_KERNEL_SESSION_UNTRACK_ID
+ * Remove ID from tracker
*
* The returned channel will be deleted when its file descriptor is closed.
*/
long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct lttng_session *session = file->private_data;
+ struct lttng_kernel_channel chan_param;
+ struct lttng_kernel_old_channel old_chan_param;
switch (cmd) {
case LTTNG_KERNEL_OLD_CHANNEL:
{
- struct lttng_kernel_channel chan_param;
- struct lttng_kernel_old_channel old_chan_param;
-
if (copy_from_user(&old_chan_param,
(struct lttng_kernel_old_channel __user *) arg,
sizeof(struct lttng_kernel_old_channel)))
}
case LTTNG_KERNEL_CHANNEL:
{
- struct lttng_kernel_channel chan_param;
-
if (copy_from_user(&chan_param,
(struct lttng_kernel_channel __user *) arg,
sizeof(struct lttng_kernel_channel)))
return lttng_session_disable(session);
case LTTNG_KERNEL_OLD_METADATA:
{
- struct lttng_kernel_channel chan_param;
- struct lttng_kernel_old_channel old_chan_param;
-
if (copy_from_user(&old_chan_param,
(struct lttng_kernel_old_channel __user *) arg,
sizeof(struct lttng_kernel_old_channel)))
}
case LTTNG_KERNEL_METADATA:
{
- struct lttng_kernel_channel chan_param;
-
if (copy_from_user(&chan_param,
(struct lttng_kernel_channel __user *) arg,
sizeof(struct lttng_kernel_channel)))
METADATA_CHANNEL);
}
case LTTNG_KERNEL_SESSION_TRACK_PID:
- return lttng_session_track_pid(session, (int) arg);
+ return lttng_session_track_id(session, TRACKER_PID, (int) arg);
case LTTNG_KERNEL_SESSION_UNTRACK_PID:
- return lttng_session_untrack_pid(session, (int) arg);
+ return lttng_session_untrack_id(session, TRACKER_PID, (int) arg);
+ case LTTNG_KERNEL_SESSION_TRACK_ID:
+ {
+ struct lttng_kernel_tracker_args tracker;
+ enum tracker_type tracker_type;
+
+ if (copy_from_user(&tracker,
+ (struct lttng_kernel_tracker_args __user *) arg,
+ sizeof(struct lttng_kernel_tracker_args)))
+ return -EFAULT;
+ tracker_type = get_tracker_type(&tracker);
+ if (tracker_type == TRACKER_UNKNOWN)
+ return -EINVAL;
+ return lttng_session_track_id(session, tracker_type, tracker.id);
+ }
+ case LTTNG_KERNEL_SESSION_UNTRACK_ID:
+ {
+ struct lttng_kernel_tracker_args tracker;
+ enum tracker_type tracker_type;
+
+ if (copy_from_user(&tracker,
+ (struct lttng_kernel_tracker_args __user *) arg,
+ sizeof(struct lttng_kernel_tracker_args)))
+ return -EFAULT;
+ tracker_type = get_tracker_type(&tracker);
+ if (tracker_type == TRACKER_UNKNOWN)
+ return -EINVAL;
+ return lttng_session_untrack_id(session, tracker_type,
+ tracker.id);
+ }
case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS:
- return lttng_session_list_tracker_pids(session);
+ return lttng_session_list_tracker_ids(session, TRACKER_PID);
+ case LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS:
+ {
+ struct lttng_kernel_tracker_args tracker;
+ enum tracker_type tracker_type;
+
+ if (copy_from_user(&tracker,
+ (struct lttng_kernel_tracker_args __user *) arg,
+ sizeof(struct lttng_kernel_tracker_args)))
+ return -EFAULT;
+ tracker_type = get_tracker_type(&tracker);
+ if (tracker_type == TRACKER_UNKNOWN)
+ return -EINVAL;
+ return lttng_session_list_tracker_ids(session, tracker_type);
+ }
case LTTNG_KERNEL_SESSION_METADATA_REGEN:
return lttng_session_metadata_regenerate(session);
case LTTNG_KERNEL_SESSION_STATEDUMP:
return lttng_session_statedump(session);
+ case LTTNG_KERNEL_SESSION_SET_NAME:
+ {
+ struct lttng_kernel_session_name name;
+
+ if (copy_from_user(&name,
+ (struct lttng_kernel_session_name __user *) arg,
+ sizeof(struct lttng_kernel_session_name)))
+ return -EFAULT;
+ return lttng_abi_session_set_name(session, &name);
+ }
+ case LTTNG_KERNEL_SESSION_SET_CREATION_TIME:
+ {
+ struct lttng_kernel_session_creation_time time;
+
+ if (copy_from_user(&time,
+ (struct lttng_kernel_session_creation_time __user *) arg,
+ sizeof(struct lttng_kernel_session_creation_time)))
+ return -EFAULT;
+ return lttng_abi_session_set_creation_time(session, &time);
+ }
default:
return -ENOIOCTLCMD;
}
int ret;
struct lttng_metadata_stream *stream = filp->private_data;
struct lib_ring_buffer *buf = stream->priv;
+ unsigned int rb_cmd;
+ bool coherent;
+
+ if (cmd == RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
+ rb_cmd = RING_BUFFER_GET_NEXT_SUBBUF;
+ else
+ rb_cmd = cmd;
switch (cmd) {
case RING_BUFFER_GET_NEXT_SUBBUF:
struct lib_ring_buffer *buf = stream->priv;
struct channel *chan = buf->backend.chan;
- ret = lttng_metadata_output_channel(stream, chan);
+ ret = lttng_metadata_output_channel(stream, chan, NULL);
if (ret > 0) {
lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
ret = 0;
*/
return -ENOSYS;
}
- case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
+ case RING_BUFFER_FLUSH_EMPTY:
+ lttng_fallthrough;
case RING_BUFFER_FLUSH:
{
struct lttng_metadata_stream *stream = filp->private_data;
* Before doing the actual ring buffer flush, write up to one
* packet of metadata in the ring buffer.
*/
- ret = lttng_metadata_output_channel(stream, chan);
+ ret = lttng_metadata_output_channel(stream, chan, NULL);
if (ret < 0)
goto err;
break;
return lttng_metadata_cache_dump(stream);
}
+ case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ struct channel *chan = buf->backend.chan;
+
+ ret = lttng_metadata_output_channel(stream, chan, &coherent);
+ if (ret > 0) {
+ lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+ ret = 0;
+ } else if (ret < 0) {
+ goto err;
+ }
+ break;
+ }
default:
break;
}
/* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
/* Performing lib ring buffer ioctl after our own. */
- ret = lib_ring_buffer_ioctl(filp, cmd, arg, buf);
+ ret = lib_ring_buffer_ioctl(filp, rb_cmd, arg, buf);
if (ret < 0)
goto err;
cmd, arg);
break;
}
+ case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
+ {
+ return put_u32(coherent, arg);
+ }
default:
break;
}
int ret;
struct lttng_metadata_stream *stream = filp->private_data;
struct lib_ring_buffer *buf = stream->priv;
+ unsigned int rb_cmd;
+ bool coherent;
+
+ if (cmd == RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
+ rb_cmd = RING_BUFFER_GET_NEXT_SUBBUF;
+ else
+ rb_cmd = cmd;
switch (cmd) {
case RING_BUFFER_GET_NEXT_SUBBUF:
struct lib_ring_buffer *buf = stream->priv;
struct channel *chan = buf->backend.chan;
- ret = lttng_metadata_output_channel(stream, chan);
+ ret = lttng_metadata_output_channel(stream, chan, NULL);
if (ret > 0) {
lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
ret = 0;
*/
return -ENOSYS;
}
- case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
+ case RING_BUFFER_FLUSH_EMPTY:
+ lttng_fallthrough;
case RING_BUFFER_FLUSH:
{
struct lttng_metadata_stream *stream = filp->private_data;
* Before doing the actual ring buffer flush, write up to one
* packet of metadata in the ring buffer.
*/
- ret = lttng_metadata_output_channel(stream, chan);
+ ret = lttng_metadata_output_channel(stream, chan, NULL);
if (ret < 0)
goto err;
break;
return lttng_metadata_cache_dump(stream);
}
+ case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ struct channel *chan = buf->backend.chan;
+
+ ret = lttng_metadata_output_channel(stream, chan, &coherent);
+ if (ret > 0) {
+ lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+ ret = 0;
+ } else if (ret < 0) {
+ goto err;
+ }
+ break;
+ }
default:
break;
}
/* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
/* Performing lib ring buffer ioctl after our own. */
- ret = lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
+ ret = lib_ring_buffer_compat_ioctl(filp, rb_cmd, arg, buf);
if (ret < 0)
goto err;
cmd, arg);
break;
}
+ case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
+ {
+ return put_u32(coherent, arg);
+ }
default:
break;
}
struct lttng_metadata_stream *stream = file->private_data;
struct lib_ring_buffer *buf = stream->priv;
+ mutex_lock(&stream->metadata_cache->lock);
+ list_del(&stream->list);
+ mutex_unlock(&stream->metadata_cache->lock);
kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
module_put(stream->transport->owner);
+ kfree(stream);
return lib_ring_buffer_release(inode, file, buf);
}
metadata_stream->priv = buf;
stream_priv = metadata_stream;
metadata_stream->transport = channel->transport;
+ /* Initial state is an empty metadata, considered as incoherent. */
+ metadata_stream->coherent = false;
/*
* Since life-time of metadata cache differs from that of
if (ret < 0)
goto fd_error;
+ mutex_lock(&session->metadata_cache->lock);
list_add(&metadata_stream->list,
&session->metadata_cache->metadata_stream);
+ mutex_unlock(&session->metadata_cache->lock);
return ret;
fd_error:
return ret;
}
+static
+int lttng_abi_validate_event_param(struct lttng_kernel_event *event_param)
+{
+ /* Limit ABI to implemented features. */
+ switch (event_param->instrumentation) {
+ case LTTNG_KERNEL_SYSCALL:
+ switch (event_param->u.syscall.entryexit) {
+ case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
+ break;
+ default:
+ return -EINVAL;
+ }
+ switch (event_param->u.syscall.abi) {
+ case LTTNG_KERNEL_SYSCALL_ABI_ALL:
+ break;
+ default:
+ return -EINVAL;
+ }
+ switch (event_param->u.syscall.match) {
+ case LTTNG_SYSCALL_MATCH_NAME:
+ break;
+ default:
+ return -EINVAL;
+ }
+ break;
+
+ case LTTNG_KERNEL_TRACEPOINT:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_KPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_KRETPROBE:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_NOOP:
+ lttng_fallthrough;
+ case LTTNG_KERNEL_UPROBE:
+ break;
+
+ case LTTNG_KERNEL_FUNCTION:
+ lttng_fallthrough;
+ default:
+ return -EINVAL;
+ }
+ return 0;
+}
+
static
int lttng_abi_create_event(struct file *channel_file,
struct lttng_kernel_event *event_param)
event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
break;
case LTTNG_KERNEL_FUNCTION:
- event_param->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
+ WARN_ON_ONCE(1);
+ /* Not implemented. */
break;
default:
break;
goto file_error;
}
/* The event holds a reference on the channel */
- if (atomic_long_add_unless(&channel_file->f_count,
- 1, INT_MAX) == INT_MAX) {
+ if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
ret = -EOVERFLOW;
goto refcount_error;
}
+ ret = lttng_abi_validate_event_param(event_param);
+ if (ret)
+ goto event_error;
if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
|| event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
struct lttng_enabler *enabler;
sizeof(uevent_param->u.kretprobe.symbol_name));
break;
case LTTNG_KERNEL_FUNCTION:
- memcpy(uevent_param->u.ftrace.symbol_name,
- old_uevent_param->u.ftrace.symbol_name,
- sizeof(uevent_param->u.ftrace.symbol_name));
+ WARN_ON_ONCE(1);
+ /* Not implemented. */
break;
default:
break;
default:
return -ENOIOCTLCMD;
}
-
}
/**
return lttng_enabler_attach_bytecode(enabler,
(struct lttng_kernel_filter_bytecode __user *) arg);
}
-
+ default:
+ WARN_ON_ONCE(1);
+ return -ENOSYS;
+ }
+ case LTTNG_KERNEL_ADD_CALLSITE:
+ switch (*evtype) {
+ case LTTNG_TYPE_EVENT:
+ event = file->private_data;
+ return lttng_event_add_callsite(event,
+ (struct lttng_kernel_event_callsite __user *) arg);
+ case LTTNG_TYPE_ENABLER:
+ return -EINVAL;
+ default:
+ WARN_ON_ONCE(1);
+ return -ENOSYS;
}
default:
return -ENOIOCTLCMD;
return put_user(val, (uint64_t __user *) arg);
}
+static int put_u32(uint32_t val, unsigned long arg)
+{
+ return put_user(val, (uint32_t __user *) arg);
+}
+
static long lttng_stream_ring_buffer_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
{
int ret = 0;
- wrapper_vmalloc_sync_all();
+ wrapper_vmalloc_sync_mappings();
lttng_clock_ref();
ret = lttng_tp_mempool_init();
}
lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
- <tng_fops, NULL);
+ <tng_proc_ops, NULL);
if (!lttng_proc_dentry) {
printk(KERN_ERR "Error creating LTTng control file\n");
projects / lttng-modules.git / blobdiff