6 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; only
11 * version 2.1 of the License.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * Mimic system calls for:
24 * - session creation, returns a file descriptor or failure.
25 * - channel creation, returns a file descriptor or failure.
26 * - Operates on a session file descriptor
27 * - Takes all channel options as parameters.
28 * - stream get, returns a file descriptor or failure.
29 * - Operates on a channel file descriptor.
30 * - stream notifier get, returns a file descriptor or failure.
31 * - Operates on a channel file descriptor.
32 * - event creation, returns a file descriptor or failure.
33 * - Operates on a channel file descriptor
34 * - Takes an event name as parameter
35 * - Takes an instrumentation source as parameter
36 * - e.g. tracepoints, dynamic_probes...
37 * - Takes instrumentation source specific arguments.
40 #include <linux/module.h>
41 #include <linux/proc_fs.h>
42 #include <linux/anon_inodes.h>
43 #include <linux/file.h>
44 #include <linux/uaccess.h>
45 #include <linux/slab.h>
46 #include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
47 #include "wrapper/ringbuffer/vfs.h"
48 #include "wrapper/ringbuffer/backend.h"
49 #include "wrapper/ringbuffer/frontend.h"
50 #include "wrapper/poll.h"
51 #include "lttng-abi.h"
52 #include "lttng-abi-old.h"
53 #include "lttng-events.h"
54 #include "lttng-tracer.h"
57 * This is LTTng's own personal way to create a system call as an external
58 * module. We use ioctl() on /proc/lttng.
61 static struct proc_dir_entry *lttng_proc_dentry;
62 static const struct file_operations lttng_fops;
63 static const struct file_operations lttng_session_fops;
64 static const struct file_operations lttng_channel_fops;
65 static const struct file_operations lttng_metadata_fops;
66 static const struct file_operations lttng_event_fops;
69 * Teardown management: opened file descriptors keep a refcount on the module,
70 * so it can only exit when all file descriptors are closed.
74 int lttng_abi_create_session(void)
76 struct lttng_session *session;
77 struct file *session_file;
80 session = lttng_session_create();
83 session_fd = get_unused_fd();
88 session_file = anon_inode_getfile("[lttng_session]",
91 if (IS_ERR(session_file)) {
92 ret = PTR_ERR(session_file);
95 session->file = session_file;
96 fd_install(session_fd, session_file);
100 put_unused_fd(session_fd);
102 lttng_session_destroy(session);
107 int lttng_abi_tracepoint_list(void)
109 struct file *tracepoint_list_file;
112 file_fd = get_unused_fd();
118 tracepoint_list_file = anon_inode_getfile("[lttng_session]",
119 <tng_tracepoint_list_fops,
121 if (IS_ERR(tracepoint_list_file)) {
122 ret = PTR_ERR(tracepoint_list_file);
125 ret = lttng_tracepoint_list_fops.open(NULL, tracepoint_list_file);
128 fd_install(file_fd, tracepoint_list_file);
136 fput(tracepoint_list_file);
138 put_unused_fd(file_fd);
144 void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v)
146 v->major = LTTNG_MODULES_MAJOR_VERSION;
147 v->minor = LTTNG_MODULES_MINOR_VERSION;
148 v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
152 long lttng_abi_add_context(struct file *file,
153 struct lttng_kernel_context *context_param,
154 struct lttng_ctx **ctx, struct lttng_session *session)
157 if (session->been_active)
160 switch (context_param->ctx) {
161 case LTTNG_KERNEL_CONTEXT_PID:
162 return lttng_add_pid_to_ctx(ctx);
163 case LTTNG_KERNEL_CONTEXT_PRIO:
164 return lttng_add_prio_to_ctx(ctx);
165 case LTTNG_KERNEL_CONTEXT_NICE:
166 return lttng_add_nice_to_ctx(ctx);
167 case LTTNG_KERNEL_CONTEXT_VPID:
168 return lttng_add_vpid_to_ctx(ctx);
169 case LTTNG_KERNEL_CONTEXT_TID:
170 return lttng_add_tid_to_ctx(ctx);
171 case LTTNG_KERNEL_CONTEXT_VTID:
172 return lttng_add_vtid_to_ctx(ctx);
173 case LTTNG_KERNEL_CONTEXT_PPID:
174 return lttng_add_ppid_to_ctx(ctx);
175 case LTTNG_KERNEL_CONTEXT_VPPID:
176 return lttng_add_vppid_to_ctx(ctx);
177 case LTTNG_KERNEL_CONTEXT_PERF_COUNTER:
178 context_param->u.perf_counter.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
179 return lttng_add_perf_counter_to_ctx(context_param->u.perf_counter.type,
180 context_param->u.perf_counter.config,
181 context_param->u.perf_counter.name,
183 case LTTNG_KERNEL_CONTEXT_PROCNAME:
184 return lttng_add_procname_to_ctx(ctx);
185 case LTTNG_KERNEL_CONTEXT_HOSTNAME:
186 return lttng_add_hostname_to_ctx(ctx);
193 * lttng_ioctl - lttng syscall through ioctl
199 * This ioctl implements lttng commands:
200 * LTTNG_KERNEL_SESSION
201 * Returns a LTTng trace session file descriptor
202 * LTTNG_KERNEL_TRACER_VERSION
203 * Returns the LTTng kernel tracer version
204 * LTTNG_KERNEL_TRACEPOINT_LIST
205 * Returns a file descriptor listing available tracepoints
206 * LTTNG_KERNEL_WAIT_QUIESCENT
207 * Returns after all previously running probes have completed
209 * The returned session will be deleted when its file descriptor is closed.
212 long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
215 case LTTNG_KERNEL_OLD_SESSION:
216 case LTTNG_KERNEL_SESSION:
217 return lttng_abi_create_session();
218 case LTTNG_KERNEL_OLD_TRACER_VERSION:
220 struct lttng_kernel_tracer_version v;
221 struct lttng_kernel_old_tracer_version oldv;
222 struct lttng_kernel_old_tracer_version *uversion =
223 (struct lttng_kernel_old_tracer_version __user *) arg;
225 lttng_abi_tracer_version(&v);
226 oldv.major = v.major;
227 oldv.minor = v.minor;
228 oldv.patchlevel = v.patchlevel;
230 if (copy_to_user(uversion, &oldv, sizeof(oldv)))
234 case LTTNG_KERNEL_TRACER_VERSION:
236 struct lttng_kernel_tracer_version version;
237 struct lttng_kernel_tracer_version *uversion =
238 (struct lttng_kernel_tracer_version __user *) arg;
240 lttng_abi_tracer_version(&version);
242 if (copy_to_user(uversion, &version, sizeof(version)))
246 case LTTNG_KERNEL_OLD_TRACEPOINT_LIST:
247 case LTTNG_KERNEL_TRACEPOINT_LIST:
248 return lttng_abi_tracepoint_list();
249 case LTTNG_KERNEL_OLD_WAIT_QUIESCENT:
250 case LTTNG_KERNEL_WAIT_QUIESCENT:
253 case LTTNG_KERNEL_OLD_CALIBRATE:
255 struct lttng_kernel_old_calibrate __user *ucalibrate =
256 (struct lttng_kernel_old_calibrate __user *) arg;
257 struct lttng_kernel_old_calibrate old_calibrate;
258 struct lttng_kernel_calibrate calibrate;
261 if (copy_from_user(&old_calibrate, ucalibrate, sizeof(old_calibrate)))
263 calibrate.type = old_calibrate.type;
264 ret = lttng_calibrate(&calibrate);
265 if (copy_to_user(ucalibrate, &old_calibrate, sizeof(old_calibrate)))
269 case LTTNG_KERNEL_CALIBRATE:
271 struct lttng_kernel_calibrate __user *ucalibrate =
272 (struct lttng_kernel_calibrate __user *) arg;
273 struct lttng_kernel_calibrate calibrate;
276 if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate)))
278 ret = lttng_calibrate(&calibrate);
279 if (copy_to_user(ucalibrate, &calibrate, sizeof(calibrate)))
288 static const struct file_operations lttng_fops = {
289 .owner = THIS_MODULE,
290 .unlocked_ioctl = lttng_ioctl,
292 .compat_ioctl = lttng_ioctl,
297 int lttng_abi_create_channel(struct file *session_file,
298 struct lttng_kernel_channel *chan_param,
299 enum channel_type channel_type)
301 struct lttng_session *session = session_file->private_data;
302 const struct file_operations *fops = NULL;
303 const char *transport_name;
304 struct lttng_channel *chan;
305 struct file *chan_file;
309 chan_fd = get_unused_fd();
314 switch (channel_type) {
315 case PER_CPU_CHANNEL:
316 fops = <tng_channel_fops;
318 case METADATA_CHANNEL:
319 fops = <tng_metadata_fops;
323 chan_file = anon_inode_getfile("[lttng_channel]",
326 if (IS_ERR(chan_file)) {
327 ret = PTR_ERR(chan_file);
330 switch (channel_type) {
331 case PER_CPU_CHANNEL:
332 if (chan_param->output == LTTNG_KERNEL_SPLICE) {
333 transport_name = chan_param->overwrite ?
334 "relay-overwrite" : "relay-discard";
335 } else if (chan_param->output == LTTNG_KERNEL_MMAP) {
336 transport_name = chan_param->overwrite ?
337 "relay-overwrite-mmap" : "relay-discard-mmap";
342 case METADATA_CHANNEL:
343 if (chan_param->output == LTTNG_KERNEL_SPLICE)
344 transport_name = "relay-metadata";
345 else if (chan_param->output == LTTNG_KERNEL_MMAP)
346 transport_name = "relay-metadata-mmap";
351 transport_name = "<unknown>";
355 * We tolerate no failure path after channel creation. It will stay
356 * invariant for the rest of the session.
358 chan = lttng_channel_create(session, transport_name, NULL,
359 chan_param->subbuf_size,
360 chan_param->num_subbuf,
361 chan_param->switch_timer_interval,
362 chan_param->read_timer_interval,
368 chan->file = chan_file;
369 chan_file->private_data = chan;
370 fd_install(chan_fd, chan_file);
371 atomic_long_inc(&session_file->f_count);
378 put_unused_fd(chan_fd);
384 * lttng_session_ioctl - lttng session fd ioctl
390 * This ioctl implements lttng commands:
391 * LTTNG_KERNEL_CHANNEL
392 * Returns a LTTng channel file descriptor
393 * LTTNG_KERNEL_ENABLE
394 * Enables tracing for a session (weak enable)
395 * LTTNG_KERNEL_DISABLE
396 * Disables tracing for a session (strong disable)
397 * LTTNG_KERNEL_METADATA
398 * Returns a LTTng metadata file descriptor
400 * The returned channel will be deleted when its file descriptor is closed.
403 long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
405 struct lttng_session *session = file->private_data;
408 case LTTNG_KERNEL_OLD_CHANNEL:
410 struct lttng_kernel_channel chan_param;
411 struct lttng_kernel_old_channel old_chan_param;
413 if (copy_from_user(&old_chan_param,
414 (struct lttng_kernel_old_channel __user *) arg,
415 sizeof(struct lttng_kernel_old_channel)))
417 chan_param.overwrite = old_chan_param.overwrite;
418 chan_param.subbuf_size = old_chan_param.subbuf_size;
419 chan_param.num_subbuf = old_chan_param.num_subbuf;
420 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
421 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
422 chan_param.output = old_chan_param.output;
424 return lttng_abi_create_channel(file, &chan_param,
427 case LTTNG_KERNEL_CHANNEL:
429 struct lttng_kernel_channel chan_param;
431 if (copy_from_user(&chan_param,
432 (struct lttng_kernel_channel __user *) arg,
433 sizeof(struct lttng_kernel_channel)))
435 return lttng_abi_create_channel(file, &chan_param,
438 case LTTNG_KERNEL_OLD_SESSION_START:
439 case LTTNG_KERNEL_OLD_ENABLE:
440 case LTTNG_KERNEL_SESSION_START:
441 case LTTNG_KERNEL_ENABLE:
442 return lttng_session_enable(session);
443 case LTTNG_KERNEL_OLD_SESSION_STOP:
444 case LTTNG_KERNEL_OLD_DISABLE:
445 case LTTNG_KERNEL_SESSION_STOP:
446 case LTTNG_KERNEL_DISABLE:
447 return lttng_session_disable(session);
448 case LTTNG_KERNEL_OLD_METADATA:
450 struct lttng_kernel_channel chan_param;
451 struct lttng_kernel_old_channel old_chan_param;
453 if (copy_from_user(&old_chan_param,
454 (struct lttng_kernel_old_channel __user *) arg,
455 sizeof(struct lttng_kernel_old_channel)))
457 chan_param.overwrite = old_chan_param.overwrite;
458 chan_param.subbuf_size = old_chan_param.subbuf_size;
459 chan_param.num_subbuf = old_chan_param.num_subbuf;
460 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
461 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
462 chan_param.output = old_chan_param.output;
464 return lttng_abi_create_channel(file, &chan_param,
467 case LTTNG_KERNEL_METADATA:
469 struct lttng_kernel_channel chan_param;
471 if (copy_from_user(&chan_param,
472 (struct lttng_kernel_channel __user *) arg,
473 sizeof(struct lttng_kernel_channel)))
475 return lttng_abi_create_channel(file, &chan_param,
484 * Called when the last file reference is dropped.
486 * Big fat note: channels and events are invariant for the whole session after
487 * their creation. So this session destruction also destroys all channel and
488 * event structures specific to this session (they are not destroyed when their
489 * individual file is released).
492 int lttng_session_release(struct inode *inode, struct file *file)
494 struct lttng_session *session = file->private_data;
497 lttng_session_destroy(session);
501 static const struct file_operations lttng_session_fops = {
502 .owner = THIS_MODULE,
503 .release = lttng_session_release,
504 .unlocked_ioctl = lttng_session_ioctl,
506 .compat_ioctl = lttng_session_ioctl,
511 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
515 * Handles the poll operations for the metadata channels.
518 unsigned int lttng_metadata_ring_buffer_poll(struct file *filp,
521 struct lttng_metadata_stream *stream = filp->private_data;
522 struct lib_ring_buffer *buf = stream->priv;
524 unsigned int mask = 0;
526 if (filp->f_mode & FMODE_READ) {
527 poll_wait_set_exclusive(wait);
528 poll_wait(filp, &stream->read_wait, wait);
530 finalized = stream->finalized;
533 * lib_ring_buffer_is_finalized() contains a smp_rmb()
534 * ordering finalized load before offsets loads.
536 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
541 if (stream->metadata_cache->metadata_written >
542 stream->metadata_out)
550 int lttng_metadata_ring_buffer_ioctl_get_next_subbuf(struct file *filp,
551 unsigned int cmd, unsigned long arg)
553 struct lttng_metadata_stream *stream = filp->private_data;
554 struct lib_ring_buffer *buf = stream->priv;
555 struct channel *chan = buf->backend.chan;
558 ret = lttng_metadata_output_channel(stream, chan);
560 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
567 void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file *filp,
568 unsigned int cmd, unsigned long arg)
570 struct lttng_metadata_stream *stream = filp->private_data;
572 stream->metadata_out = stream->metadata_in;
576 long lttng_metadata_ring_buffer_ioctl(struct file *filp,
577 unsigned int cmd, unsigned long arg)
580 struct lttng_metadata_stream *stream = filp->private_data;
581 struct lib_ring_buffer *buf = stream->priv;
584 case RING_BUFFER_GET_NEXT_SUBBUF:
586 ret = lttng_metadata_ring_buffer_ioctl_get_next_subbuf(filp,
592 case RING_BUFFER_GET_SUBBUF:
595 * Random access is not allowed for metadata channel.
602 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
604 /* Performing lib ring buffer ioctl after our own. */
605 ret = lib_ring_buffer_ioctl(filp, cmd, arg, buf);
610 case RING_BUFFER_PUT_NEXT_SUBBUF:
612 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
625 long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp,
626 unsigned int cmd, unsigned long arg)
629 struct lttng_metadata_stream *stream = filp->private_data;
630 struct lib_ring_buffer *buf = stream->priv;
633 case RING_BUFFER_GET_NEXT_SUBBUF:
635 ret = lttng_metadata_ring_buffer_ioctl_get_next_subbuf(filp,
641 case RING_BUFFER_GET_SUBBUF:
644 * Random access is not allowed for metadata channel.
651 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
653 /* Performing lib ring buffer ioctl after our own. */
654 ret = lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
659 case RING_BUFFER_PUT_NEXT_SUBBUF:
661 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
674 * This is not used by anonymous file descriptors. This code is left
675 * there if we ever want to implement an inode with open() operation.
678 int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file)
680 struct lttng_metadata_stream *stream = inode->i_private;
681 struct lib_ring_buffer *buf = stream->priv;
683 file->private_data = buf;
685 * Since life-time of metadata cache differs from that of
686 * session, we need to keep our own reference on the transport.
688 if (!try_module_get(stream->transport->owner)) {
689 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
692 return lib_ring_buffer_open(inode, file, buf);
696 int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file)
698 struct lttng_metadata_stream *stream = file->private_data;
699 struct lib_ring_buffer *buf = stream->priv;
701 kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
702 module_put(stream->transport->owner);
703 return lib_ring_buffer_release(inode, file, buf);
707 ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
708 struct pipe_inode_info *pipe, size_t len,
711 struct lttng_metadata_stream *stream = in->private_data;
712 struct lib_ring_buffer *buf = stream->priv;
714 return lib_ring_buffer_splice_read(in, ppos, pipe, len,
719 int lttng_metadata_ring_buffer_mmap(struct file *filp,
720 struct vm_area_struct *vma)
722 struct lttng_metadata_stream *stream = filp->private_data;
723 struct lib_ring_buffer *buf = stream->priv;
725 return lib_ring_buffer_mmap(filp, vma, buf);
729 const struct file_operations lttng_metadata_ring_buffer_file_operations = {
730 .owner = THIS_MODULE,
731 .open = lttng_metadata_ring_buffer_open,
732 .release = lttng_metadata_ring_buffer_release,
733 .poll = lttng_metadata_ring_buffer_poll,
734 .splice_read = lttng_metadata_ring_buffer_splice_read,
735 .mmap = lttng_metadata_ring_buffer_mmap,
736 .unlocked_ioctl = lttng_metadata_ring_buffer_ioctl,
737 .llseek = vfs_lib_ring_buffer_no_llseek,
739 .compat_ioctl = lttng_metadata_ring_buffer_compat_ioctl,
744 int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
745 const struct file_operations *fops)
748 struct file *stream_file;
750 stream_fd = get_unused_fd();
755 stream_file = anon_inode_getfile("[lttng_stream]", fops,
756 stream_priv, O_RDWR);
757 if (IS_ERR(stream_file)) {
758 ret = PTR_ERR(stream_file);
762 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
763 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
764 * file descriptor, so we set FMODE_PREAD here.
766 stream_file->f_mode |= FMODE_PREAD;
767 fd_install(stream_fd, stream_file);
769 * The stream holds a reference to the channel within the generic ring
770 * buffer library, so no need to hold a refcount on the channel and
771 * session files here.
776 put_unused_fd(stream_fd);
782 int lttng_abi_open_stream(struct file *channel_file)
784 struct lttng_channel *channel = channel_file->private_data;
785 struct lib_ring_buffer *buf;
789 buf = channel->ops->buffer_read_open(channel->chan);
794 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
795 &lib_ring_buffer_file_operations);
802 channel->ops->buffer_read_close(buf);
807 int lttng_abi_open_metadata_stream(struct file *channel_file)
809 struct lttng_channel *channel = channel_file->private_data;
810 struct lttng_session *session = channel->session;
811 struct lib_ring_buffer *buf;
813 struct lttng_metadata_stream *metadata_stream;
816 buf = channel->ops->buffer_read_open(channel->chan);
820 metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
822 if (!metadata_stream) {
826 metadata_stream->metadata_cache = session->metadata_cache;
827 init_waitqueue_head(&metadata_stream->read_wait);
828 metadata_stream->priv = buf;
829 stream_priv = metadata_stream;
830 metadata_stream->transport = channel->transport;
833 * Since life-time of metadata cache differs from that of
834 * session, we need to keep our own reference on the transport.
836 if (!try_module_get(metadata_stream->transport->owner)) {
837 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
842 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
843 <tng_metadata_ring_buffer_file_operations);
847 kref_get(&session->metadata_cache->refcount);
848 list_add(&metadata_stream->list,
849 &session->metadata_cache->metadata_stream);
853 module_put(metadata_stream->transport->owner);
855 kfree(metadata_stream);
857 channel->ops->buffer_read_close(buf);
862 int lttng_abi_create_event(struct file *channel_file,
863 struct lttng_kernel_event *event_param)
865 struct lttng_channel *channel = channel_file->private_data;
866 struct lttng_event *event;
868 struct file *event_file;
870 event_param->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
871 switch (event_param->instrumentation) {
872 case LTTNG_KERNEL_KRETPROBE:
873 event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
875 case LTTNG_KERNEL_KPROBE:
876 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
878 case LTTNG_KERNEL_FUNCTION:
879 event_param->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
884 switch (event_param->instrumentation) {
886 event_fd = get_unused_fd();
891 event_file = anon_inode_getfile("[lttng_event]",
894 if (IS_ERR(event_file)) {
895 ret = PTR_ERR(event_file);
899 * We tolerate no failure path after event creation. It
900 * will stay invariant for the rest of the session.
902 event = lttng_event_create(channel, event_param, NULL, NULL);
907 event_file->private_data = event;
908 fd_install(event_fd, event_file);
909 /* The event holds a reference on the channel */
910 atomic_long_inc(&channel_file->f_count);
912 case LTTNG_KERNEL_SYSCALL:
914 * Only all-syscall tracing supported for now.
916 if (event_param->name[0] != '\0')
918 ret = lttng_syscalls_register(channel, NULL);
929 put_unused_fd(event_fd);
935 * lttng_channel_ioctl - lttng syscall through ioctl
941 * This ioctl implements lttng commands:
942 * LTTNG_KERNEL_STREAM
943 * Returns an event stream file descriptor or failure.
944 * (typically, one event stream records events from one CPU)
946 * Returns an event file descriptor or failure.
947 * LTTNG_KERNEL_CONTEXT
948 * Prepend a context field to each event in the channel
949 * LTTNG_KERNEL_ENABLE
950 * Enable recording for events in this channel (weak enable)
951 * LTTNG_KERNEL_DISABLE
952 * Disable recording for events in this channel (strong disable)
954 * Channel and event file descriptors also hold a reference on the session.
957 long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
959 struct lttng_channel *channel = file->private_data;
962 case LTTNG_KERNEL_OLD_STREAM:
963 case LTTNG_KERNEL_STREAM:
964 return lttng_abi_open_stream(file);
965 case LTTNG_KERNEL_OLD_EVENT:
967 struct lttng_kernel_event *uevent_param;
968 struct lttng_kernel_old_event *old_uevent_param;
971 uevent_param = kmalloc(sizeof(struct lttng_kernel_event),
977 old_uevent_param = kmalloc(
978 sizeof(struct lttng_kernel_old_event),
980 if (!old_uevent_param) {
982 goto old_event_error_free_param;
984 if (copy_from_user(old_uevent_param,
985 (struct lttng_kernel_old_event __user *) arg,
986 sizeof(struct lttng_kernel_old_event))) {
988 goto old_event_error_free_old_param;
991 memcpy(uevent_param->name, old_uevent_param->name,
992 sizeof(uevent_param->name));
993 uevent_param->instrumentation =
994 old_uevent_param->instrumentation;
996 switch (old_uevent_param->instrumentation) {
997 case LTTNG_KERNEL_KPROBE:
998 uevent_param->u.kprobe.addr =
999 old_uevent_param->u.kprobe.addr;
1000 uevent_param->u.kprobe.offset =
1001 old_uevent_param->u.kprobe.offset;
1002 memcpy(uevent_param->u.kprobe.symbol_name,
1003 old_uevent_param->u.kprobe.symbol_name,
1004 sizeof(uevent_param->u.kprobe.symbol_name));
1006 case LTTNG_KERNEL_KRETPROBE:
1007 uevent_param->u.kretprobe.addr =
1008 old_uevent_param->u.kretprobe.addr;
1009 uevent_param->u.kretprobe.offset =
1010 old_uevent_param->u.kretprobe.offset;
1011 memcpy(uevent_param->u.kretprobe.symbol_name,
1012 old_uevent_param->u.kretprobe.symbol_name,
1013 sizeof(uevent_param->u.kretprobe.symbol_name));
1015 case LTTNG_KERNEL_FUNCTION:
1016 memcpy(uevent_param->u.ftrace.symbol_name,
1017 old_uevent_param->u.ftrace.symbol_name,
1018 sizeof(uevent_param->u.ftrace.symbol_name));
1023 ret = lttng_abi_create_event(file, uevent_param);
1025 old_event_error_free_old_param:
1026 kfree(old_uevent_param);
1027 old_event_error_free_param:
1028 kfree(uevent_param);
1032 case LTTNG_KERNEL_EVENT:
1034 struct lttng_kernel_event uevent_param;
1036 if (copy_from_user(&uevent_param,
1037 (struct lttng_kernel_event __user *) arg,
1038 sizeof(uevent_param)))
1040 return lttng_abi_create_event(file, &uevent_param);
1042 case LTTNG_KERNEL_OLD_CONTEXT:
1044 struct lttng_kernel_context *ucontext_param;
1045 struct lttng_kernel_old_context *old_ucontext_param;
1048 ucontext_param = kmalloc(sizeof(struct lttng_kernel_context),
1050 if (!ucontext_param) {
1054 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_old_context),
1056 if (!old_ucontext_param) {
1058 goto old_ctx_error_free_param;
1061 if (copy_from_user(old_ucontext_param,
1062 (struct lttng_kernel_old_context __user *) arg,
1063 sizeof(struct lttng_kernel_old_context))) {
1065 goto old_ctx_error_free_old_param;
1067 ucontext_param->ctx = old_ucontext_param->ctx;
1068 memcpy(ucontext_param->padding, old_ucontext_param->padding,
1069 sizeof(ucontext_param->padding));
1070 /* only type that uses the union */
1071 if (old_ucontext_param->ctx == LTTNG_KERNEL_CONTEXT_PERF_COUNTER) {
1072 ucontext_param->u.perf_counter.type =
1073 old_ucontext_param->u.perf_counter.type;
1074 ucontext_param->u.perf_counter.config =
1075 old_ucontext_param->u.perf_counter.config;
1076 memcpy(ucontext_param->u.perf_counter.name,
1077 old_ucontext_param->u.perf_counter.name,
1078 sizeof(ucontext_param->u.perf_counter.name));
1081 ret = lttng_abi_add_context(file,
1083 &channel->ctx, channel->session);
1085 old_ctx_error_free_old_param:
1086 kfree(old_ucontext_param);
1087 old_ctx_error_free_param:
1088 kfree(ucontext_param);
1092 case LTTNG_KERNEL_CONTEXT:
1094 struct lttng_kernel_context ucontext_param;
1096 if (copy_from_user(&ucontext_param,
1097 (struct lttng_kernel_context __user *) arg,
1098 sizeof(ucontext_param)))
1100 return lttng_abi_add_context(file,
1102 &channel->ctx, channel->session);
1104 case LTTNG_KERNEL_OLD_ENABLE:
1105 case LTTNG_KERNEL_ENABLE:
1106 return lttng_channel_enable(channel);
1107 case LTTNG_KERNEL_OLD_DISABLE:
1108 case LTTNG_KERNEL_DISABLE:
1109 return lttng_channel_disable(channel);
1111 return -ENOIOCTLCMD;
1117 * lttng_metadata_ioctl - lttng syscall through ioctl
1123 * This ioctl implements lttng commands:
1124 * LTTNG_KERNEL_STREAM
1125 * Returns an event stream file descriptor or failure.
1127 * Channel and event file descriptors also hold a reference on the session.
1130 long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1133 case LTTNG_KERNEL_OLD_STREAM:
1134 case LTTNG_KERNEL_STREAM:
1135 return lttng_abi_open_metadata_stream(file);
1137 return -ENOIOCTLCMD;
1142 * lttng_channel_poll - lttng stream addition/removal monitoring
1147 unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
1149 struct lttng_channel *channel = file->private_data;
1150 unsigned int mask = 0;
1152 if (file->f_mode & FMODE_READ) {
1153 poll_wait_set_exclusive(wait);
1154 poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan),
1157 if (channel->ops->is_disabled(channel->chan))
1159 if (channel->ops->is_finalized(channel->chan))
1161 if (channel->ops->buffer_has_read_closed_stream(channel->chan))
1162 return POLLIN | POLLRDNORM;
1170 int lttng_channel_release(struct inode *inode, struct file *file)
1172 struct lttng_channel *channel = file->private_data;
1175 fput(channel->session->file);
1180 int lttng_metadata_channel_release(struct inode *inode, struct file *file)
1182 struct lttng_channel *channel = file->private_data;
1185 lttng_metadata_channel_destroy(channel);
1186 fput(channel->session->file);
1192 static const struct file_operations lttng_channel_fops = {
1193 .owner = THIS_MODULE,
1194 .release = lttng_channel_release,
1195 .poll = lttng_channel_poll,
1196 .unlocked_ioctl = lttng_channel_ioctl,
1197 #ifdef CONFIG_COMPAT
1198 .compat_ioctl = lttng_channel_ioctl,
1202 static const struct file_operations lttng_metadata_fops = {
1203 .owner = THIS_MODULE,
1204 .release = lttng_metadata_channel_release,
1205 .unlocked_ioctl = lttng_metadata_ioctl,
1206 #ifdef CONFIG_COMPAT
1207 .compat_ioctl = lttng_metadata_ioctl,
1212 * lttng_event_ioctl - lttng syscall through ioctl
1218 * This ioctl implements lttng commands:
1219 * LTTNG_KERNEL_CONTEXT
1220 * Prepend a context field to each record of this event
1221 * LTTNG_KERNEL_ENABLE
1222 * Enable recording for this event (weak enable)
1223 * LTTNG_KERNEL_DISABLE
1224 * Disable recording for this event (strong disable)
1227 long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1229 struct lttng_event *event = file->private_data;
1232 case LTTNG_KERNEL_OLD_CONTEXT:
1234 struct lttng_kernel_context *ucontext_param;
1235 struct lttng_kernel_old_context *old_ucontext_param;
1238 ucontext_param = kmalloc(sizeof(struct lttng_kernel_context),
1240 if (!ucontext_param) {
1244 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_old_context),
1246 if (!old_ucontext_param) {
1248 goto old_ctx_error_free_param;
1251 if (copy_from_user(old_ucontext_param,
1252 (struct lttng_kernel_old_context __user *) arg,
1253 sizeof(struct lttng_kernel_old_context))) {
1255 goto old_ctx_error_free_old_param;
1257 ucontext_param->ctx = old_ucontext_param->ctx;
1258 memcpy(ucontext_param->padding, old_ucontext_param->padding,
1259 sizeof(ucontext_param->padding));
1260 /* only type that uses the union */
1261 if (old_ucontext_param->ctx == LTTNG_KERNEL_CONTEXT_PERF_COUNTER) {
1262 ucontext_param->u.perf_counter.type =
1263 old_ucontext_param->u.perf_counter.type;
1264 ucontext_param->u.perf_counter.config =
1265 old_ucontext_param->u.perf_counter.config;
1266 memcpy(ucontext_param->u.perf_counter.name,
1267 old_ucontext_param->u.perf_counter.name,
1268 sizeof(ucontext_param->u.perf_counter.name));
1271 ret = lttng_abi_add_context(file,
1273 &event->ctx, event->chan->session);
1275 old_ctx_error_free_old_param:
1276 kfree(old_ucontext_param);
1277 old_ctx_error_free_param:
1278 kfree(ucontext_param);
1282 case LTTNG_KERNEL_CONTEXT:
1284 struct lttng_kernel_context ucontext_param;
1286 if (copy_from_user(&ucontext_param,
1287 (struct lttng_kernel_context __user *) arg,
1288 sizeof(ucontext_param)))
1290 return lttng_abi_add_context(file,
1292 &event->ctx, event->chan->session);
1294 case LTTNG_KERNEL_OLD_ENABLE:
1295 case LTTNG_KERNEL_ENABLE:
1296 return lttng_event_enable(event);
1297 case LTTNG_KERNEL_OLD_DISABLE:
1298 case LTTNG_KERNEL_DISABLE:
1299 return lttng_event_disable(event);
1301 return -ENOIOCTLCMD;
1306 int lttng_event_release(struct inode *inode, struct file *file)
1308 struct lttng_event *event = file->private_data;
1311 fput(event->chan->file);
1315 /* TODO: filter control ioctl */
1316 static const struct file_operations lttng_event_fops = {
1317 .owner = THIS_MODULE,
1318 .release = lttng_event_release,
1319 .unlocked_ioctl = lttng_event_ioctl,
1320 #ifdef CONFIG_COMPAT
1321 .compat_ioctl = lttng_event_ioctl,
1325 int __init lttng_abi_init(void)
1329 wrapper_vmalloc_sync_all();
1330 lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
1333 if (!lttng_proc_dentry) {
1334 printk(KERN_ERR "Error creating LTTng control file\n");
1342 void __exit lttng_abi_exit(void)
1344 if (lttng_proc_dentry)
1345 remove_proc_entry("lttng", NULL);