X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=src%2Flttng-abi.c;h=219d20a044e284c63f1688a9a06df514b28bceb6;hp=88c92d91e0fd4d336c59ecdc371be25c1843d205;hb=HEAD;hpb=684a1e4d7e9a4cf1070e5202e419e1b9f6e9853c diff --git a/src/lttng-abi.c b/src/lttng-abi.c index 88c92d91..afd23373 100644 --- a/src/lttng-abi.c +++ b/src/lttng-abi.c @@ -23,6 +23,7 @@ * - Takes instrumentation source specific arguments. */ +#include #include #include #include @@ -34,14 +35,14 @@ #include #include #include +#include #include -#include #include -#include #include #include #include #include +#include #include #include #include @@ -64,7 +65,8 @@ static const struct file_operations lttng_session_fops; static const struct file_operations lttng_event_notifier_group_fops; static const struct file_operations lttng_channel_fops; static const struct file_operations lttng_metadata_fops; -static const struct file_operations lttng_event_fops; +static const struct file_operations lttng_event_recorder_event_fops; +static const struct file_operations lttng_event_recorder_enabler_fops; static struct file_operations lttng_stream_ring_buffer_file_operations; static int put_u64(uint64_t val, unsigned long arg); @@ -89,14 +91,14 @@ static int validate_zeroed_padding(char *p, size_t len) static int lttng_abi_create_session(void) { - struct lttng_session *session; + struct lttng_kernel_session *session; struct file *session_file; int session_fd, ret; session = lttng_session_create(); if (!session) return -ENOMEM; - session_fd = lttng_get_unused_fd(); + session_fd = get_unused_fd_flags(0); if (session_fd < 0) { ret = session_fd; goto fd_error; @@ -108,7 +110,7 @@ int lttng_abi_create_session(void) ret = PTR_ERR(session_file); goto file_error; } - session->file = session_file; + session->priv->file = session_file; fd_install(session_fd, session_file); return session_fd; @@ -119,6 +121,7 @@ fd_error: return ret; } +static void event_notifier_send_notification_work_wakeup(struct irq_work *entry) { struct lttng_event_notifier_group *event_notifier_group = @@ -138,7 +141,7 @@ int lttng_abi_create_event_notifier_group(void) if (!event_notifier_group) return -ENOMEM; - event_notifier_group_fd = lttng_get_unused_fd(); + event_notifier_group_fd = get_unused_fd_flags(0); if (event_notifier_group_fd < 0) { ret = event_notifier_group_fd; goto fd_error; @@ -171,7 +174,7 @@ int lttng_abi_tracepoint_list(void) struct file *tracepoint_list_file; int file_fd, ret; - file_fd = lttng_get_unused_fd(); + file_fd = get_unused_fd_flags(0); if (file_fd < 0) { ret = file_fd; goto fd_error; @@ -211,7 +214,7 @@ int lttng_abi_syscall_list(void) struct file *syscall_list_file; int file_fd, ret; - file_fd = lttng_get_unused_fd(); + file_fd = get_unused_fd_flags(0); if (file_fd < 0) { ret = file_fd; goto fd_error; @@ -240,7 +243,7 @@ fd_error: #endif static -void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v) +void lttng_abi_tracer_version(struct lttng_kernel_abi_tracer_version *v) { v->major = LTTNG_MODULES_MAJOR_VERSION; v->minor = LTTNG_MODULES_MINOR_VERSION; @@ -248,100 +251,100 @@ void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v) } static -void lttng_abi_tracer_abi_version(struct lttng_kernel_tracer_abi_version *v) +void lttng_abi_tracer_abi_version(struct lttng_kernel_abi_tracer_abi_version *v) { - v->major = LTTNG_MODULES_ABI_MAJOR_VERSION; - v->minor = LTTNG_MODULES_ABI_MINOR_VERSION; + v->major = LTTNG_KERNEL_ABI_MAJOR_VERSION; + v->minor = LTTNG_KERNEL_ABI_MINOR_VERSION; } static long lttng_abi_add_context(struct file *file, - struct lttng_kernel_context *context_param, - struct lttng_ctx **ctx, struct lttng_session *session) + struct lttng_kernel_abi_context *context_param, + struct lttng_kernel_ctx **ctx, struct lttng_kernel_session *session) { - if (session->been_active) + if (session->priv->been_active) return -EPERM; switch (context_param->ctx) { - case LTTNG_KERNEL_CONTEXT_PID: + case LTTNG_KERNEL_ABI_CONTEXT_PID: return lttng_add_pid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_PRIO: + case LTTNG_KERNEL_ABI_CONTEXT_PRIO: return lttng_add_prio_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_NICE: + case LTTNG_KERNEL_ABI_CONTEXT_NICE: return lttng_add_nice_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VPID: + case LTTNG_KERNEL_ABI_CONTEXT_VPID: return lttng_add_vpid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_TID: + case LTTNG_KERNEL_ABI_CONTEXT_TID: return lttng_add_tid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VTID: + case LTTNG_KERNEL_ABI_CONTEXT_VTID: return lttng_add_vtid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_PPID: + case LTTNG_KERNEL_ABI_CONTEXT_PPID: return lttng_add_ppid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VPPID: + case LTTNG_KERNEL_ABI_CONTEXT_VPPID: return lttng_add_vppid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_PERF_COUNTER: - context_param->u.perf_counter.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + case LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER: + context_param->u.perf_counter.name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; return lttng_add_perf_counter_to_ctx(context_param->u.perf_counter.type, context_param->u.perf_counter.config, context_param->u.perf_counter.name, ctx); - case LTTNG_KERNEL_CONTEXT_PROCNAME: + case LTTNG_KERNEL_ABI_CONTEXT_PROCNAME: return lttng_add_procname_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_HOSTNAME: + case LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME: return lttng_add_hostname_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_CPU_ID: + case LTTNG_KERNEL_ABI_CONTEXT_CPU_ID: return lttng_add_cpu_id_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE: + case LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE: return lttng_add_interruptible_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE: + case LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE: return lttng_add_need_reschedule_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE: + case LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE: return lttng_add_preemptible_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_MIGRATABLE: + case LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE: return lttng_add_migratable_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL: - case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER: + case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL: + case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER: return lttng_add_callstack_to_ctx(ctx, context_param->ctx); - case LTTNG_KERNEL_CONTEXT_CGROUP_NS: + case LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS: return lttng_add_cgroup_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_IPC_NS: + case LTTNG_KERNEL_ABI_CONTEXT_IPC_NS: return lttng_add_ipc_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_MNT_NS: + case LTTNG_KERNEL_ABI_CONTEXT_MNT_NS: return lttng_add_mnt_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_NET_NS: + case LTTNG_KERNEL_ABI_CONTEXT_NET_NS: return lttng_add_net_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_PID_NS: + case LTTNG_KERNEL_ABI_CONTEXT_PID_NS: return lttng_add_pid_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_USER_NS: + case LTTNG_KERNEL_ABI_CONTEXT_USER_NS: return lttng_add_user_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_UTS_NS: + case LTTNG_KERNEL_ABI_CONTEXT_UTS_NS: return lttng_add_uts_ns_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_UID: + case LTTNG_KERNEL_ABI_CONTEXT_UID: return lttng_add_uid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_EUID: + case LTTNG_KERNEL_ABI_CONTEXT_EUID: return lttng_add_euid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_SUID: + case LTTNG_KERNEL_ABI_CONTEXT_SUID: return lttng_add_suid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_GID: + case LTTNG_KERNEL_ABI_CONTEXT_GID: return lttng_add_gid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_EGID: + case LTTNG_KERNEL_ABI_CONTEXT_EGID: return lttng_add_egid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_SGID: + case LTTNG_KERNEL_ABI_CONTEXT_SGID: return lttng_add_sgid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VUID: + case LTTNG_KERNEL_ABI_CONTEXT_VUID: return lttng_add_vuid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VEUID: + case LTTNG_KERNEL_ABI_CONTEXT_VEUID: return lttng_add_veuid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VSUID: + case LTTNG_KERNEL_ABI_CONTEXT_VSUID: return lttng_add_vsuid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VGID: + case LTTNG_KERNEL_ABI_CONTEXT_VGID: return lttng_add_vgid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VEGID: + case LTTNG_KERNEL_ABI_CONTEXT_VEGID: return lttng_add_vegid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_VSGID: + case LTTNG_KERNEL_ABI_CONTEXT_VSGID: return lttng_add_vsgid_to_ctx(ctx); - case LTTNG_KERNEL_CONTEXT_TIME_NS: + case LTTNG_KERNEL_ABI_CONTEXT_TIME_NS: return lttng_add_time_ns_to_ctx(ctx); default: return -EINVAL; @@ -356,17 +359,17 @@ long lttng_abi_add_context(struct file *file, * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_SESSION + * LTTNG_KERNEL_ABI_SESSION * Returns a LTTng trace session file descriptor - * LTTNG_KERNEL_TRACER_VERSION + * LTTNG_KERNEL_ABI_TRACER_VERSION * Returns the LTTng kernel tracer version - * LTTNG_KERNEL_TRACEPOINT_LIST + * LTTNG_KERNEL_ABI_TRACEPOINT_LIST * Returns a file descriptor listing available tracepoints - * LTTNG_KERNEL_WAIT_QUIESCENT + * LTTNG_KERNEL_ABI_WAIT_QUIESCENT * Returns after all previously running probes have completed - * LTTNG_KERNEL_TRACER_ABI_VERSION + * LTTNG_KERNEL_ABI_TRACER_ABI_VERSION * Returns the LTTng kernel tracer ABI version - * LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_CREATE + * LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE * Returns a LTTng event notifier group file descriptor * * The returned session will be deleted when its file descriptor is closed. @@ -375,17 +378,17 @@ static long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { switch (cmd) { - case LTTNG_KERNEL_OLD_SESSION: - case LTTNG_KERNEL_SESSION: + case LTTNG_KERNEL_ABI_OLD_SESSION: + case LTTNG_KERNEL_ABI_SESSION: return lttng_abi_create_session(); - case LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_CREATE: + case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE: return lttng_abi_create_event_notifier_group(); - case LTTNG_KERNEL_OLD_TRACER_VERSION: + case LTTNG_KERNEL_ABI_OLD_TRACER_VERSION: { - struct lttng_kernel_tracer_version v; - struct lttng_kernel_old_tracer_version oldv; - struct lttng_kernel_old_tracer_version *uversion = - (struct lttng_kernel_old_tracer_version __user *) arg; + struct lttng_kernel_abi_tracer_version v; + struct lttng_kernel_abi_old_tracer_version oldv; + struct lttng_kernel_abi_old_tracer_version *uversion = + (struct lttng_kernel_abi_old_tracer_version __user *) arg; lttng_abi_tracer_version(&v); oldv.major = v.major; @@ -396,11 +399,11 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return -EFAULT; return 0; } - case LTTNG_KERNEL_TRACER_VERSION: + case LTTNG_KERNEL_ABI_TRACER_VERSION: { - struct lttng_kernel_tracer_version version; - struct lttng_kernel_tracer_version *uversion = - (struct lttng_kernel_tracer_version __user *) arg; + struct lttng_kernel_abi_tracer_version version; + struct lttng_kernel_abi_tracer_version *uversion = + (struct lttng_kernel_abi_tracer_version __user *) arg; lttng_abi_tracer_version(&version); @@ -408,11 +411,11 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return -EFAULT; return 0; } - case LTTNG_KERNEL_TRACER_ABI_VERSION: + case LTTNG_KERNEL_ABI_TRACER_ABI_VERSION: { - struct lttng_kernel_tracer_abi_version version; - struct lttng_kernel_tracer_abi_version *uversion = - (struct lttng_kernel_tracer_abi_version __user *) arg; + struct lttng_kernel_abi_tracer_abi_version version; + struct lttng_kernel_abi_tracer_abi_version *uversion = + (struct lttng_kernel_abi_tracer_abi_version __user *) arg; lttng_abi_tracer_abi_version(&version); @@ -420,21 +423,21 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return -EFAULT; return 0; } - case LTTNG_KERNEL_OLD_TRACEPOINT_LIST: - case LTTNG_KERNEL_TRACEPOINT_LIST: + case LTTNG_KERNEL_ABI_OLD_TRACEPOINT_LIST: + case LTTNG_KERNEL_ABI_TRACEPOINT_LIST: return lttng_abi_tracepoint_list(); - case LTTNG_KERNEL_SYSCALL_LIST: + case LTTNG_KERNEL_ABI_SYSCALL_LIST: return lttng_abi_syscall_list(); - case LTTNG_KERNEL_OLD_WAIT_QUIESCENT: - case LTTNG_KERNEL_WAIT_QUIESCENT: + case LTTNG_KERNEL_ABI_OLD_WAIT_QUIESCENT: + case LTTNG_KERNEL_ABI_WAIT_QUIESCENT: synchronize_trace(); return 0; - case LTTNG_KERNEL_OLD_CALIBRATE: + case LTTNG_KERNEL_ABI_OLD_CALIBRATE: { - struct lttng_kernel_old_calibrate __user *ucalibrate = - (struct lttng_kernel_old_calibrate __user *) arg; - struct lttng_kernel_old_calibrate old_calibrate; - struct lttng_kernel_calibrate calibrate; + struct lttng_kernel_abi_old_calibrate __user *ucalibrate = + (struct lttng_kernel_abi_old_calibrate __user *) arg; + struct lttng_kernel_abi_old_calibrate old_calibrate; + struct lttng_kernel_abi_calibrate calibrate; int ret; if (copy_from_user(&old_calibrate, ucalibrate, sizeof(old_calibrate))) @@ -445,11 +448,11 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return -EFAULT; return ret; } - case LTTNG_KERNEL_CALIBRATE: + case LTTNG_KERNEL_ABI_CALIBRATE: { - struct lttng_kernel_calibrate __user *ucalibrate = - (struct lttng_kernel_calibrate __user *) arg; - struct lttng_kernel_calibrate calibrate; + struct lttng_kernel_abi_calibrate __user *ucalibrate = + (struct lttng_kernel_abi_calibrate __user *) arg; + struct lttng_kernel_abi_calibrate calibrate; int ret; if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate))) @@ -483,18 +486,18 @@ static const struct file_operations lttng_proc_ops = { static int lttng_abi_create_channel(struct file *session_file, - struct lttng_kernel_channel *chan_param, + struct lttng_kernel_abi_channel *chan_param, enum channel_type channel_type) { - struct lttng_session *session = session_file->private_data; + struct lttng_kernel_session *session = session_file->private_data; const struct file_operations *fops = NULL; const char *transport_name; - struct lttng_channel *chan; + struct lttng_kernel_channel_buffer *chan; struct file *chan_file; int chan_fd; int ret = 0; - chan_fd = lttng_get_unused_fd(); + chan_fd = get_unused_fd_flags(0); if (chan_fd < 0) { ret = chan_fd; goto fd_error; @@ -517,10 +520,10 @@ int lttng_abi_create_channel(struct file *session_file, } switch (channel_type) { case PER_CPU_CHANNEL: - if (chan_param->output == LTTNG_KERNEL_SPLICE) { + if (chan_param->output == LTTNG_KERNEL_ABI_SPLICE) { transport_name = chan_param->overwrite ? "relay-overwrite" : "relay-discard"; - } else if (chan_param->output == LTTNG_KERNEL_MMAP) { + } else if (chan_param->output == LTTNG_KERNEL_ABI_MMAP) { transport_name = chan_param->overwrite ? "relay-overwrite-mmap" : "relay-discard-mmap"; } else { @@ -528,9 +531,9 @@ int lttng_abi_create_channel(struct file *session_file, } break; case METADATA_CHANNEL: - if (chan_param->output == LTTNG_KERNEL_SPLICE) + if (chan_param->output == LTTNG_KERNEL_ABI_SPLICE) transport_name = "relay-metadata"; - else if (chan_param->output == LTTNG_KERNEL_MMAP) + else if (chan_param->output == LTTNG_KERNEL_ABI_MMAP) transport_name = "relay-metadata-mmap"; else return -EINVAL; @@ -547,7 +550,7 @@ int lttng_abi_create_channel(struct file *session_file, * We tolerate no failure path after channel creation. It will stay * invariant for the rest of the session. */ - chan = lttng_channel_create(session, transport_name, NULL, + chan = lttng_channel_buffer_create(session, transport_name, NULL, chan_param->subbuf_size, chan_param->num_subbuf, chan_param->switch_timer_interval, @@ -557,7 +560,7 @@ int lttng_abi_create_channel(struct file *session_file, ret = -EINVAL; goto chan_error; } - chan->file = chan_file; + chan->priv->parent.file = chan_file; chan_file->private_data = chan; fd_install(chan_fd, chan_file); @@ -574,36 +577,36 @@ fd_error: } static -int lttng_abi_session_set_name(struct lttng_session *session, - struct lttng_kernel_session_name *name) +int lttng_abi_session_set_name(struct lttng_kernel_session *session, + struct lttng_kernel_abi_session_name *name) { size_t len; - len = strnlen(name->name, LTTNG_KERNEL_SESSION_NAME_LEN); + len = strnlen(name->name, LTTNG_KERNEL_ABI_SESSION_NAME_LEN); - if (len == LTTNG_KERNEL_SESSION_NAME_LEN) { + if (len == LTTNG_KERNEL_ABI_SESSION_NAME_LEN) { /* Name is too long/malformed */ return -EINVAL; } - strcpy(session->name, name->name); + strcpy(session->priv->name, name->name); return 0; } static -int lttng_abi_session_set_creation_time(struct lttng_session *session, - struct lttng_kernel_session_creation_time *time) +int lttng_abi_session_set_creation_time(struct lttng_kernel_session *session, + struct lttng_kernel_abi_session_creation_time *time) { size_t len; - len = strnlen(time->iso8601, LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN); + len = strnlen(time->iso8601, LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN); - if (len == LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN) { + if (len == LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN) { /* Time is too long/malformed */ return -EINVAL; } - strcpy(session->creation_time, time->iso8601); + strcpy(session->priv->creation_time, time->iso8601); return 0; } @@ -627,15 +630,15 @@ static long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct lttng_counter *counter = file->private_data; - size_t indexes[LTTNG_KERNEL_COUNTER_DIMENSION_MAX] = { 0 }; + size_t indexes[LTTNG_KERNEL_ABI_COUNTER_DIMENSION_MAX] = { 0 }; int i; switch (cmd) { - case LTTNG_KERNEL_COUNTER_READ: + case LTTNG_KERNEL_ABI_COUNTER_READ: { - struct lttng_kernel_counter_read local_counter_read; - struct lttng_kernel_counter_read __user *ucounter_read = - (struct lttng_kernel_counter_read __user *) arg; + struct lttng_kernel_abi_counter_read local_counter_read; + struct lttng_kernel_abi_counter_read __user *ucounter_read = + (struct lttng_kernel_abi_counter_read __user *) arg; bool overflow, underflow; int64_t value; int32_t cpu; @@ -647,6 +650,8 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) if (validate_zeroed_padding(local_counter_read.padding, sizeof(local_counter_read.padding))) return -EINVAL; + if (local_counter_read.index.number_dimensions > LTTNG_KERNEL_ABI_COUNTER_DIMENSION_MAX) + return -EINVAL; /* Cast all indexes into size_t. */ for (i = 0; i < local_counter_read.index.number_dimensions; i++) @@ -667,11 +672,11 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return 0; } - case LTTNG_KERNEL_COUNTER_AGGREGATE: + case LTTNG_KERNEL_ABI_COUNTER_AGGREGATE: { - struct lttng_kernel_counter_aggregate local_counter_aggregate; - struct lttng_kernel_counter_aggregate __user *ucounter_aggregate = - (struct lttng_kernel_counter_aggregate __user *) arg; + struct lttng_kernel_abi_counter_aggregate local_counter_aggregate; + struct lttng_kernel_abi_counter_aggregate __user *ucounter_aggregate = + (struct lttng_kernel_abi_counter_aggregate __user *) arg; bool overflow, underflow; int64_t value; int ret; @@ -682,6 +687,8 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) if (validate_zeroed_padding(local_counter_aggregate.padding, sizeof(local_counter_aggregate.padding))) return -EINVAL; + if (local_counter_aggregate.index.number_dimensions > LTTNG_KERNEL_ABI_COUNTER_DIMENSION_MAX) + return -EINVAL; /* Cast all indexes into size_t. */ for (i = 0; i < local_counter_aggregate.index.number_dimensions; i++) @@ -701,11 +708,11 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return 0; } - case LTTNG_KERNEL_COUNTER_CLEAR: + case LTTNG_KERNEL_ABI_COUNTER_CLEAR: { - struct lttng_kernel_counter_clear local_counter_clear; - struct lttng_kernel_counter_clear __user *ucounter_clear = - (struct lttng_kernel_counter_clear __user *) arg; + struct lttng_kernel_abi_counter_clear local_counter_clear; + struct lttng_kernel_abi_counter_clear __user *ucounter_clear = + (struct lttng_kernel_abi_counter_clear __user *) arg; if (copy_from_user(&local_counter_clear, ucounter_clear, sizeof(local_counter_clear))) @@ -713,6 +720,8 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) if (validate_zeroed_padding(local_counter_clear.padding, sizeof(local_counter_clear.padding))) return -EINVAL; + if (local_counter_clear.index.number_dimensions > LTTNG_KERNEL_ABI_COUNTER_DIMENSION_MAX) + return -EINVAL; /* Cast all indexes into size_t. */ for (i = 0; i < local_counter_clear.index.number_dimensions; i++) @@ -721,7 +730,6 @@ long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_kernel_counter_clear(counter, indexes); } default: - WARN_ON_ONCE(1); return -ENOSYS; } } @@ -737,20 +745,20 @@ static const struct file_operations lttng_counter_fops = { static -enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker) +enum tracker_type get_tracker_type(struct lttng_kernel_abi_tracker_args *tracker) { switch (tracker->type) { - case LTTNG_KERNEL_TRACKER_PID: + case LTTNG_KERNEL_ABI_TRACKER_PID: return TRACKER_PID; - case LTTNG_KERNEL_TRACKER_VPID: + case LTTNG_KERNEL_ABI_TRACKER_VPID: return TRACKER_VPID; - case LTTNG_KERNEL_TRACKER_UID: + case LTTNG_KERNEL_ABI_TRACKER_UID: return TRACKER_UID; - case LTTNG_KERNEL_TRACKER_VUID: + case LTTNG_KERNEL_ABI_TRACKER_VUID: return TRACKER_VUID; - case LTTNG_KERNEL_TRACKER_GID: + case LTTNG_KERNEL_ABI_TRACKER_GID: return TRACKER_GID; - case LTTNG_KERNEL_TRACKER_VGID: + case LTTNG_KERNEL_ABI_TRACKER_VGID: return TRACKER_VGID; default: return TRACKER_UNKNOWN; @@ -765,21 +773,21 @@ enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker) * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_CHANNEL + * LTTNG_KERNEL_ABI_CHANNEL * Returns a LTTng channel file descriptor - * LTTNG_KERNEL_ENABLE + * LTTNG_KERNEL_ABI_ENABLE * Enables tracing for a session (weak enable) - * LTTNG_KERNEL_DISABLE + * LTTNG_KERNEL_ABI_DISABLE * Disables tracing for a session (strong disable) - * LTTNG_KERNEL_METADATA + * LTTNG_KERNEL_ABI_METADATA * Returns a LTTng metadata file descriptor - * LTTNG_KERNEL_SESSION_TRACK_PID + * LTTNG_KERNEL_ABI_SESSION_TRACK_PID * Add PID to session PID tracker - * LTTNG_KERNEL_SESSION_UNTRACK_PID + * LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID * Remove PID from session PID tracker - * LTTNG_KERNEL_SESSION_TRACK_ID + * LTTNG_KERNEL_ABI_SESSION_TRACK_ID * Add ID to tracker - * LTTNG_KERNEL_SESSION_UNTRACK_ID + * LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID * Remove ID from tracker * * The returned channel will be deleted when its file descriptor is closed. @@ -787,16 +795,47 @@ enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker) static 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; + struct lttng_kernel_session *session = file->private_data; + struct lttng_kernel_abi_channel chan_param; + struct lttng_kernel_abi_old_channel old_chan_param; + + /* + * Handle backward compatibility. OLD commands have wrong + * directions, replace them by the correct direction. + */ + switch (cmd) { + case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_PID: + cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_PID; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_PID: + cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_ID: + cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_ID; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_ID: + cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_LIST_TRACKER_IDS: + cmd = LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_SET_NAME: + cmd = LTTNG_KERNEL_ABI_SESSION_SET_NAME; + break; + case LTTNG_KERNEL_ABI_OLD_SESSION_SET_CREATION_TIME: + cmd = LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME; + break; + default: + /* Nothing to do. */ + break; + } switch (cmd) { - case LTTNG_KERNEL_OLD_CHANNEL: + case LTTNG_KERNEL_ABI_OLD_CHANNEL: { if (copy_from_user(&old_chan_param, - (struct lttng_kernel_old_channel __user *) arg, - sizeof(struct lttng_kernel_old_channel))) + (struct lttng_kernel_abi_old_channel __user *) arg, + sizeof(struct lttng_kernel_abi_old_channel))) return -EFAULT; chan_param.overwrite = old_chan_param.overwrite; chan_param.subbuf_size = old_chan_param.subbuf_size; @@ -808,30 +847,30 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_abi_create_channel(file, &chan_param, PER_CPU_CHANNEL); } - case LTTNG_KERNEL_CHANNEL: + case LTTNG_KERNEL_ABI_CHANNEL: { if (copy_from_user(&chan_param, - (struct lttng_kernel_channel __user *) arg, - sizeof(struct lttng_kernel_channel))) + (struct lttng_kernel_abi_channel __user *) arg, + sizeof(struct lttng_kernel_abi_channel))) return -EFAULT; return lttng_abi_create_channel(file, &chan_param, PER_CPU_CHANNEL); } - case LTTNG_KERNEL_OLD_SESSION_START: - case LTTNG_KERNEL_OLD_ENABLE: - case LTTNG_KERNEL_SESSION_START: - case LTTNG_KERNEL_ENABLE: + case LTTNG_KERNEL_ABI_OLD_SESSION_START: + case LTTNG_KERNEL_ABI_OLD_ENABLE: + case LTTNG_KERNEL_ABI_SESSION_START: + case LTTNG_KERNEL_ABI_ENABLE: return lttng_session_enable(session); - case LTTNG_KERNEL_OLD_SESSION_STOP: - case LTTNG_KERNEL_OLD_DISABLE: - case LTTNG_KERNEL_SESSION_STOP: - case LTTNG_KERNEL_DISABLE: + case LTTNG_KERNEL_ABI_OLD_SESSION_STOP: + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_SESSION_STOP: + case LTTNG_KERNEL_ABI_DISABLE: return lttng_session_disable(session); - case LTTNG_KERNEL_OLD_METADATA: + case LTTNG_KERNEL_ABI_OLD_METADATA: { if (copy_from_user(&old_chan_param, - (struct lttng_kernel_old_channel __user *) arg, - sizeof(struct lttng_kernel_old_channel))) + (struct lttng_kernel_abi_old_channel __user *) arg, + sizeof(struct lttng_kernel_abi_old_channel))) return -EFAULT; chan_param.overwrite = old_chan_param.overwrite; chan_param.subbuf_size = old_chan_param.subbuf_size; @@ -843,41 +882,41 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_abi_create_channel(file, &chan_param, METADATA_CHANNEL); } - case LTTNG_KERNEL_METADATA: + case LTTNG_KERNEL_ABI_METADATA: { if (copy_from_user(&chan_param, - (struct lttng_kernel_channel __user *) arg, - sizeof(struct lttng_kernel_channel))) + (struct lttng_kernel_abi_channel __user *) arg, + sizeof(struct lttng_kernel_abi_channel))) return -EFAULT; return lttng_abi_create_channel(file, &chan_param, METADATA_CHANNEL); } - case LTTNG_KERNEL_SESSION_TRACK_PID: + case LTTNG_KERNEL_ABI_SESSION_TRACK_PID: return lttng_session_track_id(session, TRACKER_PID, (int) arg); - case LTTNG_KERNEL_SESSION_UNTRACK_PID: + case LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID: return lttng_session_untrack_id(session, TRACKER_PID, (int) arg); - case LTTNG_KERNEL_SESSION_TRACK_ID: + case LTTNG_KERNEL_ABI_SESSION_TRACK_ID: { - struct lttng_kernel_tracker_args tracker; + struct lttng_kernel_abi_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))) + (struct lttng_kernel_abi_tracker_args __user *) arg, + sizeof(struct lttng_kernel_abi_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: + case LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID: { - struct lttng_kernel_tracker_args tracker; + struct lttng_kernel_abi_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))) + (struct lttng_kernel_abi_tracker_args __user *) arg, + sizeof(struct lttng_kernel_abi_tracker_args))) return -EFAULT; tracker_type = get_tracker_type(&tracker); if (tracker_type == TRACKER_UNKNOWN) @@ -885,43 +924,43 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_session_untrack_id(session, tracker_type, tracker.id); } - case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS: + case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_PIDS: return lttng_session_list_tracker_ids(session, TRACKER_PID); - case LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS: + case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS: { - struct lttng_kernel_tracker_args tracker; + struct lttng_kernel_abi_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))) + (struct lttng_kernel_abi_tracker_args __user *) arg, + sizeof(struct lttng_kernel_abi_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: + case LTTNG_KERNEL_ABI_SESSION_METADATA_REGEN: return lttng_session_metadata_regenerate(session); - case LTTNG_KERNEL_SESSION_STATEDUMP: + case LTTNG_KERNEL_ABI_SESSION_STATEDUMP: return lttng_session_statedump(session); - case LTTNG_KERNEL_SESSION_SET_NAME: + case LTTNG_KERNEL_ABI_SESSION_SET_NAME: { - struct lttng_kernel_session_name name; + struct lttng_kernel_abi_session_name name; if (copy_from_user(&name, - (struct lttng_kernel_session_name __user *) arg, - sizeof(struct lttng_kernel_session_name))) + (struct lttng_kernel_abi_session_name __user *) arg, + sizeof(struct lttng_kernel_abi_session_name))) return -EFAULT; return lttng_abi_session_set_name(session, &name); } - case LTTNG_KERNEL_SESSION_SET_CREATION_TIME: + case LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME: { - struct lttng_kernel_session_creation_time time; + struct lttng_kernel_abi_session_creation_time time; if (copy_from_user(&time, - (struct lttng_kernel_session_creation_time __user *) arg, - sizeof(struct lttng_kernel_session_creation_time))) + (struct lttng_kernel_abi_session_creation_time __user *) arg, + sizeof(struct lttng_kernel_abi_session_creation_time))) return -EFAULT; return lttng_abi_session_set_creation_time(session, &time); } @@ -941,7 +980,7 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) static int lttng_session_release(struct inode *inode, struct file *file) { - struct lttng_session *session = file->private_data; + struct lttng_kernel_session *session = file->private_data; if (session) lttng_session_destroy(session); @@ -966,8 +1005,8 @@ ssize_t lttng_event_notifier_group_notif_read(struct file *filp, char __user *us size_t count, loff_t *ppos) { struct lttng_event_notifier_group *event_notifier_group = filp->private_data; - struct channel *chan = event_notifier_group->chan; - struct lib_ring_buffer *buf = event_notifier_group->buf; + struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan; + struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf; ssize_t read_count = 0, len; size_t read_offset; @@ -977,7 +1016,7 @@ ssize_t lttng_event_notifier_group_notif_read(struct file *filp, char __user *us /* Finish copy of previous record */ if (*ppos != 0) { - if (read_count < count) { + if (count != 0) { len = chan->iter.len_left; read_offset = *ppos; goto skip_get_next; @@ -1057,7 +1096,8 @@ nodata: chan->iter.len_left = 0; put_record: - lib_ring_buffer_put_current_record(buf); + if (*ppos == 0) + lib_ring_buffer_put_current_record(buf); return read_count; } @@ -1072,9 +1112,9 @@ unsigned int lttng_event_notifier_group_notif_poll(struct file *filp, { unsigned int mask = 0; struct lttng_event_notifier_group *event_notifier_group = filp->private_data; - struct channel *chan = event_notifier_group->chan; - struct lib_ring_buffer *buf = event_notifier_group->buf; - const struct lib_ring_buffer_config *config = &chan->backend.config; + struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan; + struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf; + const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config; int finalized, disabled; unsigned long consumed, offset; size_t subbuffer_header_size = config->cb.subbuffer_header_size(); @@ -1146,7 +1186,7 @@ retry: static int lttng_event_notifier_group_notif_open(struct inode *inode, struct file *file) { struct lttng_event_notifier_group *event_notifier_group = inode->i_private; - struct lib_ring_buffer *buf = event_notifier_group->buf; + struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf; file->private_data = event_notifier_group; return lib_ring_buffer_open(inode, file, buf); @@ -1162,7 +1202,7 @@ static int lttng_event_notifier_group_notif_open(struct inode *inode, struct fil static int lttng_event_notifier_group_notif_release(struct inode *inode, struct file *file) { struct lttng_event_notifier_group *event_notifier_group = file->private_data; - struct lib_ring_buffer *buf = event_notifier_group->buf; + struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf; int ret; ret = lib_ring_buffer_release(inode, file, buf); @@ -1192,7 +1232,7 @@ unsigned int lttng_metadata_ring_buffer_poll(struct file *filp, poll_table *wait) { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer *buf = stream->priv; int finalized; unsigned int mask = 0; @@ -1268,21 +1308,21 @@ long lttng_metadata_ring_buffer_ioctl(struct file *filp, { int ret; struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_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; + if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK) + rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF; else rb_cmd = cmd; switch (cmd) { - case RING_BUFFER_GET_NEXT_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF: { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; ret = lttng_metadata_output_channel(stream, chan, NULL); if (ret > 0) { @@ -1292,19 +1332,20 @@ long lttng_metadata_ring_buffer_ioctl(struct file *filp, goto err; break; } - case RING_BUFFER_GET_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF: { /* * Random access is not allowed for metadata channel. */ return -ENOSYS; } - case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */ - case RING_BUFFER_FLUSH: + case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH: { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; /* * Before doing the actual ring buffer flush, write up to one @@ -1315,23 +1356,23 @@ long lttng_metadata_ring_buffer_ioctl(struct file *filp, goto err; break; } - case RING_BUFFER_GET_METADATA_VERSION: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION: { struct lttng_metadata_stream *stream = filp->private_data; return put_u64(stream->version, arg); } - case RING_BUFFER_METADATA_CACHE_DUMP: + case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP: { struct lttng_metadata_stream *stream = filp->private_data; return lttng_metadata_cache_dump(stream); } - case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: + case LTTNG_KERNEL_ABI_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; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; ret = lttng_metadata_output_channel(stream, chan, &coherent); if (ret > 0) { @@ -1353,13 +1394,13 @@ long lttng_metadata_ring_buffer_ioctl(struct file *filp, goto err; switch (cmd) { - case RING_BUFFER_PUT_NEXT_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF: { lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp, cmd, arg); break; } - case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: { return put_u32(coherent, arg); } @@ -1377,21 +1418,21 @@ long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp, { int ret; struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_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; + if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK) + rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF; else rb_cmd = cmd; switch (cmd) { - case RING_BUFFER_GET_NEXT_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF: { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; ret = lttng_metadata_output_channel(stream, chan, NULL); if (ret > 0) { @@ -1401,19 +1442,20 @@ long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp, goto err; break; } - case RING_BUFFER_GET_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF: { /* * Random access is not allowed for metadata channel. */ return -ENOSYS; } - case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */ - case RING_BUFFER_FLUSH: + case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH: { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; /* * Before doing the actual ring buffer flush, write up to one @@ -1424,23 +1466,23 @@ long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp, goto err; break; } - case RING_BUFFER_GET_METADATA_VERSION: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION: { struct lttng_metadata_stream *stream = filp->private_data; return put_u64(stream->version, arg); } - case RING_BUFFER_METADATA_CACHE_DUMP: + case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP: { struct lttng_metadata_stream *stream = filp->private_data; return lttng_metadata_cache_dump(stream); } - case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: + case LTTNG_KERNEL_ABI_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; + struct lttng_kernel_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; ret = lttng_metadata_output_channel(stream, chan, &coherent); if (ret > 0) { @@ -1462,13 +1504,13 @@ long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp, goto err; switch (cmd) { - case RING_BUFFER_PUT_NEXT_SUBBUF: + case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF: { lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp, cmd, arg); break; } - case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK: { return put_u32(coherent, arg); } @@ -1488,7 +1530,7 @@ static int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file) { struct lttng_metadata_stream *stream = inode->i_private; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer *buf = stream->priv; file->private_data = buf; /* @@ -1506,7 +1548,7 @@ static int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file) { struct lttng_metadata_stream *stream = file->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer *buf = stream->priv; mutex_lock(&stream->metadata_cache->lock); list_del(&stream->list); @@ -1523,7 +1565,7 @@ ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos, unsigned int flags) { struct lttng_metadata_stream *stream = in->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer *buf = stream->priv; return lib_ring_buffer_splice_read(in, ppos, pipe, len, flags, buf); @@ -1534,7 +1576,7 @@ int lttng_metadata_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma) { struct lttng_metadata_stream *stream = filp->private_data; - struct lib_ring_buffer *buf = stream->priv; + struct lttng_kernel_ring_buffer *buf = stream->priv; return lib_ring_buffer_mmap(filp, vma, buf); } @@ -1561,7 +1603,7 @@ int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv, int stream_fd, ret; struct file *stream_file; - stream_fd = lttng_get_unused_fd(); + stream_fd = get_unused_fd_flags(0); if (stream_fd < 0) { ret = stream_fd; goto fd_error; @@ -1594,12 +1636,12 @@ fd_error: static int lttng_abi_open_stream(struct file *channel_file) { - struct lttng_channel *channel = channel_file->private_data; - struct lib_ring_buffer *buf; + struct lttng_kernel_channel_buffer *channel = channel_file->private_data; + struct lttng_kernel_ring_buffer *buf; int ret; void *stream_priv; - buf = channel->ops->buffer_read_open(channel->chan); + buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan); if (!buf) return -ENOENT; @@ -1613,21 +1655,21 @@ int lttng_abi_open_stream(struct file *channel_file) return ret; fd_error: - channel->ops->buffer_read_close(buf); + channel->ops->priv->buffer_read_close(buf); return ret; } static int lttng_abi_open_metadata_stream(struct file *channel_file) { - struct lttng_channel *channel = channel_file->private_data; - struct lttng_session *session = channel->session; - struct lib_ring_buffer *buf; + struct lttng_kernel_channel_buffer *channel = channel_file->private_data; + struct lttng_kernel_session *session = channel->parent.session; + struct lttng_kernel_ring_buffer *buf; int ret; struct lttng_metadata_stream *metadata_stream; void *stream_priv; - buf = channel->ops->buffer_read_open(channel->chan); + buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan); if (!buf) return -ENOENT; @@ -1637,11 +1679,11 @@ int lttng_abi_open_metadata_stream(struct file *channel_file) ret = -ENOMEM; goto nomem; } - metadata_stream->metadata_cache = session->metadata_cache; + metadata_stream->metadata_cache = session->priv->metadata_cache; init_waitqueue_head(&metadata_stream->read_wait); metadata_stream->priv = buf; stream_priv = metadata_stream; - metadata_stream->transport = channel->transport; + metadata_stream->transport = channel->priv->transport; /* Initial state is an empty metadata, considered as incoherent. */ metadata_stream->coherent = false; @@ -1655,7 +1697,7 @@ int lttng_abi_open_metadata_stream(struct file *channel_file) goto notransport; } - if (!lttng_kref_get(&session->metadata_cache->refcount)) { + if (!lttng_kref_get(&session->priv->metadata_cache->refcount)) { ret = -EOVERFLOW; goto kref_error; } @@ -1666,20 +1708,20 @@ int lttng_abi_open_metadata_stream(struct file *channel_file) if (ret < 0) goto fd_error; - mutex_lock(&session->metadata_cache->lock); + mutex_lock(&session->priv->metadata_cache->lock); list_add(&metadata_stream->list, - &session->metadata_cache->metadata_stream); - mutex_unlock(&session->metadata_cache->lock); + &session->priv->metadata_cache->metadata_stream); + mutex_unlock(&session->priv->metadata_cache->lock); return ret; fd_error: - kref_put(&session->metadata_cache->refcount, metadata_cache_destroy); + kref_put(&session->priv->metadata_cache->refcount, metadata_cache_destroy); kref_error: module_put(metadata_stream->transport->owner); notransport: kfree(metadata_stream); nomem: - channel->ops->buffer_read_close(buf); + channel->ops->priv->buffer_read_close(buf); return ret; } @@ -1687,12 +1729,12 @@ static int lttng_abi_open_event_notifier_group_stream(struct file *notif_file) { struct lttng_event_notifier_group *event_notifier_group = notif_file->private_data; - struct channel *chan = event_notifier_group->chan; - struct lib_ring_buffer *buf; + struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan; + struct lttng_kernel_ring_buffer *buf; int ret; void *stream_priv; - buf = event_notifier_group->ops->buffer_read_open(chan); + buf = event_notifier_group->ops->priv->buffer_read_open(chan); if (!buf) return -ENOENT; @@ -1714,56 +1756,64 @@ int lttng_abi_open_event_notifier_group_stream(struct file *notif_file) fd_error: atomic_long_dec(¬if_file->f_count); refcount_error: - event_notifier_group->ops->buffer_read_close(buf); + event_notifier_group->ops->priv->buffer_read_close(buf); return ret; } static -int lttng_abi_validate_event_param(struct lttng_kernel_event *event_param) +int lttng_abi_validate_event_param(struct lttng_kernel_abi_event *event_param) { /* Limit ABI to implemented features. */ switch (event_param->instrumentation) { - case LTTNG_KERNEL_SYSCALL: + case LTTNG_KERNEL_ABI_SYSCALL: switch (event_param->u.syscall.entryexit) { - case LTTNG_KERNEL_SYSCALL_ENTRY: /* Fall-through */ - case LTTNG_KERNEL_SYSCALL_EXIT: /* Fall-through */ - case LTTNG_KERNEL_SYSCALL_ENTRYEXIT: + case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL_EXIT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: break; default: return -EINVAL; } switch (event_param->u.syscall.abi) { - case LTTNG_KERNEL_SYSCALL_ABI_ALL: + case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL: break; default: return -EINVAL; } switch (event_param->u.syscall.match) { - case LTTNG_KERNEL_SYSCALL_MATCH_NAME: + case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME: break; default: return -EINVAL; } break; - case LTTNG_KERNEL_KRETPROBE: + case LTTNG_KERNEL_ABI_KRETPROBE: switch (event_param->u.kretprobe.entryexit) { - case LTTNG_KERNEL_SYSCALL_ENTRYEXIT: + case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: break; - case LTTNG_KERNEL_SYSCALL_ENTRY: /* Fall-through */ - case LTTNG_KERNEL_SYSCALL_EXIT: /* Fall-through */ + case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL_EXIT: + lttng_fallthrough; default: return -EINVAL; } break; - case LTTNG_KERNEL_TRACEPOINT: /* Fall-through */ - case LTTNG_KERNEL_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_UPROBE: + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: break; - case LTTNG_KERNEL_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: return -EINVAL; } @@ -1772,36 +1822,59 @@ int lttng_abi_validate_event_param(struct lttng_kernel_event *event_param) static int lttng_abi_create_event(struct file *channel_file, - struct lttng_kernel_event *event_param) + struct lttng_kernel_abi_event *event_param) { - struct lttng_channel *channel = channel_file->private_data; + const struct file_operations *fops; + struct lttng_kernel_channel_buffer *channel = channel_file->private_data; int event_fd, ret; struct file *event_file; void *priv; - event_param->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + event_param->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; switch (event_param->instrumentation) { - case LTTNG_KERNEL_KRETPROBE: - event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + case LTTNG_KERNEL_ABI_KRETPROBE: + event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; - case LTTNG_KERNEL_KPROBE: - event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + case LTTNG_KERNEL_ABI_KPROBE: + event_param->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; - case LTTNG_KERNEL_FUNCTION: + case LTTNG_KERNEL_ABI_FUNCTION: WARN_ON_ONCE(1); /* Not implemented. */ break; default: break; } - event_fd = lttng_get_unused_fd(); + + switch (event_param->instrumentation) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + fops = <tng_event_recorder_enabler_fops; + break; + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + fops = <tng_event_recorder_event_fops; + break; + + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; + default: + return -EINVAL; + } + + event_fd = get_unused_fd_flags(0); if (event_fd < 0) { ret = event_fd; goto fd_error; } event_file = anon_inode_getfile("[lttng_event]", - <tng_event_fops, - NULL, O_RDWR); + fops, NULL, O_RDWR); if (IS_ERR(event_file)) { ret = PTR_ERR(event_file); goto file_error; @@ -1816,50 +1889,63 @@ int lttng_abi_create_event(struct file *channel_file, goto event_error; switch (event_param->instrumentation) { - case LTTNG_KERNEL_TRACEPOINT: /* Fall-through */ - case LTTNG_KERNEL_SYSCALL: + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: { - struct lttng_event_enabler *event_enabler; + struct lttng_event_recorder_enabler *event_enabler; if (strutils_is_star_glob_pattern(event_param->name)) { /* * If the event name is a star globbing pattern, * we create the special star globbing enabler. */ - event_enabler = lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB, + event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB, event_param, channel); } else { - event_enabler = lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_NAME, + event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME, event_param, channel); } + if (event_enabler) + lttng_event_enabler_session_add(channel->parent.session, event_enabler); priv = event_enabler; break; } - case LTTNG_KERNEL_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_KRETPROBE: /* Fall-through */ - case LTTNG_KERNEL_UPROBE: + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: { - struct lttng_event *event; + struct lttng_kernel_event_common *event; + struct lttng_event_recorder_enabler *event_enabler; + event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME, + event_param, channel); + if (!event_enabler) { + ret = -ENOMEM; + goto event_error; + } /* * We tolerate no failure path after event creation. It * will stay invariant for the rest of the session. */ - event = lttng_event_create(channel, event_param, - NULL, NULL, - event_param->instrumentation); - WARN_ON_ONCE(!event); + event = lttng_kernel_event_create(&event_enabler->parent, NULL); + WARN_ON_ONCE(IS_ERR(event)); + lttng_event_enabler_destroy(&event_enabler->parent); if (IS_ERR(event)) { ret = PTR_ERR(event); goto event_error; } - priv = event; + priv = container_of(event, struct lttng_kernel_event_recorder, parent); break; } - case LTTNG_KERNEL_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: ret = -EINVAL; goto event_error; @@ -1879,158 +1965,151 @@ fd_error: } static -long lttng_event_notifier_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +long lttng_event_notifier_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct lttng_event_notifier *event_notifier; - struct lttng_event_notifier_enabler *event_notifier_enabler; - enum lttng_event_type *evtype = file->private_data; + struct lttng_kernel_event_notifier *event_notifier = file->private_data; switch (cmd) { - case LTTNG_KERNEL_ENABLE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event_notifier = file->private_data; - return lttng_event_notifier_enable(event_notifier); - case LTTNG_TYPE_ENABLER: - event_notifier_enabler = file->private_data; - return lttng_event_notifier_enabler_enable(event_notifier_enabler); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - case LTTNG_KERNEL_DISABLE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event_notifier = file->private_data; - return lttng_event_notifier_disable(event_notifier); - case LTTNG_TYPE_ENABLER: - event_notifier_enabler = file->private_data; - return lttng_event_notifier_enabler_disable(event_notifier_enabler); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - case LTTNG_KERNEL_FILTER: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - return -EINVAL; - case LTTNG_TYPE_ENABLER: - event_notifier_enabler = file->private_data; - return lttng_event_notifier_enabler_attach_filter_bytecode( - event_notifier_enabler, - (struct lttng_kernel_filter_bytecode __user *) arg); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - - case LTTNG_KERNEL_CAPTURE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - return -EINVAL; - case LTTNG_TYPE_ENABLER: - event_notifier_enabler = file->private_data; - return lttng_event_notifier_enabler_attach_capture_bytecode( - event_notifier_enabler, - (struct lttng_kernel_capture_bytecode __user *) arg); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - case LTTNG_KERNEL_ADD_CALLSITE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event_notifier = file->private_data; - return lttng_event_notifier_add_callsite(event_notifier, - (struct lttng_kernel_event_callsite __user *) arg); - case LTTNG_TYPE_ENABLER: - return -EINVAL; - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } + case LTTNG_KERNEL_ABI_ENABLE: + return lttng_event_enable(&event_notifier->parent); + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_disable(&event_notifier->parent); + case LTTNG_KERNEL_ABI_FILTER: + return -EINVAL; + case LTTNG_KERNEL_ABI_CAPTURE: + return -EINVAL; + case LTTNG_KERNEL_ABI_ADD_CALLSITE: + return lttng_event_add_callsite(&event_notifier->parent, + (struct lttng_kernel_abi_event_callsite __user *) arg); default: return -ENOIOCTLCMD; } } static -int lttng_event_notifier_release(struct inode *inode, struct file *file) +long lttng_event_notifier_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct lttng_event_notifier *event_notifier; - struct lttng_event_notifier_enabler *event_notifier_enabler; - enum lttng_event_type *evtype = file->private_data; - - if (!evtype) - return 0; + struct lttng_event_notifier_enabler *event_notifier_enabler = file->private_data; - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event_notifier = file->private_data; - if (event_notifier) - fput(event_notifier->group->file); - break; - case LTTNG_TYPE_ENABLER: - event_notifier_enabler = file->private_data; - if (event_notifier_enabler) - fput(event_notifier_enabler->group->file); - break; + switch (cmd) { + case LTTNG_KERNEL_ABI_ENABLE: + return lttng_event_enabler_enable(&event_notifier_enabler->parent); + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_enabler_disable(&event_notifier_enabler->parent); + case LTTNG_KERNEL_ABI_FILTER: + return lttng_event_enabler_attach_filter_bytecode(&event_notifier_enabler->parent, + (struct lttng_kernel_abi_filter_bytecode __user *) arg); + case LTTNG_KERNEL_ABI_CAPTURE: + return lttng_event_notifier_enabler_attach_capture_bytecode( + event_notifier_enabler, + (struct lttng_kernel_abi_capture_bytecode __user *) arg); + case LTTNG_KERNEL_ABI_ADD_CALLSITE: + return -EINVAL; default: - WARN_ON_ONCE(1); - break; + return -ENOIOCTLCMD; } +} + +static +int lttng_event_notifier_event_release(struct inode *inode, struct file *file) +{ + struct lttng_kernel_event_notifier *event_notifier = file->private_data; + if (event_notifier) + fput(event_notifier->priv->group->file); return 0; } -static const struct file_operations lttng_event_notifier_fops = { +static +int lttng_event_notifier_enabler_release(struct inode *inode, struct file *file) +{ + struct lttng_event_notifier_enabler *event_notifier_enabler = file->private_data; + + if (event_notifier_enabler) + fput(event_notifier_enabler->group->file); + return 0; +} + +static const struct file_operations lttng_event_notifier_event_fops = { .owner = THIS_MODULE, - .release = lttng_event_notifier_release, - .unlocked_ioctl = lttng_event_notifier_ioctl, + .release = lttng_event_notifier_event_release, + .unlocked_ioctl = lttng_event_notifier_event_ioctl, #ifdef CONFIG_COMPAT - .compat_ioctl = lttng_event_notifier_ioctl, + .compat_ioctl = lttng_event_notifier_event_ioctl, +#endif +}; + +static const struct file_operations lttng_event_notifier_enabler_fops = { + .owner = THIS_MODULE, + .release = lttng_event_notifier_enabler_release, + .unlocked_ioctl = lttng_event_notifier_enabler_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = lttng_event_notifier_enabler_ioctl, #endif }; static int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, - struct lttng_kernel_event_notifier *event_notifier_param) + struct lttng_kernel_abi_event_notifier *event_notifier_param) { struct lttng_event_notifier_group *event_notifier_group = event_notifier_group_file->private_data; + const struct file_operations *fops; int event_notifier_fd, ret; struct file *event_notifier_file; void *priv; switch (event_notifier_param->event.instrumentation) { - case LTTNG_KERNEL_TRACEPOINT: - case LTTNG_KERNEL_UPROBE: + case LTTNG_KERNEL_ABI_TRACEPOINT: + case LTTNG_KERNEL_ABI_UPROBE: break; - case LTTNG_KERNEL_KPROBE: - event_notifier_param->event.u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + case LTTNG_KERNEL_ABI_KPROBE: + event_notifier_param->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; - case LTTNG_KERNEL_SYSCALL: + case LTTNG_KERNEL_ABI_SYSCALL: break; - case LTTNG_KERNEL_KRETPROBE: + case LTTNG_KERNEL_ABI_KRETPROBE: /* Placing an event notifier on kretprobe is not supported. */ - case LTTNG_KERNEL_FUNCTION: - case LTTNG_KERNEL_NOOP: + case LTTNG_KERNEL_ABI_FUNCTION: + case LTTNG_KERNEL_ABI_NOOP: + default: + ret = -EINVAL; + goto inval_instr; + } + + switch (event_notifier_param->event.instrumentation) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + fops = <tng_event_notifier_enabler_fops; + break; + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + fops = <tng_event_notifier_event_fops; + break; + + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: ret = -EINVAL; goto inval_instr; } - event_notifier_param->event.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + event_notifier_param->event.name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; - event_notifier_fd = lttng_get_unused_fd(); + event_notifier_fd = get_unused_fd_flags(0); if (event_notifier_fd < 0) { ret = event_notifier_fd; goto fd_error; } event_notifier_file = anon_inode_getfile("[lttng_event_notifier]", - <tng_event_notifier_fops, - NULL, O_RDWR); + fops, NULL, O_RDWR); if (IS_ERR(event_notifier_file)) { ret = PTR_ERR(event_notifier_file); goto file_error; @@ -2042,9 +2121,14 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, goto refcount_error; } + ret = lttng_abi_validate_event_param(&event_notifier_param->event); + if (ret) + goto event_notifier_error; + switch (event_notifier_param->event.instrumentation) { - case LTTNG_KERNEL_TRACEPOINT: /* Fall-through */ - case LTTNG_KERNEL_SYSCALL: + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: { struct lttng_event_notifier_enabler *enabler; @@ -2054,46 +2138,51 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, * we create the special star globbing enabler. */ enabler = lttng_event_notifier_enabler_create( - event_notifier_group, LTTNG_ENABLER_FORMAT_STAR_GLOB, - event_notifier_param); + event_notifier_param, + event_notifier_group); } else { enabler = lttng_event_notifier_enabler_create( - event_notifier_group, LTTNG_ENABLER_FORMAT_NAME, - event_notifier_param); + event_notifier_param, + event_notifier_group); } + if (enabler) + lttng_event_notifier_enabler_group_add(event_notifier_group, enabler); priv = enabler; break; } - case LTTNG_KERNEL_KPROBE: /* Fall-through */ - case LTTNG_KERNEL_KRETPROBE: /* Fall-through */ - case LTTNG_KERNEL_UPROBE: + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: { - struct lttng_event_notifier *event_notifier; + struct lttng_kernel_event_common *event; + struct lttng_event_notifier_enabler *event_notifier_enabler; - /* - * We tolerate no failure path after event notifier creation. - * It will stay invariant for the rest of the session. - */ - event_notifier = lttng_event_notifier_create(NULL, - event_notifier_param->event.token, - event_notifier_param->error_counter_index, - event_notifier_group, - event_notifier_param, NULL, - event_notifier_param->event.instrumentation); - WARN_ON_ONCE(!event_notifier); - if (IS_ERR(event_notifier)) { - ret = PTR_ERR(event_notifier); + event_notifier_enabler = lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME, + event_notifier_param, event_notifier_group); + if (!event_notifier_enabler) { + ret = -ENOMEM; + goto event_notifier_error; + } + event = lttng_kernel_event_create(&event_notifier_enabler->parent, NULL); + WARN_ON_ONCE(IS_ERR(event)); + lttng_event_enabler_destroy(&event_notifier_enabler->parent); + if (IS_ERR(event)) { + ret = PTR_ERR(event); goto event_notifier_error; } - priv = event_notifier; + priv = container_of(event, struct lttng_kernel_event_notifier, parent); break; } - case LTTNG_KERNEL_FUNCTION: /* Fall-through */ - case LTTNG_KERNEL_NOOP: /* Fall-through */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: ret = -EINVAL; goto event_notifier_error; @@ -2116,7 +2205,7 @@ inval_instr: static long lttng_abi_event_notifier_group_create_error_counter( struct file *event_notifier_group_file, - const struct lttng_kernel_counter_conf *error_counter_conf) + const struct lttng_kernel_abi_counter_conf *error_counter_conf) { int counter_fd, ret; char *counter_transport_name; @@ -2126,7 +2215,7 @@ long lttng_abi_event_notifier_group_create_error_counter( struct lttng_event_notifier_group *event_notifier_group = (struct lttng_event_notifier_group *) event_notifier_group_file->private_data; - if (error_counter_conf->arithmetic != LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR) { + if (error_counter_conf->arithmetic != LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR) { printk(KERN_ERR "LTTng: event_notifier: Error counter of the wrong arithmetic type.\n"); return -EINVAL; } @@ -2137,10 +2226,10 @@ long lttng_abi_event_notifier_group_create_error_counter( } switch (error_counter_conf->bitness) { - case LTTNG_KERNEL_COUNTER_BITNESS_64: + case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64: counter_transport_name = "counter-per-cpu-64-modular"; break; - case LTTNG_KERNEL_COUNTER_BITNESS_32: + case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32: counter_transport_name = "counter-per-cpu-32-modular"; break; default: @@ -2160,7 +2249,7 @@ long lttng_abi_event_notifier_group_create_error_counter( goto fd_error; } - counter_fd = lttng_get_unused_fd(); + counter_fd = get_unused_fd_flags(0); if (counter_fd < 0) { ret = counter_fd; goto fd_error; @@ -2194,7 +2283,7 @@ long lttng_abi_event_notifier_group_create_error_counter( * in record_error. Ensures the counter is created and the * error_counter_len is set before they are used. */ - lttng_smp_store_release(&event_notifier_group->error_counter, counter); + smp_store_release(&event_notifier_group->error_counter, counter); counter->file = counter_file; counter->owner = event_notifier_group->file; @@ -2223,26 +2312,26 @@ long lttng_event_notifier_group_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { switch (cmd) { - case LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD: + case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD: { return lttng_abi_open_event_notifier_group_stream(file); } - case LTTNG_KERNEL_EVENT_NOTIFIER_CREATE: + case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_CREATE: { - struct lttng_kernel_event_notifier uevent_notifier_param; + struct lttng_kernel_abi_event_notifier uevent_notifier_param; if (copy_from_user(&uevent_notifier_param, - (struct lttng_kernel_event_notifier __user *) arg, + (struct lttng_kernel_abi_event_notifier __user *) arg, sizeof(uevent_notifier_param))) return -EFAULT; return lttng_abi_create_event_notifier(file, &uevent_notifier_param); } - case LTTNG_KERNEL_COUNTER: + case LTTNG_KERNEL_ABI_COUNTER: { - struct lttng_kernel_counter_conf uerror_counter_conf; + struct lttng_kernel_abi_counter_conf uerror_counter_conf; if (copy_from_user(&uerror_counter_conf, - (struct lttng_kernel_counter_conf __user *) arg, + (struct lttng_kernel_abi_counter_conf __user *) arg, sizeof(uerror_counter_conf))) return -EFAULT; return lttng_abi_event_notifier_group_create_error_counter(file, @@ -2282,16 +2371,16 @@ static const struct file_operations lttng_event_notifier_group_fops = { * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_STREAM + * LTTNG_KERNEL_ABI_STREAM * Returns an event stream file descriptor or failure. * (typically, one event stream records events from one CPU) - * LTTNG_KERNEL_EVENT + * LTTNG_KERNEL_ABI_EVENT * Returns an event file descriptor or failure. - * LTTNG_KERNEL_CONTEXT + * LTTNG_KERNEL_ABI_CONTEXT * Prepend a context field to each event in the channel - * LTTNG_KERNEL_ENABLE + * LTTNG_KERNEL_ABI_ENABLE * Enable recording for events in this channel (weak enable) - * LTTNG_KERNEL_DISABLE + * LTTNG_KERNEL_ABI_DISABLE * Disable recording for events in this channel (strong disable) * * Channel and event file descriptors also hold a reference on the session. @@ -2299,34 +2388,34 @@ static const struct file_operations lttng_event_notifier_group_fops = { static long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct lttng_channel *channel = file->private_data; + struct lttng_kernel_channel_buffer *channel = file->private_data; switch (cmd) { - case LTTNG_KERNEL_OLD_STREAM: - case LTTNG_KERNEL_STREAM: + case LTTNG_KERNEL_ABI_OLD_STREAM: + case LTTNG_KERNEL_ABI_STREAM: return lttng_abi_open_stream(file); - case LTTNG_KERNEL_OLD_EVENT: + case LTTNG_KERNEL_ABI_OLD_EVENT: { - struct lttng_kernel_event *uevent_param; - struct lttng_kernel_old_event *old_uevent_param; + struct lttng_kernel_abi_event *uevent_param; + struct lttng_kernel_abi_old_event *old_uevent_param; int ret; - uevent_param = kmalloc(sizeof(struct lttng_kernel_event), + uevent_param = kmalloc(sizeof(struct lttng_kernel_abi_event), GFP_KERNEL); if (!uevent_param) { ret = -ENOMEM; goto old_event_end; } old_uevent_param = kmalloc( - sizeof(struct lttng_kernel_old_event), + sizeof(struct lttng_kernel_abi_old_event), GFP_KERNEL); if (!old_uevent_param) { ret = -ENOMEM; goto old_event_error_free_param; } if (copy_from_user(old_uevent_param, - (struct lttng_kernel_old_event __user *) arg, - sizeof(struct lttng_kernel_old_event))) { + (struct lttng_kernel_abi_old_event __user *) arg, + sizeof(struct lttng_kernel_abi_old_event))) { ret = -EFAULT; goto old_event_error_free_old_param; } @@ -2337,7 +2426,7 @@ long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg) old_uevent_param->instrumentation; switch (old_uevent_param->instrumentation) { - case LTTNG_KERNEL_KPROBE: + case LTTNG_KERNEL_ABI_KPROBE: uevent_param->u.kprobe.addr = old_uevent_param->u.kprobe.addr; uevent_param->u.kprobe.offset = @@ -2346,7 +2435,7 @@ long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg) old_uevent_param->u.kprobe.symbol_name, sizeof(uevent_param->u.kprobe.symbol_name)); break; - case LTTNG_KERNEL_KRETPROBE: + case LTTNG_KERNEL_ABI_KRETPROBE: uevent_param->u.kretprobe.addr = old_uevent_param->u.kretprobe.addr; uevent_param->u.kretprobe.offset = @@ -2355,7 +2444,7 @@ long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg) old_uevent_param->u.kretprobe.symbol_name, sizeof(uevent_param->u.kretprobe.symbol_name)); break; - case LTTNG_KERNEL_FUNCTION: + case LTTNG_KERNEL_ABI_FUNCTION: WARN_ON_ONCE(1); /* Not implemented. */ break; @@ -2371,29 +2460,29 @@ old_event_error_free_param: old_event_end: return ret; } - case LTTNG_KERNEL_EVENT: + case LTTNG_KERNEL_ABI_EVENT: { - struct lttng_kernel_event uevent_param; + struct lttng_kernel_abi_event uevent_param; if (copy_from_user(&uevent_param, - (struct lttng_kernel_event __user *) arg, + (struct lttng_kernel_abi_event __user *) arg, sizeof(uevent_param))) return -EFAULT; return lttng_abi_create_event(file, &uevent_param); } - case LTTNG_KERNEL_OLD_CONTEXT: + case LTTNG_KERNEL_ABI_OLD_CONTEXT: { - struct lttng_kernel_context *ucontext_param; - struct lttng_kernel_old_context *old_ucontext_param; + struct lttng_kernel_abi_context *ucontext_param; + struct lttng_kernel_abi_old_context *old_ucontext_param; int ret; - ucontext_param = kmalloc(sizeof(struct lttng_kernel_context), + ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_context), GFP_KERNEL); if (!ucontext_param) { ret = -ENOMEM; goto old_ctx_end; } - old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_old_context), + old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_old_context), GFP_KERNEL); if (!old_ucontext_param) { ret = -ENOMEM; @@ -2401,8 +2490,8 @@ old_event_end: } if (copy_from_user(old_ucontext_param, - (struct lttng_kernel_old_context __user *) arg, - sizeof(struct lttng_kernel_old_context))) { + (struct lttng_kernel_abi_old_context __user *) arg, + sizeof(struct lttng_kernel_abi_old_context))) { ret = -EFAULT; goto old_ctx_error_free_old_param; } @@ -2410,7 +2499,7 @@ old_event_end: memcpy(ucontext_param->padding, old_ucontext_param->padding, sizeof(ucontext_param->padding)); /* only type that uses the union */ - if (old_ucontext_param->ctx == LTTNG_KERNEL_CONTEXT_PERF_COUNTER) { + if (old_ucontext_param->ctx == LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER) { ucontext_param->u.perf_counter.type = old_ucontext_param->u.perf_counter.type; ucontext_param->u.perf_counter.config = @@ -2422,7 +2511,7 @@ old_event_end: ret = lttng_abi_add_context(file, ucontext_param, - &channel->ctx, channel->session); + &channel->priv->ctx, channel->parent.session); old_ctx_error_free_old_param: kfree(old_ucontext_param); @@ -2431,27 +2520,27 @@ old_ctx_error_free_param: old_ctx_end: return ret; } - case LTTNG_KERNEL_CONTEXT: + case LTTNG_KERNEL_ABI_CONTEXT: { - struct lttng_kernel_context ucontext_param; + struct lttng_kernel_abi_context ucontext_param; if (copy_from_user(&ucontext_param, - (struct lttng_kernel_context __user *) arg, + (struct lttng_kernel_abi_context __user *) arg, sizeof(ucontext_param))) return -EFAULT; return lttng_abi_add_context(file, &ucontext_param, - &channel->ctx, channel->session); - } - case LTTNG_KERNEL_OLD_ENABLE: - case LTTNG_KERNEL_ENABLE: - return lttng_channel_enable(channel); - case LTTNG_KERNEL_OLD_DISABLE: - case LTTNG_KERNEL_DISABLE: - return lttng_channel_disable(channel); - case LTTNG_KERNEL_SYSCALL_MASK: - return lttng_channel_syscall_mask(channel, - (struct lttng_kernel_syscall_mask __user *) arg); + &channel->priv->ctx, channel->parent.session); + } + case LTTNG_KERNEL_ABI_OLD_ENABLE: + case LTTNG_KERNEL_ABI_ENABLE: + return lttng_channel_enable(&channel->parent); + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_channel_disable(&channel->parent); + case LTTNG_KERNEL_ABI_SYSCALL_MASK: + return lttng_syscall_table_get_active_mask(&channel->priv->parent.syscall_table, + (struct lttng_kernel_abi_syscall_mask __user *) arg); default: return -ENOIOCTLCMD; } @@ -2465,7 +2554,7 @@ old_ctx_end: * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_STREAM + * LTTNG_KERNEL_ABI_STREAM * Returns an event stream file descriptor or failure. * * Channel and event file descriptors also hold a reference on the session. @@ -2474,8 +2563,8 @@ static long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { switch (cmd) { - case LTTNG_KERNEL_OLD_STREAM: - case LTTNG_KERNEL_STREAM: + case LTTNG_KERNEL_ABI_OLD_STREAM: + case LTTNG_KERNEL_ABI_STREAM: return lttng_abi_open_metadata_stream(file); default: return -ENOIOCTLCMD; @@ -2488,21 +2577,22 @@ long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg * @file: the file * @wait: poll table */ +static unsigned int lttng_channel_poll(struct file *file, poll_table *wait) { - struct lttng_channel *channel = file->private_data; + struct lttng_kernel_channel_buffer *channel = file->private_data; unsigned int mask = 0; if (file->f_mode & FMODE_READ) { poll_wait_set_exclusive(wait); - poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan), + poll_wait(file, channel->ops->priv->get_hp_wait_queue(channel->priv->rb_chan), wait); - if (channel->ops->is_disabled(channel->chan)) + if (channel->ops->priv->is_disabled(channel->priv->rb_chan)) return POLLERR; - if (channel->ops->is_finalized(channel->chan)) + if (channel->ops->priv->is_finalized(channel->priv->rb_chan)) return POLLHUP; - if (channel->ops->buffer_has_read_closed_stream(channel->chan)) + if (channel->ops->priv->buffer_has_read_closed_stream(channel->priv->rb_chan)) return POLLIN | POLLRDNORM; return 0; } @@ -2513,20 +2603,20 @@ unsigned int lttng_channel_poll(struct file *file, poll_table *wait) static int lttng_channel_release(struct inode *inode, struct file *file) { - struct lttng_channel *channel = file->private_data; + struct lttng_kernel_channel_buffer *channel = file->private_data; if (channel) - fput(channel->session->file); + fput(channel->parent.session->priv->file); return 0; } static int lttng_metadata_channel_release(struct inode *inode, struct file *file) { - struct lttng_channel *channel = file->private_data; + struct lttng_kernel_channel_buffer *channel = file->private_data; if (channel) { - fput(channel->session->file); + fput(channel->parent.session->priv->file); lttng_metadata_channel_destroy(channel); } @@ -2553,132 +2643,134 @@ static const struct file_operations lttng_metadata_fops = { }; /** - * lttng_event_ioctl - lttng syscall through ioctl + * lttng_event_recorder_event_ioctl - lttng syscall through ioctl * * @file: the file * @cmd: the command * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_CONTEXT + * LTTNG_KERNEL_ABI_CONTEXT * Prepend a context field to each record of this event - * LTTNG_KERNEL_ENABLE + * LTTNG_KERNEL_ABI_ENABLE * Enable recording for this event (weak enable) - * LTTNG_KERNEL_DISABLE + * LTTNG_KERNEL_ABI_DISABLE * Disable recording for this event (strong disable) */ static -long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +long lttng_event_recorder_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct lttng_event *event; - struct lttng_event_enabler *event_enabler; - enum lttng_event_type *evtype = file->private_data; + struct lttng_kernel_event_recorder *event_recorder = file->private_data; switch (cmd) { - case LTTNG_KERNEL_OLD_CONTEXT: + case LTTNG_KERNEL_ABI_OLD_CONTEXT: { /* Not implemented */ return -ENOSYS; } - case LTTNG_KERNEL_CONTEXT: + case LTTNG_KERNEL_ABI_CONTEXT: { /* Not implemented */ return -ENOSYS; } - case LTTNG_KERNEL_OLD_ENABLE: - case LTTNG_KERNEL_ENABLE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event = file->private_data; - return lttng_event_enable(event); - case LTTNG_TYPE_ENABLER: - event_enabler = file->private_data; - return lttng_event_enabler_enable(event_enabler); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - case LTTNG_KERNEL_OLD_DISABLE: - case LTTNG_KERNEL_DISABLE: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event = file->private_data; - return lttng_event_disable(event); - case LTTNG_TYPE_ENABLER: - event_enabler = file->private_data; - return lttng_event_enabler_disable(event_enabler); - default: - WARN_ON_ONCE(1); - return -ENOSYS; - } - case LTTNG_KERNEL_FILTER: - switch (*evtype) { - case LTTNG_TYPE_EVENT: - return -EINVAL; - case LTTNG_TYPE_ENABLER: - { - event_enabler = file->private_data; - return lttng_event_enabler_attach_filter_bytecode( - event_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; - } + case LTTNG_KERNEL_ABI_OLD_ENABLE: + case LTTNG_KERNEL_ABI_ENABLE: + return lttng_event_enable(&event_recorder->parent); + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_disable(&event_recorder->parent); + case LTTNG_KERNEL_ABI_FILTER: + return -EINVAL; + case LTTNG_KERNEL_ABI_ADD_CALLSITE: + return lttng_event_add_callsite(&event_recorder->parent, + (struct lttng_kernel_abi_event_callsite __user *) arg); default: return -ENOIOCTLCMD; } } +/** + * lttng_event_recorder_enabler_ioctl - lttng syscall through ioctl + * + * @file: the file + * @cmd: the command + * @arg: command arg + * + * This ioctl implements lttng commands: + * LTTNG_KERNEL_ABI_CONTEXT + * Prepend a context field to each record of this event + * LTTNG_KERNEL_ABI_ENABLE + * Enable recording for this event (weak enable) + * LTTNG_KERNEL_ABI_DISABLE + * Disable recording for this event (strong disable) + */ static -int lttng_event_release(struct inode *inode, struct file *file) +long lttng_event_recorder_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct lttng_event *event; - struct lttng_event_enabler *event_enabler; - enum lttng_event_type *evtype = file->private_data; - - if (!evtype) - return 0; + struct lttng_event_recorder_enabler *event_enabler = file->private_data; - switch (*evtype) { - case LTTNG_TYPE_EVENT: - event = file->private_data; - if (event) - fput(event->chan->file); - break; - case LTTNG_TYPE_ENABLER: - event_enabler = file->private_data; - if (event_enabler) - fput(event_enabler->chan->file); - break; + switch (cmd) { + case LTTNG_KERNEL_ABI_OLD_CONTEXT: + { + /* Not implemented */ + return -ENOSYS; + } + case LTTNG_KERNEL_ABI_CONTEXT: + { + /* Not implemented */ + return -ENOSYS; + } + case LTTNG_KERNEL_ABI_OLD_ENABLE: + case LTTNG_KERNEL_ABI_ENABLE: + return lttng_event_enabler_enable(&event_enabler->parent); + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_enabler_disable(&event_enabler->parent); + case LTTNG_KERNEL_ABI_FILTER: + return lttng_event_enabler_attach_filter_bytecode(&event_enabler->parent, + (struct lttng_kernel_abi_filter_bytecode __user *) arg); + case LTTNG_KERNEL_ABI_ADD_CALLSITE: + return -EINVAL; default: - WARN_ON_ONCE(1); - break; + return -ENOIOCTLCMD; } +} +static +int lttng_event_recorder_event_release(struct inode *inode, struct file *file) +{ + struct lttng_kernel_event_recorder *event = file->private_data; + + if (event) + fput(event->chan->priv->parent.file); return 0; } -/* TODO: filter control ioctl */ -static const struct file_operations lttng_event_fops = { +static +int lttng_event_recorder_enabler_release(struct inode *inode, struct file *file) +{ + struct lttng_event_recorder_enabler *event_enabler = file->private_data; + + if (event_enabler) + fput(event_enabler->chan->priv->parent.file); + return 0; +} + +static const struct file_operations lttng_event_recorder_event_fops = { + .owner = THIS_MODULE, + .release = lttng_event_recorder_event_release, + .unlocked_ioctl = lttng_event_recorder_event_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = lttng_event_recorder_event_ioctl, +#endif +}; + +static const struct file_operations lttng_event_recorder_enabler_fops = { .owner = THIS_MODULE, - .release = lttng_event_release, - .unlocked_ioctl = lttng_event_ioctl, + .release = lttng_event_recorder_enabler_release, + .unlocked_ioctl = lttng_event_recorder_enabler_ioctl, #ifdef CONFIG_COMPAT - .compat_ioctl = lttng_event_ioctl, + .compat_ioctl = lttng_event_recorder_enabler_ioctl, #endif }; @@ -2695,93 +2787,93 @@ static int put_u32(uint32_t val, unsigned long arg) static long lttng_stream_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { - struct lib_ring_buffer *buf = filp->private_data; - struct channel *chan = buf->backend.chan; - const struct lib_ring_buffer_config *config = &chan->backend.config; - const struct lttng_channel_ops *ops = chan->backend.priv_ops; + struct lttng_kernel_ring_buffer *buf = filp->private_data; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; + const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config; + const struct lttng_kernel_channel_buffer_ops *ops = chan->backend.priv_ops; int ret; if (atomic_read(&chan->record_disabled)) return -EIO; switch (cmd) { - case LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_BEGIN: { uint64_t ts; - ret = ops->timestamp_begin(config, buf, &ts); + ret = ops->priv->timestamp_begin(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_GET_TIMESTAMP_END: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_END: { uint64_t ts; - ret = ops->timestamp_end(config, buf, &ts); + ret = ops->priv->timestamp_end(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_EVENTS_DISCARDED: { uint64_t ed; - ret = ops->events_discarded(config, buf, &ed); + ret = ops->priv->events_discarded(config, buf, &ed); if (ret < 0) goto error; return put_u64(ed, arg); } - case LTTNG_RING_BUFFER_GET_CONTENT_SIZE: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CONTENT_SIZE: { uint64_t cs; - ret = ops->content_size(config, buf, &cs); + ret = ops->priv->content_size(config, buf, &cs); if (ret < 0) goto error; return put_u64(cs, arg); } - case LTTNG_RING_BUFFER_GET_PACKET_SIZE: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_PACKET_SIZE: { uint64_t ps; - ret = ops->packet_size(config, buf, &ps); + ret = ops->priv->packet_size(config, buf, &ps); if (ret < 0) goto error; return put_u64(ps, arg); } - case LTTNG_RING_BUFFER_GET_STREAM_ID: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_STREAM_ID: { uint64_t si; - ret = ops->stream_id(config, buf, &si); + ret = ops->priv->stream_id(config, buf, &si); if (ret < 0) goto error; return put_u64(si, arg); } - case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP: { uint64_t ts; - ret = ops->current_timestamp(config, buf, &ts); + ret = ops->priv->current_timestamp(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_GET_SEQ_NUM: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SEQ_NUM: { uint64_t seq; - ret = ops->sequence_number(config, buf, &seq); + ret = ops->priv->sequence_number(config, buf, &seq); if (ret < 0) goto error; return put_u64(seq, arg); } - case LTTNG_RING_BUFFER_INSTANCE_ID: + case LTTNG_KERNEL_ABI_RING_BUFFER_INSTANCE_ID: { uint64_t id; - ret = ops->instance_id(config, buf, &id); + ret = ops->priv->instance_id(config, buf, &id); if (ret < 0) goto error; return put_u64(id, arg); @@ -2799,93 +2891,93 @@ error: static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { - struct lib_ring_buffer *buf = filp->private_data; - struct channel *chan = buf->backend.chan; - const struct lib_ring_buffer_config *config = &chan->backend.config; - const struct lttng_channel_ops *ops = chan->backend.priv_ops; + struct lttng_kernel_ring_buffer *buf = filp->private_data; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; + const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config; + const struct lttng_kernel_channel_buffer_ops *ops = chan->backend.priv_ops; int ret; if (atomic_read(&chan->record_disabled)) return -EIO; switch (cmd) { - case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN: { uint64_t ts; - ret = ops->timestamp_begin(config, buf, &ts); + ret = ops->priv->timestamp_begin(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_END: { uint64_t ts; - ret = ops->timestamp_end(config, buf, &ts); + ret = ops->priv->timestamp_end(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED: { uint64_t ed; - ret = ops->events_discarded(config, buf, &ed); + ret = ops->priv->events_discarded(config, buf, &ed); if (ret < 0) goto error; return put_u64(ed, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_CONTENT_SIZE: { uint64_t cs; - ret = ops->content_size(config, buf, &cs); + ret = ops->priv->content_size(config, buf, &cs); if (ret < 0) goto error; return put_u64(cs, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_PACKET_SIZE: { uint64_t ps; - ret = ops->packet_size(config, buf, &ps); + ret = ops->priv->packet_size(config, buf, &ps); if (ret < 0) goto error; return put_u64(ps, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_STREAM_ID: { uint64_t si; - ret = ops->stream_id(config, buf, &si); + ret = ops->priv->stream_id(config, buf, &si); if (ret < 0) goto error; return put_u64(si, arg); } - case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP: + case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP: { uint64_t ts; - ret = ops->current_timestamp(config, buf, &ts); + ret = ops->priv->current_timestamp(config, buf, &ts); if (ret < 0) goto error; return put_u64(ts, arg); } - case LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_SEQ_NUM: { uint64_t seq; - ret = ops->sequence_number(config, buf, &seq); + ret = ops->priv->sequence_number(config, buf, &seq); if (ret < 0) goto error; return put_u64(seq, arg); } - case LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID: + case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_INSTANCE_ID: { uint64_t id; - ret = ops->instance_id(config, buf, &id); + ret = ops->priv->instance_id(config, buf, &id); if (ret < 0) goto error; return put_u64(id, arg);