X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt-debugfs-abi.c;h=86a1720068c49eb96d306f86711f6bb54bd22b65;hb=259b6cb38d19bbe9c039728459bc25acc0f6f8a0;hp=f8bee492c3daae003dc7702aaf638ad3af99d0d3;hpb=254ec7bc4c72da11a4e3f2c90904b111a06a2c55;p=lttng-modules.git diff --git a/ltt-debugfs-abi.c b/ltt-debugfs-abi.c index f8bee492..86a17200 100644 --- a/ltt-debugfs-abi.c +++ b/ltt-debugfs-abi.c @@ -26,6 +26,7 @@ #include #include +#include #include #include #include @@ -43,12 +44,18 @@ */ static struct dentry *lttng_dentry; +static struct proc_dir_entry *lttng_proc_dentry; static const struct file_operations lttng_fops; static const struct file_operations lttng_session_fops; static const struct file_operations lttng_channel_fops; static const struct file_operations lttng_metadata_fops; static const struct file_operations lttng_event_fops; +/* + * Teardown management: opened file descriptors keep a refcount on the module, + * so it can only exit when all file descriptors are closed. + */ + enum channel_type { PER_CPU_CHANNEL, METADATA_CHANNEL, @@ -159,6 +166,16 @@ long lttng_abi_add_context(struct file *file, return lttng_add_prio_to_ctx(ctx); case LTTNG_KERNEL_CONTEXT_NICE: return lttng_add_nice_to_ctx(ctx); + case LTTNG_KERNEL_CONTEXT_VPID: + return lttng_add_vpid_to_ctx(ctx); + case LTTNG_KERNEL_CONTEXT_TID: + return lttng_add_tid_to_ctx(ctx); + case LTTNG_KERNEL_CONTEXT_VTID: + return lttng_add_vtid_to_ctx(ctx); + case LTTNG_KERNEL_CONTEXT_PPID: + return lttng_add_ppid_to_ctx(ctx); + case LTTNG_KERNEL_CONTEXT_VPPID: + return lttng_add_vppid_to_ctx(ctx); case LTTNG_KERNEL_CONTEXT_PERF_COUNTER: context_param.u.perf_counter.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; return lttng_add_perf_counter_to_ctx(context_param.u.perf_counter.type, @@ -186,6 +203,8 @@ long lttng_abi_add_context(struct file *file, * Returns the LTTng kernel tracer version * LTTNG_KERNEL_TRACEPOINT_LIST * Returns a file descriptor listing available tracepoints + * LTTNG_KERNEL_WAIT_QUIESCENT + * Returns after all previously running probes have completed * * The returned session will be deleted when its file descriptor is closed. */ @@ -200,12 +219,30 @@ long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg) (struct lttng_kernel_tracer_version __user *) arg); case LTTNG_KERNEL_TRACEPOINT_LIST: return lttng_abi_tracepoint_list(); + case LTTNG_KERNEL_WAIT_QUIESCENT: + synchronize_trace(); + return 0; + case LTTNG_KERNEL_CALIBRATE: + { + struct lttng_kernel_calibrate __user *ucalibrate = + (struct lttng_kernel_calibrate __user *) arg; + struct lttng_kernel_calibrate calibrate; + int ret; + + if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate))) + return -EFAULT; + ret = lttng_calibrate(&calibrate); + if (copy_to_user(ucalibrate, &calibrate, sizeof(calibrate))) + return -EFAULT; + return ret; + } default: return -ENOIOCTLCMD; } } static const struct file_operations lttng_fops = { + .owner = THIS_MODULE, .unlocked_ioctl = lttng_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = lttng_ioctl, @@ -226,15 +263,13 @@ void lttng_metadata_create_events(struct file *channel_file) .name = "lttng_metadata", }; struct ltt_event *event; - int ret; /* * We tolerate no failure path after event creation. It will stay * invariant for the rest of the session. */ - event = ltt_event_create(channel, &metadata_params, NULL); + event = ltt_event_create(channel, &metadata_params, NULL, NULL); if (!event) { - ret = -EINVAL; goto create_error; } return; @@ -250,7 +285,7 @@ int lttng_abi_create_channel(struct file *session_file, enum channel_type channel_type) { struct ltt_session *session = session_file->private_data; - const struct file_operations *fops; + const struct file_operations *fops = NULL; const char *transport_name; struct ltt_channel *chan; struct file *chan_file; @@ -265,8 +300,17 @@ int lttng_abi_create_channel(struct file *session_file, ret = chan_fd; goto fd_error; } + switch (channel_type) { + case PER_CPU_CHANNEL: + fops = <tng_channel_fops; + break; + case METADATA_CHANNEL: + fops = <tng_metadata_fops; + break; + } + chan_file = anon_inode_getfile("[lttng_channel]", - <tng_channel_fops, + fops, NULL, O_RDWR); if (IS_ERR(chan_file)) { ret = PTR_ERR(chan_file); @@ -274,13 +318,23 @@ int lttng_abi_create_channel(struct file *session_file, } switch (channel_type) { case PER_CPU_CHANNEL: - transport_name = chan_param.overwrite ? - "relay-overwrite" : "relay-discard"; - fops = <tng_channel_fops; + if (chan_param.output == LTTNG_KERNEL_SPLICE) { + transport_name = chan_param.overwrite ? + "relay-overwrite" : "relay-discard"; + } else if (chan_param.output == LTTNG_KERNEL_MMAP) { + transport_name = chan_param.overwrite ? + "relay-overwrite-mmap" : "relay-discard-mmap"; + } else { + return -EINVAL; + } break; case METADATA_CHANNEL: - transport_name = "relay-metadata"; - fops = <tng_metadata_fops; + if (chan_param.output == LTTNG_KERNEL_SPLICE) + transport_name = "relay-metadata"; + else if (chan_param.output == LTTNG_KERNEL_MMAP) + transport_name = "relay-metadata-mmap"; + else + return -EINVAL; break; default: transport_name = ""; @@ -330,10 +384,10 @@ fd_error: * This ioctl implements lttng commands: * LTTNG_KERNEL_CHANNEL * Returns a LTTng channel file descriptor - * LTTNG_KERNEL_SESSION_START - * Starts tracing session - * LTTNG_KERNEL_SESSION_STOP - * Stops tracing session + * LTTNG_KERNEL_ENABLE + * Enables tracing for a session (weak enable) + * LTTNG_KERNEL_DISABLE + * Disables tracing for a session (strong disable) * LTTNG_KERNEL_METADATA * Returns a LTTng metadata file descriptor * @@ -350,9 +404,11 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) (struct lttng_kernel_channel __user *) arg, PER_CPU_CHANNEL); case LTTNG_KERNEL_SESSION_START: - return ltt_session_start(session); + case LTTNG_KERNEL_ENABLE: + return ltt_session_enable(session); case LTTNG_KERNEL_SESSION_STOP: - return ltt_session_stop(session); + case LTTNG_KERNEL_DISABLE: + return ltt_session_disable(session); case LTTNG_KERNEL_METADATA: return lttng_abi_create_channel(file, (struct lttng_kernel_channel __user *) arg, @@ -381,6 +437,7 @@ int lttng_session_release(struct inode *inode, struct file *file) } static const struct file_operations lttng_session_fops = { + .owner = THIS_MODULE, .release = lttng_session_release, .unlocked_ioctl = lttng_session_ioctl, #ifdef CONFIG_COMPAT @@ -447,6 +504,9 @@ int lttng_abi_create_event(struct file *channel_file, return -EFAULT; event_param.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; switch (event_param.instrumentation) { + case LTTNG_KERNEL_KRETPROBE: + event_param.u.kretprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0'; + break; case LTTNG_KERNEL_KPROBE: event_param.u.kprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0'; break; @@ -456,31 +516,41 @@ int lttng_abi_create_event(struct file *channel_file, default: break; } - event_fd = 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); - if (IS_ERR(event_file)) { - ret = PTR_ERR(event_file); - goto file_error; - } - /* - * We tolerate no failure path after event creation. It will stay - * invariant for the rest of the session. - */ - event = ltt_event_create(channel, &event_param, NULL); - if (!event) { - ret = -EINVAL; - goto event_error; + switch (event_param.instrumentation) { + default: + event_fd = 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); + if (IS_ERR(event_file)) { + ret = PTR_ERR(event_file); + goto file_error; + } + /* + * We tolerate no failure path after event creation. It + * will stay invariant for the rest of the session. + */ + event = ltt_event_create(channel, &event_param, NULL, NULL); + if (!event) { + ret = -EINVAL; + goto event_error; + } + event_file->private_data = event; + fd_install(event_fd, event_file); + /* The event holds a reference on the channel */ + atomic_long_inc(&channel_file->f_count); + break; + case LTTNG_KERNEL_SYSCALLS: + ret = lttng_syscalls_register(channel, NULL); + if (ret) + goto fd_error; + event_fd = 0; + break; } - event_file->private_data = event; - fd_install(event_fd, event_file); - /* The event holds a reference on the channel */ - atomic_long_inc(&channel_file->f_count); return event_fd; event_error: @@ -506,6 +576,10 @@ fd_error: * Returns an event file descriptor or failure. * LTTNG_KERNEL_CONTEXT * Prepend a context field to each event in the channel + * LTTNG_KERNEL_ENABLE + * Enable recording for events in this channel (weak enable) + * LTTNG_KERNEL_DISABLE + * Disable recording for events in this channel (strong disable) * * Channel and event file descriptors also hold a reference on the session. */ @@ -523,6 +597,10 @@ long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_abi_add_context(file, (struct lttng_kernel_context __user *) arg, &channel->ctx, channel->session); + case LTTNG_KERNEL_ENABLE: + return ltt_channel_enable(channel); + case LTTNG_KERNEL_DISABLE: + return ltt_channel_disable(channel); default: return -ENOIOCTLCMD; } @@ -564,7 +642,7 @@ unsigned int lttng_channel_poll(struct file *file, poll_table *wait) unsigned int mask = 0; if (file->f_mode & FMODE_READ) { - init_poll_funcptr(wait, wrapper_pollwait_exclusive); + poll_wait_set_exclusive(wait); poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan), wait); @@ -572,8 +650,9 @@ unsigned int lttng_channel_poll(struct file *file, poll_table *wait) return POLLERR; if (channel->ops->is_finalized(channel->chan)) return POLLHUP; - else + if (channel->ops->buffer_has_read_closed_stream(channel->chan)) return POLLIN | POLLRDNORM; + return 0; } return mask; @@ -590,6 +669,7 @@ int lttng_channel_release(struct inode *inode, struct file *file) } static const struct file_operations lttng_channel_fops = { + .owner = THIS_MODULE, .release = lttng_channel_release, .poll = lttng_channel_poll, .unlocked_ioctl = lttng_channel_ioctl, @@ -599,6 +679,7 @@ static const struct file_operations lttng_channel_fops = { }; static const struct file_operations lttng_metadata_fops = { + .owner = THIS_MODULE, .release = lttng_channel_release, .unlocked_ioctl = lttng_metadata_ioctl, #ifdef CONFIG_COMPAT @@ -614,13 +695,12 @@ static const struct file_operations lttng_metadata_fops = { * @arg: command arg * * This ioctl implements lttng commands: - * LTTNG_KERNEL_STREAM - * Returns an event stream file descriptor or failure. - * (typically, one event stream records events from one CPU) - * LTTNG_KERNEL_EVENT - * Returns an event file descriptor or failure. * LTTNG_KERNEL_CONTEXT * Prepend a context field to each record of this event + * LTTNG_KERNEL_ENABLE + * Enable recording for this event (weak enable) + * LTTNG_KERNEL_DISABLE + * Disable recording for this event (strong disable) */ static long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg) @@ -632,6 +712,10 @@ long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_abi_add_context(file, (struct lttng_kernel_context __user *) arg, &event->ctx, event->chan->session); + case LTTNG_KERNEL_ENABLE: + return ltt_event_enable(event); + case LTTNG_KERNEL_DISABLE: + return ltt_event_disable(event); default: return -ENOIOCTLCMD; } @@ -649,6 +733,7 @@ int lttng_event_release(struct inode *inode, struct file *file) /* TODO: filter control ioctl */ static const struct file_operations lttng_event_fops = { + .owner = THIS_MODULE, .release = lttng_event_release, .unlocked_ioctl = lttng_event_ioctl, #ifdef CONFIG_COMPAT @@ -662,8 +747,14 @@ int __init ltt_debugfs_abi_init(void) wrapper_vmalloc_sync_all(); lttng_dentry = debugfs_create_file("lttng", S_IWUSR, NULL, NULL, - <tng_fops); - if (IS_ERR(lttng_dentry) || !lttng_dentry) { + <tng_fops); + if (IS_ERR(lttng_dentry)) + lttng_dentry = NULL; + + lttng_proc_dentry = proc_create_data("lttng", S_IWUSR, NULL, + <tng_fops, NULL); + + if (!lttng_dentry && !lttng_proc_dentry) { printk(KERN_ERR "Error creating LTTng control file\n"); ret = -ENOMEM; goto error; @@ -674,5 +765,8 @@ error: void __exit ltt_debugfs_abi_exit(void) { - debugfs_remove(lttng_dentry); + if (lttng_dentry) + debugfs_remove(lttng_dentry); + if (lttng_proc_dentry) + remove_proc_entry("lttng", NULL); }