X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-abi.c;h=eac1afd11a83b50caa6495251d70b44dc838e1af;hb=c570be0da77e963d77bac099d468bc0cd5f1bd63;hp=be8bfe1e5027e23ec42acd8cccba99813b517a32;hpb=183e8b3ade0b58852561b334b3455988c743ebc9;p=lttng-modules.git diff --git a/src/lttng-abi.c b/src/lttng-abi.c index be8bfe1e..eac1afd1 100644 --- a/src/lttng-abi.c +++ b/src/lttng-abi.c @@ -34,13 +34,16 @@ #include #include #include +#include #include #include #include +#include #include #include #include #include +#include #include #include #include @@ -53,7 +56,7 @@ static struct proc_dir_entry *lttng_proc_dentry; -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0)) +#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; @@ -63,12 +66,24 @@ 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); static int put_u32(uint32_t val, unsigned long arg); +static int validate_zeroed_padding(char *p, size_t len) +{ + size_t i; + + for (i = 0; i < len; i++) { + if (p[i]) + return -1; + } + return 0; +} + /* * Teardown management: opened file descriptors keep a refcount on the module, * so it can only exit when all file descriptors are closed. @@ -77,7 +92,7 @@ static int put_u32(uint32_t val, unsigned long arg); static int lttng_abi_create_session(void) { - struct lttng_session *session; + struct lttng_kernel_session *session; struct file *session_file; int session_fd, ret; @@ -96,7 +111,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; @@ -228,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; @@ -236,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; @@ -344,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. @@ -363,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; @@ -384,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); @@ -396,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); @@ -408,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))) @@ -433,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))) @@ -452,7 +467,7 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) } } -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0)) +#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 @@ -471,13 +486,13 @@ 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; @@ -505,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 { @@ -516,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; @@ -545,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); @@ -562,54 +577,183 @@ 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; +} + +static +int lttng_counter_release(struct inode *inode, struct file *file) +{ + struct lttng_counter *counter = file->private_data; + + if (counter) { + /* + * Do not destroy the counter itself. Wait of the owner + * (event_notifier group) to be destroyed. + */ + fput(counter->owner); + } + return 0; } static -enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker) +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_ABI_COUNTER_DIMENSION_MAX] = { 0 }; + int i; + + switch (cmd) { + case LTTNG_KERNEL_ABI_COUNTER_READ: + { + 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; + int ret; + + if (copy_from_user(&local_counter_read, ucounter_read, + sizeof(local_counter_read))) + return -EFAULT; + if (validate_zeroed_padding(local_counter_read.padding, + sizeof(local_counter_read.padding))) + return -EINVAL; + + /* Cast all indexes into size_t. */ + for (i = 0; i < local_counter_read.index.number_dimensions; i++) + indexes[i] = (size_t) local_counter_read.index.dimension_indexes[i]; + cpu = local_counter_read.cpu; + + ret = lttng_kernel_counter_read(counter, indexes, cpu, &value, + &overflow, &underflow); + if (ret) + return ret; + local_counter_read.value.value = value; + local_counter_read.value.overflow = overflow; + local_counter_read.value.underflow = underflow; + + if (copy_to_user(&ucounter_read->value, &local_counter_read.value, + sizeof(local_counter_read.value))) + return -EFAULT; + + return 0; + } + case LTTNG_KERNEL_ABI_COUNTER_AGGREGATE: + { + 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; + + if (copy_from_user(&local_counter_aggregate, ucounter_aggregate, + sizeof(local_counter_aggregate))) + return -EFAULT; + if (validate_zeroed_padding(local_counter_aggregate.padding, + sizeof(local_counter_aggregate.padding))) + return -EINVAL; + + /* Cast all indexes into size_t. */ + for (i = 0; i < local_counter_aggregate.index.number_dimensions; i++) + indexes[i] = (size_t) local_counter_aggregate.index.dimension_indexes[i]; + + ret = lttng_kernel_counter_aggregate(counter, indexes, &value, + &overflow, &underflow); + if (ret) + return ret; + local_counter_aggregate.value.value = value; + local_counter_aggregate.value.overflow = overflow; + local_counter_aggregate.value.underflow = underflow; + + if (copy_to_user(&ucounter_aggregate->value, &local_counter_aggregate.value, + sizeof(local_counter_aggregate.value))) + return -EFAULT; + + return 0; + } + case LTTNG_KERNEL_ABI_COUNTER_CLEAR: + { + 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))) + return -EFAULT; + if (validate_zeroed_padding(local_counter_clear.padding, + sizeof(local_counter_clear.padding))) + return -EINVAL; + + /* Cast all indexes into size_t. */ + for (i = 0; i < local_counter_clear.index.number_dimensions; i++) + indexes[i] = (size_t) local_counter_clear.index.dimension_indexes[i]; + + return lttng_kernel_counter_clear(counter, indexes); + } + default: + WARN_ON_ONCE(1); + return -ENOSYS; + } +} + +static const struct file_operations lttng_counter_fops = { + .owner = THIS_MODULE, + .release = lttng_counter_release, + .unlocked_ioctl = lttng_counter_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = lttng_counter_ioctl, +#endif +}; + + +static +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; @@ -624,21 +768,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. @@ -646,16 +790,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; @@ -667,30 +842,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; @@ -702,41 +877,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) @@ -744,43 +919,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); } @@ -800,7 +975,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); @@ -825,8 +1000,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; @@ -931,9 +1106,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(); @@ -1005,7 +1180,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); @@ -1021,7 +1196,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); @@ -1051,7 +1226,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; @@ -1127,21 +1302,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) { @@ -1151,19 +1326,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 @@ -1174,23 +1350,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) { @@ -1212,13 +1388,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); } @@ -1236,21 +1412,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) { @@ -1260,19 +1436,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 @@ -1283,23 +1460,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) { @@ -1321,13 +1498,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); } @@ -1347,7 +1524,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; /* @@ -1365,7 +1542,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); @@ -1382,7 +1559,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); @@ -1393,7 +1570,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); } @@ -1453,12 +1630,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; @@ -1472,21 +1649,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; @@ -1496,11 +1673,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; @@ -1514,7 +1691,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; } @@ -1525,20 +1702,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; } @@ -1546,12 +1723,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; @@ -1573,46 +1750,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: - case LTTNG_KERNEL_SYSCALL_EXIT: - 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_ABI_KRETPROBE: + switch (event_param->u.kretprobe.entryexit) { + case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT: break; + case LTTNG_KERNEL_ABI_SYSCALL_ENTRY: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL_EXIT: + lttng_fallthrough; default: return -EINVAL; } break; - case LTTNG_KERNEL_TRACEPOINT: /* Fallthrough */ - case LTTNG_KERNEL_KPROBE: /* Fallthrough */ - case LTTNG_KERNEL_KRETPROBE: /* Fallthrough */ - case LTTNG_KERNEL_NOOP: /* Fallthrough */ - 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: /* Fallthrough */ + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; default: return -EINVAL; } @@ -1621,36 +1816,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; } + + 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 = lttng_get_unused_fd(); 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; @@ -1663,8 +1881,12 @@ int lttng_abi_create_event(struct file *channel_file, 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) { + + switch (event_param->instrumentation) { + case LTTNG_KERNEL_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + { struct lttng_event_enabler *event_enabler; if (strutils_is_star_glob_pattern(event_param->name)) { @@ -1679,22 +1901,39 @@ int lttng_abi_create_event(struct file *channel_file, event_param, channel); } priv = event_enabler; - } else { - struct lttng_event *event; + break; + } + + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + { + struct lttng_kernel_event_recorder *event; /* * 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); + event = lttng_kernel_event_recorder_create(channel, event_param, + NULL, event_param->instrumentation); WARN_ON_ONCE(!event); if (IS_ERR(event)) { ret = PTR_ERR(event); goto event_error; } priv = event; + break; + } + + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; + default: + ret = -EINVAL; + goto event_error; } event_file->private_data = priv; fd_install(event_fd, event_file); @@ -1711,134 +1950,143 @@ 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_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; + struct lttng_event_notifier_enabler *event_notifier_enabler = file->private_data; - if (!evtype) - return 0; - - 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_notifier_enabler_enable(event_notifier_enabler); + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_notifier_enabler_disable(event_notifier_enabler); + case LTTNG_KERNEL_ABI_FILTER: + return lttng_event_notifier_enabler_attach_filter_bytecode( + event_notifier_enabler, + (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(); if (event_notifier_fd < 0) { @@ -1847,8 +2095,7 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, } 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; @@ -1860,8 +2107,15 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, goto refcount_error; } - if (event_notifier_param->event.instrumentation == LTTNG_KERNEL_TRACEPOINT - || event_notifier_param->event.instrumentation == LTTNG_KERNEL_SYSCALL) { + 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_ABI_TRACEPOINT: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_SYSCALL: + { struct lttng_event_notifier_enabler *enabler; if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) { @@ -1880,16 +2134,26 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, event_notifier_param); } priv = enabler; - } else { - struct lttng_event_notifier *event_notifier; + break; + } + + case LTTNG_KERNEL_ABI_KPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_KRETPROBE: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_UPROBE: + { + struct lttng_kernel_event_notifier *event_notifier; /* * 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_group, - event_notifier_param, NULL, + event_notifier_param->event.token, + event_notifier_param->error_counter_index, + event_notifier_group, + event_notifier_param, event_notifier_param->event.instrumentation); WARN_ON_ONCE(!event_notifier); if (IS_ERR(event_notifier)) { @@ -1897,6 +2161,16 @@ int lttng_abi_create_event_notifier(struct file *event_notifier_group_file, goto event_notifier_error; } priv = event_notifier; + break; + } + + case LTTNG_KERNEL_ABI_FUNCTION: + lttng_fallthrough; + case LTTNG_KERNEL_ABI_NOOP: + lttng_fallthrough; + default: + ret = -EINVAL; + goto event_notifier_error; } event_notifier_file->private_data = priv; fd_install(event_notifier_fd, event_notifier_file); @@ -1913,25 +2187,141 @@ inval_instr: return ret; } +static +long lttng_abi_event_notifier_group_create_error_counter( + struct file *event_notifier_group_file, + const struct lttng_kernel_abi_counter_conf *error_counter_conf) +{ + int counter_fd, ret; + char *counter_transport_name; + size_t counter_len; + struct lttng_counter *counter = NULL; + struct file *counter_file; + 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_ABI_COUNTER_ARITHMETIC_MODULAR) { + printk(KERN_ERR "LTTng: event_notifier: Error counter of the wrong arithmetic type.\n"); + return -EINVAL; + } + + if (error_counter_conf->number_dimensions != 1) { + printk(KERN_ERR "LTTng: event_notifier: Error counter has more than one dimension.\n"); + return -EINVAL; + } + + switch (error_counter_conf->bitness) { + case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64: + counter_transport_name = "counter-per-cpu-64-modular"; + break; + case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32: + counter_transport_name = "counter-per-cpu-32-modular"; + break; + default: + return -EINVAL; + } + + /* + * Lock sessions to provide mutual exclusion against concurrent + * modification of event_notifier group, which would result in + * overwriting the error counter if set concurrently. + */ + lttng_lock_sessions(); + + if (event_notifier_group->error_counter) { + printk(KERN_ERR "Error counter already created in event_notifier group\n"); + ret = -EBUSY; + goto fd_error; + } + + counter_fd = lttng_get_unused_fd(); + if (counter_fd < 0) { + ret = counter_fd; + goto fd_error; + } + + counter_file = anon_inode_getfile("[lttng_counter]", + <tng_counter_fops, + NULL, O_RDONLY); + if (IS_ERR(counter_file)) { + ret = PTR_ERR(counter_file); + goto file_error; + } + + counter_len = error_counter_conf->dimensions[0].size; + + if (!atomic_long_add_unless(&event_notifier_group_file->f_count, 1, LONG_MAX)) { + ret = -EOVERFLOW; + goto refcount_error; + } + + counter = lttng_kernel_counter_create(counter_transport_name, + 1, &counter_len); + if (!counter) { + ret = -EINVAL; + goto counter_error; + } + + event_notifier_group->error_counter_len = counter_len; + /* + * store-release to publish error counter matches load-acquire + * 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); + + counter->file = counter_file; + counter->owner = event_notifier_group->file; + counter_file->private_data = counter; + /* Ownership transferred. */ + counter = NULL; + + fd_install(counter_fd, counter_file); + lttng_unlock_sessions(); + + return counter_fd; + +counter_error: + atomic_long_dec(&event_notifier_group_file->f_count); +refcount_error: + fput(counter_file); +file_error: + put_unused_fd(counter_fd); +fd_error: + lttng_unlock_sessions(); + return ret; +} + static 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_ABI_COUNTER: + { + struct lttng_kernel_abi_counter_conf uerror_counter_conf; + + if (copy_from_user(&uerror_counter_conf, + (struct lttng_kernel_abi_counter_conf __user *) arg, + sizeof(uerror_counter_conf))) + return -EFAULT; + return lttng_abi_event_notifier_group_create_error_counter(file, + &uerror_counter_conf); + } default: return -ENOIOCTLCMD; } @@ -1966,16 +2356,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. @@ -1983,34 +2373,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; } @@ -2021,7 +2411,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 = @@ -2030,7 +2420,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 = @@ -2039,7 +2429,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; @@ -2055,29 +2445,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; @@ -2085,8 +2475,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; } @@ -2094,7 +2484,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 = @@ -2106,7 +2496,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); @@ -2115,27 +2505,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); + &channel->priv->ctx, channel->parent.session); } - case LTTNG_KERNEL_OLD_ENABLE: - case LTTNG_KERNEL_ENABLE: + case LTTNG_KERNEL_ABI_OLD_ENABLE: + case LTTNG_KERNEL_ABI_ENABLE: return lttng_channel_enable(channel); - case LTTNG_KERNEL_OLD_DISABLE: - case LTTNG_KERNEL_DISABLE: + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_DISABLE: return lttng_channel_disable(channel); - case LTTNG_KERNEL_SYSCALL_MASK: + case LTTNG_KERNEL_ABI_SYSCALL_MASK: return lttng_channel_syscall_mask(channel, - (struct lttng_kernel_syscall_mask __user *) arg); + (struct lttng_kernel_abi_syscall_mask __user *) arg); default: return -ENOIOCTLCMD; } @@ -2149,7 +2539,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. @@ -2158,8 +2548,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; @@ -2174,19 +2564,19 @@ long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg */ 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; } @@ -2197,20 +2587,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); } @@ -2237,132 +2627,135 @@ 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; + struct lttng_event_enabler *event_enabler = file->private_data; - if (!evtype) - return 0; - - 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); + case LTTNG_KERNEL_ABI_OLD_DISABLE: + case LTTNG_KERNEL_ABI_DISABLE: + return lttng_event_enabler_disable(event_enabler); + case LTTNG_KERNEL_ABI_FILTER: + return lttng_event_enabler_attach_filter_bytecode( + event_enabler, + (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_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 }; @@ -2379,93 +2772,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); @@ -2483,93 +2876,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);