1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Mimic system calls for:
10 * - session creation, returns a file descriptor or failure.
11 * - channel creation, returns a file descriptor or failure.
12 * - Operates on a session file descriptor
13 * - Takes all channel options as parameters.
14 * - stream get, returns a file descriptor or failure.
15 * - Operates on a channel file descriptor.
16 * - stream notifier get, returns a file descriptor or failure.
17 * - Operates on a channel file descriptor.
18 * - event creation, returns a file descriptor or failure.
19 * - Operates on a channel file descriptor
20 * - Takes an event name as parameter
21 * - Takes an instrumentation source as parameter
22 * - e.g. tracepoints, dynamic_probes...
23 * - Takes instrumentation source specific arguments.
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/anon_inodes.h>
29 #include <linux/file.h>
30 #include <linux/uaccess.h>
31 #include <linux/slab.h>
32 #include <linux/err.h>
33 #include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
34 #include <ringbuffer/vfs.h>
35 #include <ringbuffer/backend.h>
36 #include <ringbuffer/frontend.h>
37 #include <wrapper/poll.h>
38 #include <wrapper/file.h>
39 #include <wrapper/kref.h>
40 #include <lttng/string-utils.h>
41 #include <lttng/abi.h>
42 #include <lttng/abi-old.h>
43 #include <lttng/events.h>
44 #include <lttng/tracer.h>
45 #include <lttng/tp-mempool.h>
46 #include <ringbuffer/frontend_types.h>
47 #include <ringbuffer/iterator.h>
50 * This is LTTng's own personal way to create a system call as an external
51 * module. We use ioctl() on /proc/lttng.
54 static struct proc_dir_entry
*lttng_proc_dentry
;
56 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
57 static const struct proc_ops lttng_proc_ops
;
59 static const struct file_operations lttng_proc_ops
;
62 static const struct file_operations lttng_session_fops
;
63 static const struct file_operations lttng_event_notifier_group_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
;
67 static struct file_operations lttng_stream_ring_buffer_file_operations
;
69 static int put_u64(uint64_t val
, unsigned long arg
);
70 static int put_u32(uint32_t val
, unsigned long arg
);
73 * Teardown management: opened file descriptors keep a refcount on the module,
74 * so it can only exit when all file descriptors are closed.
78 int lttng_abi_create_session(void)
80 struct lttng_session
*session
;
81 struct file
*session_file
;
84 session
= lttng_session_create();
87 session_fd
= lttng_get_unused_fd();
92 session_file
= anon_inode_getfile("[lttng_session]",
95 if (IS_ERR(session_file
)) {
96 ret
= PTR_ERR(session_file
);
99 session
->file
= session_file
;
100 fd_install(session_fd
, session_file
);
104 put_unused_fd(session_fd
);
106 lttng_session_destroy(session
);
110 void event_notifier_send_notification_work_wakeup(struct irq_work
*entry
)
112 struct lttng_event_notifier_group
*event_notifier_group
=
113 container_of(entry
, struct lttng_event_notifier_group
,
115 wake_up_interruptible(&event_notifier_group
->read_wait
);
119 int lttng_abi_create_event_notifier_group(void)
121 struct lttng_event_notifier_group
*event_notifier_group
;
122 struct file
*event_notifier_group_file
;
123 int event_notifier_group_fd
, ret
;
125 event_notifier_group
= lttng_event_notifier_group_create();
126 if (!event_notifier_group
)
129 event_notifier_group_fd
= lttng_get_unused_fd();
130 if (event_notifier_group_fd
< 0) {
131 ret
= event_notifier_group_fd
;
134 event_notifier_group_file
= anon_inode_getfile("[lttng_event_notifier_group]",
135 <tng_event_notifier_group_fops
,
136 event_notifier_group
, O_RDWR
);
137 if (IS_ERR(event_notifier_group_file
)) {
138 ret
= PTR_ERR(event_notifier_group_file
);
142 event_notifier_group
->file
= event_notifier_group_file
;
143 init_waitqueue_head(&event_notifier_group
->read_wait
);
144 init_irq_work(&event_notifier_group
->wakeup_pending
,
145 event_notifier_send_notification_work_wakeup
);
146 fd_install(event_notifier_group_fd
, event_notifier_group_file
);
147 return event_notifier_group_fd
;
150 put_unused_fd(event_notifier_group_fd
);
152 lttng_event_notifier_group_destroy(event_notifier_group
);
157 int lttng_abi_tracepoint_list(void)
159 struct file
*tracepoint_list_file
;
162 file_fd
= lttng_get_unused_fd();
168 tracepoint_list_file
= anon_inode_getfile("[lttng_tracepoint_list]",
169 <tng_tracepoint_list_fops
,
171 if (IS_ERR(tracepoint_list_file
)) {
172 ret
= PTR_ERR(tracepoint_list_file
);
175 ret
= lttng_tracepoint_list_fops
.open(NULL
, tracepoint_list_file
);
178 fd_install(file_fd
, tracepoint_list_file
);
182 fput(tracepoint_list_file
);
184 put_unused_fd(file_fd
);
189 #ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
191 int lttng_abi_syscall_list(void)
197 int lttng_abi_syscall_list(void)
199 struct file
*syscall_list_file
;
202 file_fd
= lttng_get_unused_fd();
208 syscall_list_file
= anon_inode_getfile("[lttng_syscall_list]",
209 <tng_syscall_list_fops
,
211 if (IS_ERR(syscall_list_file
)) {
212 ret
= PTR_ERR(syscall_list_file
);
215 ret
= lttng_syscall_list_fops
.open(NULL
, syscall_list_file
);
218 fd_install(file_fd
, syscall_list_file
);
222 fput(syscall_list_file
);
224 put_unused_fd(file_fd
);
231 void lttng_abi_tracer_version(struct lttng_kernel_tracer_version
*v
)
233 v
->major
= LTTNG_MODULES_MAJOR_VERSION
;
234 v
->minor
= LTTNG_MODULES_MINOR_VERSION
;
235 v
->patchlevel
= LTTNG_MODULES_PATCHLEVEL_VERSION
;
239 void lttng_abi_tracer_abi_version(struct lttng_kernel_tracer_abi_version
*v
)
241 v
->major
= LTTNG_MODULES_ABI_MAJOR_VERSION
;
242 v
->minor
= LTTNG_MODULES_ABI_MINOR_VERSION
;
246 long lttng_abi_add_context(struct file
*file
,
247 struct lttng_kernel_context
*context_param
,
248 struct lttng_ctx
**ctx
, struct lttng_session
*session
)
251 if (session
->been_active
)
254 switch (context_param
->ctx
) {
255 case LTTNG_KERNEL_CONTEXT_PID
:
256 return lttng_add_pid_to_ctx(ctx
);
257 case LTTNG_KERNEL_CONTEXT_PRIO
:
258 return lttng_add_prio_to_ctx(ctx
);
259 case LTTNG_KERNEL_CONTEXT_NICE
:
260 return lttng_add_nice_to_ctx(ctx
);
261 case LTTNG_KERNEL_CONTEXT_VPID
:
262 return lttng_add_vpid_to_ctx(ctx
);
263 case LTTNG_KERNEL_CONTEXT_TID
:
264 return lttng_add_tid_to_ctx(ctx
);
265 case LTTNG_KERNEL_CONTEXT_VTID
:
266 return lttng_add_vtid_to_ctx(ctx
);
267 case LTTNG_KERNEL_CONTEXT_PPID
:
268 return lttng_add_ppid_to_ctx(ctx
);
269 case LTTNG_KERNEL_CONTEXT_VPPID
:
270 return lttng_add_vppid_to_ctx(ctx
);
271 case LTTNG_KERNEL_CONTEXT_PERF_COUNTER
:
272 context_param
->u
.perf_counter
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
273 return lttng_add_perf_counter_to_ctx(context_param
->u
.perf_counter
.type
,
274 context_param
->u
.perf_counter
.config
,
275 context_param
->u
.perf_counter
.name
,
277 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
278 return lttng_add_procname_to_ctx(ctx
);
279 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
280 return lttng_add_hostname_to_ctx(ctx
);
281 case LTTNG_KERNEL_CONTEXT_CPU_ID
:
282 return lttng_add_cpu_id_to_ctx(ctx
);
283 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
284 return lttng_add_interruptible_to_ctx(ctx
);
285 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
286 return lttng_add_need_reschedule_to_ctx(ctx
);
287 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
288 return lttng_add_preemptible_to_ctx(ctx
);
289 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
290 return lttng_add_migratable_to_ctx(ctx
);
291 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
:
292 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
:
293 return lttng_add_callstack_to_ctx(ctx
, context_param
->ctx
);
294 case LTTNG_KERNEL_CONTEXT_CGROUP_NS
:
295 return lttng_add_cgroup_ns_to_ctx(ctx
);
296 case LTTNG_KERNEL_CONTEXT_IPC_NS
:
297 return lttng_add_ipc_ns_to_ctx(ctx
);
298 case LTTNG_KERNEL_CONTEXT_MNT_NS
:
299 return lttng_add_mnt_ns_to_ctx(ctx
);
300 case LTTNG_KERNEL_CONTEXT_NET_NS
:
301 return lttng_add_net_ns_to_ctx(ctx
);
302 case LTTNG_KERNEL_CONTEXT_PID_NS
:
303 return lttng_add_pid_ns_to_ctx(ctx
);
304 case LTTNG_KERNEL_CONTEXT_USER_NS
:
305 return lttng_add_user_ns_to_ctx(ctx
);
306 case LTTNG_KERNEL_CONTEXT_UTS_NS
:
307 return lttng_add_uts_ns_to_ctx(ctx
);
308 case LTTNG_KERNEL_CONTEXT_UID
:
309 return lttng_add_uid_to_ctx(ctx
);
310 case LTTNG_KERNEL_CONTEXT_EUID
:
311 return lttng_add_euid_to_ctx(ctx
);
312 case LTTNG_KERNEL_CONTEXT_SUID
:
313 return lttng_add_suid_to_ctx(ctx
);
314 case LTTNG_KERNEL_CONTEXT_GID
:
315 return lttng_add_gid_to_ctx(ctx
);
316 case LTTNG_KERNEL_CONTEXT_EGID
:
317 return lttng_add_egid_to_ctx(ctx
);
318 case LTTNG_KERNEL_CONTEXT_SGID
:
319 return lttng_add_sgid_to_ctx(ctx
);
320 case LTTNG_KERNEL_CONTEXT_VUID
:
321 return lttng_add_vuid_to_ctx(ctx
);
322 case LTTNG_KERNEL_CONTEXT_VEUID
:
323 return lttng_add_veuid_to_ctx(ctx
);
324 case LTTNG_KERNEL_CONTEXT_VSUID
:
325 return lttng_add_vsuid_to_ctx(ctx
);
326 case LTTNG_KERNEL_CONTEXT_VGID
:
327 return lttng_add_vgid_to_ctx(ctx
);
328 case LTTNG_KERNEL_CONTEXT_VEGID
:
329 return lttng_add_vegid_to_ctx(ctx
);
330 case LTTNG_KERNEL_CONTEXT_VSGID
:
331 return lttng_add_vsgid_to_ctx(ctx
);
332 case LTTNG_KERNEL_CONTEXT_TIME_NS
:
333 return lttng_add_time_ns_to_ctx(ctx
);
340 * lttng_ioctl - lttng syscall through ioctl
346 * This ioctl implements lttng commands:
347 * LTTNG_KERNEL_SESSION
348 * Returns a LTTng trace session file descriptor
349 * LTTNG_KERNEL_TRACER_VERSION
350 * Returns the LTTng kernel tracer version
351 * LTTNG_KERNEL_TRACEPOINT_LIST
352 * Returns a file descriptor listing available tracepoints
353 * LTTNG_KERNEL_WAIT_QUIESCENT
354 * Returns after all previously running probes have completed
355 * LTTNG_KERNEL_TRACER_ABI_VERSION
356 * Returns the LTTng kernel tracer ABI version
357 * LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_CREATE
358 * Returns a LTTng event notifier group file descriptor
360 * The returned session will be deleted when its file descriptor is closed.
363 long lttng_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
366 case LTTNG_KERNEL_OLD_SESSION
:
367 case LTTNG_KERNEL_SESSION
:
368 return lttng_abi_create_session();
369 case LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_CREATE
:
370 return lttng_abi_create_event_notifier_group();
371 case LTTNG_KERNEL_OLD_TRACER_VERSION
:
373 struct lttng_kernel_tracer_version v
;
374 struct lttng_kernel_old_tracer_version oldv
;
375 struct lttng_kernel_old_tracer_version
*uversion
=
376 (struct lttng_kernel_old_tracer_version __user
*) arg
;
378 lttng_abi_tracer_version(&v
);
379 oldv
.major
= v
.major
;
380 oldv
.minor
= v
.minor
;
381 oldv
.patchlevel
= v
.patchlevel
;
383 if (copy_to_user(uversion
, &oldv
, sizeof(oldv
)))
387 case LTTNG_KERNEL_TRACER_VERSION
:
389 struct lttng_kernel_tracer_version version
;
390 struct lttng_kernel_tracer_version
*uversion
=
391 (struct lttng_kernel_tracer_version __user
*) arg
;
393 lttng_abi_tracer_version(&version
);
395 if (copy_to_user(uversion
, &version
, sizeof(version
)))
399 case LTTNG_KERNEL_TRACER_ABI_VERSION
:
401 struct lttng_kernel_tracer_abi_version version
;
402 struct lttng_kernel_tracer_abi_version
*uversion
=
403 (struct lttng_kernel_tracer_abi_version __user
*) arg
;
405 lttng_abi_tracer_abi_version(&version
);
407 if (copy_to_user(uversion
, &version
, sizeof(version
)))
411 case LTTNG_KERNEL_OLD_TRACEPOINT_LIST
:
412 case LTTNG_KERNEL_TRACEPOINT_LIST
:
413 return lttng_abi_tracepoint_list();
414 case LTTNG_KERNEL_SYSCALL_LIST
:
415 return lttng_abi_syscall_list();
416 case LTTNG_KERNEL_OLD_WAIT_QUIESCENT
:
417 case LTTNG_KERNEL_WAIT_QUIESCENT
:
420 case LTTNG_KERNEL_OLD_CALIBRATE
:
422 struct lttng_kernel_old_calibrate __user
*ucalibrate
=
423 (struct lttng_kernel_old_calibrate __user
*) arg
;
424 struct lttng_kernel_old_calibrate old_calibrate
;
425 struct lttng_kernel_calibrate calibrate
;
428 if (copy_from_user(&old_calibrate
, ucalibrate
, sizeof(old_calibrate
)))
430 calibrate
.type
= old_calibrate
.type
;
431 ret
= lttng_calibrate(&calibrate
);
432 if (copy_to_user(ucalibrate
, &old_calibrate
, sizeof(old_calibrate
)))
436 case LTTNG_KERNEL_CALIBRATE
:
438 struct lttng_kernel_calibrate __user
*ucalibrate
=
439 (struct lttng_kernel_calibrate __user
*) arg
;
440 struct lttng_kernel_calibrate calibrate
;
443 if (copy_from_user(&calibrate
, ucalibrate
, sizeof(calibrate
)))
445 ret
= lttng_calibrate(&calibrate
);
446 if (copy_to_user(ucalibrate
, &calibrate
, sizeof(calibrate
)))
455 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
456 static const struct proc_ops lttng_proc_ops
= {
457 .proc_ioctl
= lttng_ioctl
,
459 .proc_compat_ioctl
= lttng_ioctl
,
460 #endif /* CONFIG_COMPAT */
463 static const struct file_operations lttng_proc_ops
= {
464 .owner
= THIS_MODULE
,
465 .unlocked_ioctl
= lttng_ioctl
,
467 .compat_ioctl
= lttng_ioctl
,
468 #endif /* CONFIG_COMPAT */
473 int lttng_abi_create_channel(struct file
*session_file
,
474 struct lttng_kernel_channel
*chan_param
,
475 enum channel_type channel_type
)
477 struct lttng_session
*session
= session_file
->private_data
;
478 const struct file_operations
*fops
= NULL
;
479 const char *transport_name
;
480 struct lttng_channel
*chan
;
481 struct file
*chan_file
;
485 chan_fd
= lttng_get_unused_fd();
490 switch (channel_type
) {
491 case PER_CPU_CHANNEL
:
492 fops
= <tng_channel_fops
;
494 case METADATA_CHANNEL
:
495 fops
= <tng_metadata_fops
;
499 chan_file
= anon_inode_getfile("[lttng_channel]",
502 if (IS_ERR(chan_file
)) {
503 ret
= PTR_ERR(chan_file
);
506 switch (channel_type
) {
507 case PER_CPU_CHANNEL
:
508 if (chan_param
->output
== LTTNG_KERNEL_SPLICE
) {
509 transport_name
= chan_param
->overwrite
?
510 "relay-overwrite" : "relay-discard";
511 } else if (chan_param
->output
== LTTNG_KERNEL_MMAP
) {
512 transport_name
= chan_param
->overwrite
?
513 "relay-overwrite-mmap" : "relay-discard-mmap";
518 case METADATA_CHANNEL
:
519 if (chan_param
->output
== LTTNG_KERNEL_SPLICE
)
520 transport_name
= "relay-metadata";
521 else if (chan_param
->output
== LTTNG_KERNEL_MMAP
)
522 transport_name
= "relay-metadata-mmap";
527 transport_name
= "<unknown>";
530 if (!atomic_long_add_unless(&session_file
->f_count
, 1, LONG_MAX
)) {
535 * We tolerate no failure path after channel creation. It will stay
536 * invariant for the rest of the session.
538 chan
= lttng_channel_create(session
, transport_name
, NULL
,
539 chan_param
->subbuf_size
,
540 chan_param
->num_subbuf
,
541 chan_param
->switch_timer_interval
,
542 chan_param
->read_timer_interval
,
548 chan
->file
= chan_file
;
549 chan_file
->private_data
= chan
;
550 fd_install(chan_fd
, chan_file
);
555 atomic_long_dec(&session_file
->f_count
);
559 put_unused_fd(chan_fd
);
565 int lttng_abi_session_set_name(struct lttng_session
*session
,
566 struct lttng_kernel_session_name
*name
)
570 len
= strnlen(name
->name
, LTTNG_KERNEL_SESSION_NAME_LEN
);
572 if (len
== LTTNG_KERNEL_SESSION_NAME_LEN
) {
573 /* Name is too long/malformed */
577 strcpy(session
->name
, name
->name
);
582 int lttng_abi_session_set_creation_time(struct lttng_session
*session
,
583 struct lttng_kernel_session_creation_time
*time
)
587 len
= strnlen(time
->iso8601
, LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN
);
589 if (len
== LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN
) {
590 /* Time is too long/malformed */
594 strcpy(session
->creation_time
, time
->iso8601
);
599 enum tracker_type
get_tracker_type(struct lttng_kernel_tracker_args
*tracker
)
601 switch (tracker
->type
) {
602 case LTTNG_KERNEL_TRACKER_PID
:
604 case LTTNG_KERNEL_TRACKER_VPID
:
606 case LTTNG_KERNEL_TRACKER_UID
:
608 case LTTNG_KERNEL_TRACKER_VUID
:
610 case LTTNG_KERNEL_TRACKER_GID
:
612 case LTTNG_KERNEL_TRACKER_VGID
:
615 return TRACKER_UNKNOWN
;
620 * lttng_session_ioctl - lttng session fd ioctl
626 * This ioctl implements lttng commands:
627 * LTTNG_KERNEL_CHANNEL
628 * Returns a LTTng channel file descriptor
629 * LTTNG_KERNEL_ENABLE
630 * Enables tracing for a session (weak enable)
631 * LTTNG_KERNEL_DISABLE
632 * Disables tracing for a session (strong disable)
633 * LTTNG_KERNEL_METADATA
634 * Returns a LTTng metadata file descriptor
635 * LTTNG_KERNEL_SESSION_TRACK_PID
636 * Add PID to session PID tracker
637 * LTTNG_KERNEL_SESSION_UNTRACK_PID
638 * Remove PID from session PID tracker
639 * LTTNG_KERNEL_SESSION_TRACK_ID
641 * LTTNG_KERNEL_SESSION_UNTRACK_ID
642 * Remove ID from tracker
644 * The returned channel will be deleted when its file descriptor is closed.
647 long lttng_session_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
649 struct lttng_session
*session
= file
->private_data
;
650 struct lttng_kernel_channel chan_param
;
651 struct lttng_kernel_old_channel old_chan_param
;
654 case LTTNG_KERNEL_OLD_CHANNEL
:
656 if (copy_from_user(&old_chan_param
,
657 (struct lttng_kernel_old_channel __user
*) arg
,
658 sizeof(struct lttng_kernel_old_channel
)))
660 chan_param
.overwrite
= old_chan_param
.overwrite
;
661 chan_param
.subbuf_size
= old_chan_param
.subbuf_size
;
662 chan_param
.num_subbuf
= old_chan_param
.num_subbuf
;
663 chan_param
.switch_timer_interval
= old_chan_param
.switch_timer_interval
;
664 chan_param
.read_timer_interval
= old_chan_param
.read_timer_interval
;
665 chan_param
.output
= old_chan_param
.output
;
667 return lttng_abi_create_channel(file
, &chan_param
,
670 case LTTNG_KERNEL_CHANNEL
:
672 if (copy_from_user(&chan_param
,
673 (struct lttng_kernel_channel __user
*) arg
,
674 sizeof(struct lttng_kernel_channel
)))
676 return lttng_abi_create_channel(file
, &chan_param
,
679 case LTTNG_KERNEL_OLD_SESSION_START
:
680 case LTTNG_KERNEL_OLD_ENABLE
:
681 case LTTNG_KERNEL_SESSION_START
:
682 case LTTNG_KERNEL_ENABLE
:
683 return lttng_session_enable(session
);
684 case LTTNG_KERNEL_OLD_SESSION_STOP
:
685 case LTTNG_KERNEL_OLD_DISABLE
:
686 case LTTNG_KERNEL_SESSION_STOP
:
687 case LTTNG_KERNEL_DISABLE
:
688 return lttng_session_disable(session
);
689 case LTTNG_KERNEL_OLD_METADATA
:
691 if (copy_from_user(&old_chan_param
,
692 (struct lttng_kernel_old_channel __user
*) arg
,
693 sizeof(struct lttng_kernel_old_channel
)))
695 chan_param
.overwrite
= old_chan_param
.overwrite
;
696 chan_param
.subbuf_size
= old_chan_param
.subbuf_size
;
697 chan_param
.num_subbuf
= old_chan_param
.num_subbuf
;
698 chan_param
.switch_timer_interval
= old_chan_param
.switch_timer_interval
;
699 chan_param
.read_timer_interval
= old_chan_param
.read_timer_interval
;
700 chan_param
.output
= old_chan_param
.output
;
702 return lttng_abi_create_channel(file
, &chan_param
,
705 case LTTNG_KERNEL_METADATA
:
707 if (copy_from_user(&chan_param
,
708 (struct lttng_kernel_channel __user
*) arg
,
709 sizeof(struct lttng_kernel_channel
)))
711 return lttng_abi_create_channel(file
, &chan_param
,
714 case LTTNG_KERNEL_SESSION_TRACK_PID
:
715 return lttng_session_track_id(session
, TRACKER_PID
, (int) arg
);
716 case LTTNG_KERNEL_SESSION_UNTRACK_PID
:
717 return lttng_session_untrack_id(session
, TRACKER_PID
, (int) arg
);
718 case LTTNG_KERNEL_SESSION_TRACK_ID
:
720 struct lttng_kernel_tracker_args tracker
;
721 enum tracker_type tracker_type
;
723 if (copy_from_user(&tracker
,
724 (struct lttng_kernel_tracker_args __user
*) arg
,
725 sizeof(struct lttng_kernel_tracker_args
)))
727 tracker_type
= get_tracker_type(&tracker
);
728 if (tracker_type
== TRACKER_UNKNOWN
)
730 return lttng_session_track_id(session
, tracker_type
, tracker
.id
);
732 case LTTNG_KERNEL_SESSION_UNTRACK_ID
:
734 struct lttng_kernel_tracker_args tracker
;
735 enum tracker_type tracker_type
;
737 if (copy_from_user(&tracker
,
738 (struct lttng_kernel_tracker_args __user
*) arg
,
739 sizeof(struct lttng_kernel_tracker_args
)))
741 tracker_type
= get_tracker_type(&tracker
);
742 if (tracker_type
== TRACKER_UNKNOWN
)
744 return lttng_session_untrack_id(session
, tracker_type
,
747 case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS
:
748 return lttng_session_list_tracker_ids(session
, TRACKER_PID
);
749 case LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS
:
751 struct lttng_kernel_tracker_args tracker
;
752 enum tracker_type tracker_type
;
754 if (copy_from_user(&tracker
,
755 (struct lttng_kernel_tracker_args __user
*) arg
,
756 sizeof(struct lttng_kernel_tracker_args
)))
758 tracker_type
= get_tracker_type(&tracker
);
759 if (tracker_type
== TRACKER_UNKNOWN
)
761 return lttng_session_list_tracker_ids(session
, tracker_type
);
763 case LTTNG_KERNEL_SESSION_METADATA_REGEN
:
764 return lttng_session_metadata_regenerate(session
);
765 case LTTNG_KERNEL_SESSION_STATEDUMP
:
766 return lttng_session_statedump(session
);
767 case LTTNG_KERNEL_SESSION_SET_NAME
:
769 struct lttng_kernel_session_name name
;
771 if (copy_from_user(&name
,
772 (struct lttng_kernel_session_name __user
*) arg
,
773 sizeof(struct lttng_kernel_session_name
)))
775 return lttng_abi_session_set_name(session
, &name
);
777 case LTTNG_KERNEL_SESSION_SET_CREATION_TIME
:
779 struct lttng_kernel_session_creation_time time
;
781 if (copy_from_user(&time
,
782 (struct lttng_kernel_session_creation_time __user
*) arg
,
783 sizeof(struct lttng_kernel_session_creation_time
)))
785 return lttng_abi_session_set_creation_time(session
, &time
);
793 * Called when the last file reference is dropped.
795 * Big fat note: channels and events are invariant for the whole session after
796 * their creation. So this session destruction also destroys all channel and
797 * event structures specific to this session (they are not destroyed when their
798 * individual file is released).
801 int lttng_session_release(struct inode
*inode
, struct file
*file
)
803 struct lttng_session
*session
= file
->private_data
;
806 lttng_session_destroy(session
);
810 static const struct file_operations lttng_session_fops
= {
811 .owner
= THIS_MODULE
,
812 .release
= lttng_session_release
,
813 .unlocked_ioctl
= lttng_session_ioctl
,
815 .compat_ioctl
= lttng_session_ioctl
,
820 * When encountering empty buffer, flush current sub-buffer if non-empty
821 * and retry (if new data available to read after flush).
824 ssize_t
lttng_event_notifier_group_notif_read(struct file
*filp
, char __user
*user_buf
,
825 size_t count
, loff_t
*ppos
)
827 struct lttng_event_notifier_group
*event_notifier_group
= filp
->private_data
;
828 struct channel
*chan
= event_notifier_group
->chan
;
829 struct lib_ring_buffer
*buf
= event_notifier_group
->buf
;
830 ssize_t read_count
= 0, len
;
834 if (!lttng_access_ok(VERIFY_WRITE
, user_buf
, count
))
837 /* Finish copy of previous record */
839 if (read_count
< count
) {
840 len
= chan
->iter
.len_left
;
846 while (read_count
< count
) {
847 size_t copy_len
, space_left
;
849 len
= lib_ring_buffer_get_next_record(chan
, buf
);
853 * Check if buffer is finalized (end of file).
855 if (len
== -ENODATA
) {
856 /* A 0 read_count will tell about end of file */
859 if (filp
->f_flags
& O_NONBLOCK
) {
861 read_count
= -EAGAIN
;
867 * No data available at the moment, return what
874 * Wait for returned len to be >= 0 or -ENODATA.
876 error
= wait_event_interruptible(
877 event_notifier_group
->read_wait
,
878 ((len
= lib_ring_buffer_get_next_record(
879 chan
, buf
)), len
!= -EAGAIN
));
880 CHAN_WARN_ON(chan
, len
== -EBUSY
);
885 CHAN_WARN_ON(chan
, len
< 0 && len
!= -ENODATA
);
889 read_offset
= buf
->iter
.read_offset
;
891 space_left
= count
- read_count
;
892 if (len
<= space_left
) {
894 chan
->iter
.len_left
= 0;
897 copy_len
= space_left
;
898 chan
->iter
.len_left
= len
- copy_len
;
899 *ppos
= read_offset
+ copy_len
;
901 if (__lib_ring_buffer_copy_to_user(&buf
->backend
, read_offset
,
902 &user_buf
[read_count
],
905 * Leave the len_left and ppos values at their current
906 * state, as we currently have a valid event to read.
910 read_count
+= copy_len
;
916 chan
->iter
.len_left
= 0;
921 * If the ring buffer is non empty (even just a partial subbuffer), return that
922 * there is data available. Perform a ring buffer flush if we encounter a
923 * non-empty ring buffer which does not have any consumeable subbuffer available.
926 unsigned int lttng_event_notifier_group_notif_poll(struct file
*filp
,
929 unsigned int mask
= 0;
930 struct lttng_event_notifier_group
*event_notifier_group
= filp
->private_data
;
931 struct channel
*chan
= event_notifier_group
->chan
;
932 struct lib_ring_buffer
*buf
= event_notifier_group
->buf
;
933 const struct lib_ring_buffer_config
*config
= &chan
->backend
.config
;
934 int finalized
, disabled
;
935 unsigned long consumed
, offset
;
937 if (filp
->f_mode
& FMODE_READ
) {
938 poll_wait_set_exclusive(wait
);
939 poll_wait(filp
, &event_notifier_group
->read_wait
, wait
);
941 finalized
= lib_ring_buffer_is_finalized(config
, buf
);
942 disabled
= lib_ring_buffer_channel_is_disabled(chan
);
945 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
946 * finalized load before offsets loads.
948 WARN_ON(atomic_long_read(&buf
->active_readers
) != 1);
953 offset
= lib_ring_buffer_get_offset(config
, buf
);
954 consumed
= lib_ring_buffer_get_consumed(config
, buf
);
957 * If there is no buffer available to consume.
959 if (subbuf_trunc(offset
, chan
) - subbuf_trunc(consumed
, chan
) == 0) {
961 * If there is a non-empty subbuffer, flush and try again.
963 if (subbuf_offset(offset
, chan
) != 0) {
964 lib_ring_buffer_switch_remote(buf
);
972 * The memory barriers
973 * __wait_event()/wake_up_interruptible() take
974 * care of "raw_spin_is_locked" memory ordering.
976 if (raw_spin_is_locked(&buf
->raw_tick_nohz_spinlock
))
982 if (subbuf_trunc(offset
, chan
) - subbuf_trunc(consumed
, chan
)
983 >= chan
->backend
.buf_size
)
984 return POLLPRI
| POLLRDBAND
;
986 return POLLIN
| POLLRDNORM
;
994 * lttng_event_notifier_group_notif_open - event_notifier ring buffer open file operation
995 * @inode: opened inode
998 * Open implementation. Makes sure only one open instance of a buffer is
999 * done at a given moment.
1001 static int lttng_event_notifier_group_notif_open(struct inode
*inode
, struct file
*file
)
1003 struct lttng_event_notifier_group
*event_notifier_group
= inode
->i_private
;
1004 struct lib_ring_buffer
*buf
= event_notifier_group
->buf
;
1006 file
->private_data
= event_notifier_group
;
1007 return lib_ring_buffer_open(inode
, file
, buf
);
1011 * lttng_event_notifier_group_notif_release - event_notifier ring buffer release file operation
1012 * @inode: opened inode
1013 * @file: opened file
1015 * Release implementation.
1017 static int lttng_event_notifier_group_notif_release(struct inode
*inode
, struct file
*file
)
1019 struct lttng_event_notifier_group
*event_notifier_group
= file
->private_data
;
1020 struct lib_ring_buffer
*buf
= event_notifier_group
->buf
;
1023 ret
= lib_ring_buffer_release(inode
, file
, buf
);
1026 fput(event_notifier_group
->file
);
1030 static const struct file_operations lttng_event_notifier_group_notif_fops
= {
1031 .owner
= THIS_MODULE
,
1032 .open
= lttng_event_notifier_group_notif_open
,
1033 .release
= lttng_event_notifier_group_notif_release
,
1034 .read
= lttng_event_notifier_group_notif_read
,
1035 .poll
= lttng_event_notifier_group_notif_poll
,
1039 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
1043 * Handles the poll operations for the metadata channels.
1046 unsigned int lttng_metadata_ring_buffer_poll(struct file
*filp
,
1049 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1050 struct lib_ring_buffer
*buf
= stream
->priv
;
1052 unsigned int mask
= 0;
1054 if (filp
->f_mode
& FMODE_READ
) {
1055 poll_wait_set_exclusive(wait
);
1056 poll_wait(filp
, &stream
->read_wait
, wait
);
1058 finalized
= stream
->finalized
;
1061 * lib_ring_buffer_is_finalized() contains a smp_rmb()
1062 * ordering finalized load before offsets loads.
1064 WARN_ON(atomic_long_read(&buf
->active_readers
) != 1);
1069 mutex_lock(&stream
->metadata_cache
->lock
);
1070 if (stream
->metadata_cache
->metadata_written
>
1071 stream
->metadata_out
)
1073 mutex_unlock(&stream
->metadata_cache
->lock
);
1080 void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file
*filp
,
1081 unsigned int cmd
, unsigned long arg
)
1083 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1085 stream
->metadata_out
= stream
->metadata_in
;
1089 * Reset the counter of how much metadata has been consumed to 0. That way,
1090 * the consumer receives the content of the metadata cache unchanged. This is
1091 * different from the metadata_regenerate where the offset from epoch is
1092 * resampled, here we want the exact same content as the last time the metadata
1093 * was generated. This command is only possible if all the metadata written
1094 * in the cache has been output to the metadata stream to avoid corrupting the
1097 * Return 0 on success, a negative value on error.
1100 int lttng_metadata_cache_dump(struct lttng_metadata_stream
*stream
)
1103 struct lttng_metadata_cache
*cache
= stream
->metadata_cache
;
1105 mutex_lock(&cache
->lock
);
1106 if (stream
->metadata_out
!= cache
->metadata_written
) {
1110 stream
->metadata_out
= 0;
1111 stream
->metadata_in
= 0;
1112 wake_up_interruptible(&stream
->read_wait
);
1116 mutex_unlock(&cache
->lock
);
1121 long lttng_metadata_ring_buffer_ioctl(struct file
*filp
,
1122 unsigned int cmd
, unsigned long arg
)
1125 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1126 struct lib_ring_buffer
*buf
= stream
->priv
;
1127 unsigned int rb_cmd
;
1130 if (cmd
== RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
)
1131 rb_cmd
= RING_BUFFER_GET_NEXT_SUBBUF
;
1136 case RING_BUFFER_GET_NEXT_SUBBUF
:
1138 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1139 struct lib_ring_buffer
*buf
= stream
->priv
;
1140 struct channel
*chan
= buf
->backend
.chan
;
1142 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
1144 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
1150 case RING_BUFFER_GET_SUBBUF
:
1153 * Random access is not allowed for metadata channel.
1157 case RING_BUFFER_FLUSH_EMPTY
: /* Fall-through. */
1158 case RING_BUFFER_FLUSH
:
1160 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1161 struct lib_ring_buffer
*buf
= stream
->priv
;
1162 struct channel
*chan
= buf
->backend
.chan
;
1165 * Before doing the actual ring buffer flush, write up to one
1166 * packet of metadata in the ring buffer.
1168 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
1173 case RING_BUFFER_GET_METADATA_VERSION
:
1175 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1177 return put_u64(stream
->version
, arg
);
1179 case RING_BUFFER_METADATA_CACHE_DUMP
:
1181 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1183 return lttng_metadata_cache_dump(stream
);
1185 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
1187 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1188 struct lib_ring_buffer
*buf
= stream
->priv
;
1189 struct channel
*chan
= buf
->backend
.chan
;
1191 ret
= lttng_metadata_output_channel(stream
, chan
, &coherent
);
1193 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
1195 } else if (ret
< 0) {
1203 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
1205 /* Performing lib ring buffer ioctl after our own. */
1206 ret
= lib_ring_buffer_ioctl(filp
, rb_cmd
, arg
, buf
);
1211 case RING_BUFFER_PUT_NEXT_SUBBUF
:
1213 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp
,
1217 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
1219 return put_u32(coherent
, arg
);
1228 #ifdef CONFIG_COMPAT
1230 long lttng_metadata_ring_buffer_compat_ioctl(struct file
*filp
,
1231 unsigned int cmd
, unsigned long arg
)
1234 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1235 struct lib_ring_buffer
*buf
= stream
->priv
;
1236 unsigned int rb_cmd
;
1239 if (cmd
== RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
)
1240 rb_cmd
= RING_BUFFER_GET_NEXT_SUBBUF
;
1245 case RING_BUFFER_GET_NEXT_SUBBUF
:
1247 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1248 struct lib_ring_buffer
*buf
= stream
->priv
;
1249 struct channel
*chan
= buf
->backend
.chan
;
1251 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
1253 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
1259 case RING_BUFFER_GET_SUBBUF
:
1262 * Random access is not allowed for metadata channel.
1266 case RING_BUFFER_FLUSH_EMPTY
: /* Fall-through. */
1267 case RING_BUFFER_FLUSH
:
1269 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1270 struct lib_ring_buffer
*buf
= stream
->priv
;
1271 struct channel
*chan
= buf
->backend
.chan
;
1274 * Before doing the actual ring buffer flush, write up to one
1275 * packet of metadata in the ring buffer.
1277 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
1282 case RING_BUFFER_GET_METADATA_VERSION
:
1284 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1286 return put_u64(stream
->version
, arg
);
1288 case RING_BUFFER_METADATA_CACHE_DUMP
:
1290 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1292 return lttng_metadata_cache_dump(stream
);
1294 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
1296 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1297 struct lib_ring_buffer
*buf
= stream
->priv
;
1298 struct channel
*chan
= buf
->backend
.chan
;
1300 ret
= lttng_metadata_output_channel(stream
, chan
, &coherent
);
1302 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
1304 } else if (ret
< 0) {
1312 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
1314 /* Performing lib ring buffer ioctl after our own. */
1315 ret
= lib_ring_buffer_compat_ioctl(filp
, rb_cmd
, arg
, buf
);
1320 case RING_BUFFER_PUT_NEXT_SUBBUF
:
1322 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp
,
1326 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
1328 return put_u32(coherent
, arg
);
1339 * This is not used by anonymous file descriptors. This code is left
1340 * there if we ever want to implement an inode with open() operation.
1343 int lttng_metadata_ring_buffer_open(struct inode
*inode
, struct file
*file
)
1345 struct lttng_metadata_stream
*stream
= inode
->i_private
;
1346 struct lib_ring_buffer
*buf
= stream
->priv
;
1348 file
->private_data
= buf
;
1350 * Since life-time of metadata cache differs from that of
1351 * session, we need to keep our own reference on the transport.
1353 if (!try_module_get(stream
->transport
->owner
)) {
1354 printk(KERN_WARNING
"LTTng: Can't lock transport module.\n");
1357 return lib_ring_buffer_open(inode
, file
, buf
);
1361 int lttng_metadata_ring_buffer_release(struct inode
*inode
, struct file
*file
)
1363 struct lttng_metadata_stream
*stream
= file
->private_data
;
1364 struct lib_ring_buffer
*buf
= stream
->priv
;
1366 mutex_lock(&stream
->metadata_cache
->lock
);
1367 list_del(&stream
->list
);
1368 mutex_unlock(&stream
->metadata_cache
->lock
);
1369 kref_put(&stream
->metadata_cache
->refcount
, metadata_cache_destroy
);
1370 module_put(stream
->transport
->owner
);
1372 return lib_ring_buffer_release(inode
, file
, buf
);
1376 ssize_t
lttng_metadata_ring_buffer_splice_read(struct file
*in
, loff_t
*ppos
,
1377 struct pipe_inode_info
*pipe
, size_t len
,
1380 struct lttng_metadata_stream
*stream
= in
->private_data
;
1381 struct lib_ring_buffer
*buf
= stream
->priv
;
1383 return lib_ring_buffer_splice_read(in
, ppos
, pipe
, len
,
1388 int lttng_metadata_ring_buffer_mmap(struct file
*filp
,
1389 struct vm_area_struct
*vma
)
1391 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1392 struct lib_ring_buffer
*buf
= stream
->priv
;
1394 return lib_ring_buffer_mmap(filp
, vma
, buf
);
1398 const struct file_operations lttng_metadata_ring_buffer_file_operations
= {
1399 .owner
= THIS_MODULE
,
1400 .open
= lttng_metadata_ring_buffer_open
,
1401 .release
= lttng_metadata_ring_buffer_release
,
1402 .poll
= lttng_metadata_ring_buffer_poll
,
1403 .splice_read
= lttng_metadata_ring_buffer_splice_read
,
1404 .mmap
= lttng_metadata_ring_buffer_mmap
,
1405 .unlocked_ioctl
= lttng_metadata_ring_buffer_ioctl
,
1406 .llseek
= vfs_lib_ring_buffer_no_llseek
,
1407 #ifdef CONFIG_COMPAT
1408 .compat_ioctl
= lttng_metadata_ring_buffer_compat_ioctl
,
1413 int lttng_abi_create_stream_fd(struct file
*channel_file
, void *stream_priv
,
1414 const struct file_operations
*fops
, const char *name
)
1417 struct file
*stream_file
;
1419 stream_fd
= lttng_get_unused_fd();
1420 if (stream_fd
< 0) {
1424 stream_file
= anon_inode_getfile(name
, fops
, stream_priv
, O_RDWR
);
1425 if (IS_ERR(stream_file
)) {
1426 ret
= PTR_ERR(stream_file
);
1430 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
1431 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
1432 * file descriptor, so we set FMODE_PREAD here.
1434 stream_file
->f_mode
|= FMODE_PREAD
;
1435 fd_install(stream_fd
, stream_file
);
1437 * The stream holds a reference to the channel within the generic ring
1438 * buffer library, so no need to hold a refcount on the channel and
1439 * session files here.
1444 put_unused_fd(stream_fd
);
1450 int lttng_abi_open_stream(struct file
*channel_file
)
1452 struct lttng_channel
*channel
= channel_file
->private_data
;
1453 struct lib_ring_buffer
*buf
;
1457 buf
= channel
->ops
->buffer_read_open(channel
->chan
);
1462 ret
= lttng_abi_create_stream_fd(channel_file
, stream_priv
,
1463 <tng_stream_ring_buffer_file_operations
,
1471 channel
->ops
->buffer_read_close(buf
);
1476 int lttng_abi_open_metadata_stream(struct file
*channel_file
)
1478 struct lttng_channel
*channel
= channel_file
->private_data
;
1479 struct lttng_session
*session
= channel
->session
;
1480 struct lib_ring_buffer
*buf
;
1482 struct lttng_metadata_stream
*metadata_stream
;
1485 buf
= channel
->ops
->buffer_read_open(channel
->chan
);
1489 metadata_stream
= kzalloc(sizeof(struct lttng_metadata_stream
),
1491 if (!metadata_stream
) {
1495 metadata_stream
->metadata_cache
= session
->metadata_cache
;
1496 init_waitqueue_head(&metadata_stream
->read_wait
);
1497 metadata_stream
->priv
= buf
;
1498 stream_priv
= metadata_stream
;
1499 metadata_stream
->transport
= channel
->transport
;
1500 /* Initial state is an empty metadata, considered as incoherent. */
1501 metadata_stream
->coherent
= false;
1504 * Since life-time of metadata cache differs from that of
1505 * session, we need to keep our own reference on the transport.
1507 if (!try_module_get(metadata_stream
->transport
->owner
)) {
1508 printk(KERN_WARNING
"LTTng: Can't lock transport module.\n");
1513 if (!lttng_kref_get(&session
->metadata_cache
->refcount
)) {
1518 ret
= lttng_abi_create_stream_fd(channel_file
, stream_priv
,
1519 <tng_metadata_ring_buffer_file_operations
,
1520 "[lttng_metadata_stream]");
1524 mutex_lock(&session
->metadata_cache
->lock
);
1525 list_add(&metadata_stream
->list
,
1526 &session
->metadata_cache
->metadata_stream
);
1527 mutex_unlock(&session
->metadata_cache
->lock
);
1531 kref_put(&session
->metadata_cache
->refcount
, metadata_cache_destroy
);
1533 module_put(metadata_stream
->transport
->owner
);
1535 kfree(metadata_stream
);
1537 channel
->ops
->buffer_read_close(buf
);
1542 int lttng_abi_open_event_notifier_group_stream(struct file
*notif_file
)
1544 struct lttng_event_notifier_group
*event_notifier_group
= notif_file
->private_data
;
1545 struct channel
*chan
= event_notifier_group
->chan
;
1546 struct lib_ring_buffer
*buf
;
1550 buf
= event_notifier_group
->ops
->buffer_read_open(chan
);
1554 /* The event_notifier notification fd holds a reference on the event_notifier group */
1555 if (!atomic_long_add_unless(¬if_file
->f_count
, 1, LONG_MAX
)) {
1557 goto refcount_error
;
1559 event_notifier_group
->buf
= buf
;
1560 stream_priv
= event_notifier_group
;
1561 ret
= lttng_abi_create_stream_fd(notif_file
, stream_priv
,
1562 <tng_event_notifier_group_notif_fops
,
1563 "[lttng_event_notifier_stream]");
1570 atomic_long_dec(¬if_file
->f_count
);
1572 event_notifier_group
->ops
->buffer_read_close(buf
);
1577 int lttng_abi_validate_event_param(struct lttng_kernel_event
*event_param
)
1579 /* Limit ABI to implemented features. */
1580 switch (event_param
->instrumentation
) {
1581 case LTTNG_KERNEL_SYSCALL
:
1582 switch (event_param
->u
.syscall
.entryexit
) {
1583 case LTTNG_KERNEL_SYSCALL_ENTRYEXIT
:
1588 switch (event_param
->u
.syscall
.abi
) {
1589 case LTTNG_KERNEL_SYSCALL_ABI_ALL
:
1594 switch (event_param
->u
.syscall
.match
) {
1595 case LTTNG_SYSCALL_MATCH_NAME
:
1602 case LTTNG_KERNEL_TRACEPOINT
: /* Fallthrough */
1603 case LTTNG_KERNEL_KPROBE
: /* Fallthrough */
1604 case LTTNG_KERNEL_KRETPROBE
: /* Fallthrough */
1605 case LTTNG_KERNEL_NOOP
: /* Fallthrough */
1606 case LTTNG_KERNEL_UPROBE
:
1609 case LTTNG_KERNEL_FUNCTION
: /* Fallthrough */
1617 int lttng_abi_create_event(struct file
*channel_file
,
1618 struct lttng_kernel_event
*event_param
)
1620 struct lttng_channel
*channel
= channel_file
->private_data
;
1622 struct file
*event_file
;
1625 event_param
->name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
1626 switch (event_param
->instrumentation
) {
1627 case LTTNG_KERNEL_KRETPROBE
:
1628 event_param
->u
.kretprobe
.symbol_name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
1630 case LTTNG_KERNEL_KPROBE
:
1631 event_param
->u
.kprobe
.symbol_name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
1633 case LTTNG_KERNEL_FUNCTION
:
1635 /* Not implemented. */
1640 event_fd
= lttng_get_unused_fd();
1645 event_file
= anon_inode_getfile("[lttng_event]",
1648 if (IS_ERR(event_file
)) {
1649 ret
= PTR_ERR(event_file
);
1652 /* The event holds a reference on the channel */
1653 if (!atomic_long_add_unless(&channel_file
->f_count
, 1, LONG_MAX
)) {
1655 goto refcount_error
;
1657 ret
= lttng_abi_validate_event_param(event_param
);
1660 if (event_param
->instrumentation
== LTTNG_KERNEL_TRACEPOINT
1661 || event_param
->instrumentation
== LTTNG_KERNEL_SYSCALL
) {
1662 struct lttng_event_enabler
*event_enabler
;
1664 if (strutils_is_star_glob_pattern(event_param
->name
)) {
1666 * If the event name is a star globbing pattern,
1667 * we create the special star globbing enabler.
1669 event_enabler
= lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB
,
1670 event_param
, channel
);
1672 event_enabler
= lttng_event_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
1673 event_param
, channel
);
1675 priv
= event_enabler
;
1677 struct lttng_event
*event
;
1680 * We tolerate no failure path after event creation. It
1681 * will stay invariant for the rest of the session.
1683 event
= lttng_event_create(channel
, event_param
,
1685 event_param
->instrumentation
);
1686 WARN_ON_ONCE(!event
);
1687 if (IS_ERR(event
)) {
1688 ret
= PTR_ERR(event
);
1693 event_file
->private_data
= priv
;
1694 fd_install(event_fd
, event_file
);
1698 atomic_long_dec(&channel_file
->f_count
);
1702 put_unused_fd(event_fd
);
1708 long lttng_event_notifier_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1710 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
1711 enum lttng_event_type
*evtype
= file
->private_data
;
1714 case LTTNG_KERNEL_ENABLE
:
1716 case LTTNG_TYPE_EVENT
:
1718 case LTTNG_TYPE_ENABLER
:
1719 event_notifier_enabler
= file
->private_data
;
1720 return lttng_event_notifier_enabler_enable(event_notifier_enabler
);
1725 case LTTNG_KERNEL_DISABLE
:
1727 case LTTNG_TYPE_EVENT
:
1729 case LTTNG_TYPE_ENABLER
:
1730 event_notifier_enabler
= file
->private_data
;
1731 return lttng_event_notifier_enabler_disable(event_notifier_enabler
);
1736 case LTTNG_KERNEL_FILTER
:
1738 case LTTNG_TYPE_EVENT
:
1740 case LTTNG_TYPE_ENABLER
:
1741 event_notifier_enabler
= file
->private_data
;
1742 return lttng_event_notifier_enabler_attach_bytecode(event_notifier_enabler
,
1743 (struct lttng_kernel_filter_bytecode __user
*) arg
);
1749 return -ENOIOCTLCMD
;
1754 int lttng_event_notifier_release(struct inode
*inode
, struct file
*file
)
1756 struct lttng_event_notifier
*event_notifier
;
1757 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
1758 enum lttng_event_type
*evtype
= file
->private_data
;
1764 case LTTNG_TYPE_EVENT
:
1765 event_notifier
= file
->private_data
;
1767 fput(event_notifier
->group
->file
);
1769 case LTTNG_TYPE_ENABLER
:
1770 event_notifier_enabler
= file
->private_data
;
1771 if (event_notifier_enabler
)
1772 fput(event_notifier_enabler
->group
->file
);
1782 static const struct file_operations lttng_event_notifier_fops
= {
1783 .owner
= THIS_MODULE
,
1784 .release
= lttng_event_notifier_release
,
1785 .unlocked_ioctl
= lttng_event_notifier_ioctl
,
1786 #ifdef CONFIG_COMPAT
1787 .compat_ioctl
= lttng_event_notifier_ioctl
,
1792 int lttng_abi_create_event_notifier(struct file
*event_notifier_group_file
,
1793 struct lttng_kernel_event_notifier
*event_notifier_param
)
1795 struct lttng_event_notifier_group
*event_notifier_group
=
1796 event_notifier_group_file
->private_data
;
1797 int event_notifier_fd
, ret
;
1798 struct file
*event_notifier_file
;
1801 switch (event_notifier_param
->event
.instrumentation
) {
1802 case LTTNG_KERNEL_TRACEPOINT
:
1803 case LTTNG_KERNEL_KPROBE
:
1804 case LTTNG_KERNEL_UPROBE
:
1805 case LTTNG_KERNEL_KRETPROBE
:
1806 case LTTNG_KERNEL_FUNCTION
:
1807 case LTTNG_KERNEL_NOOP
:
1808 case LTTNG_KERNEL_SYSCALL
:
1814 event_notifier_param
->event
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
1816 event_notifier_fd
= lttng_get_unused_fd();
1817 if (event_notifier_fd
< 0) {
1818 ret
= event_notifier_fd
;
1822 event_notifier_file
= anon_inode_getfile("[lttng_event_notifier]",
1823 <tng_event_notifier_fops
,
1825 if (IS_ERR(event_notifier_file
)) {
1826 ret
= PTR_ERR(event_notifier_file
);
1830 /* The event notifier holds a reference on the event notifier group. */
1831 if (!atomic_long_add_unless(&event_notifier_group_file
->f_count
, 1, LONG_MAX
)) {
1833 goto refcount_error
;
1836 if (event_notifier_param
->event
.instrumentation
== LTTNG_KERNEL_TRACEPOINT
1837 || event_notifier_param
->event
.instrumentation
== LTTNG_KERNEL_SYSCALL
) {
1838 struct lttng_event_notifier_enabler
*enabler
;
1840 if (strutils_is_star_glob_pattern(event_notifier_param
->event
.name
)) {
1842 * If the event name is a star globbing pattern,
1843 * we create the special star globbing enabler.
1845 enabler
= lttng_event_notifier_enabler_create(
1846 event_notifier_group
,
1847 LTTNG_ENABLER_FORMAT_STAR_GLOB
,
1848 event_notifier_param
);
1850 enabler
= lttng_event_notifier_enabler_create(
1851 event_notifier_group
,
1852 LTTNG_ENABLER_FORMAT_NAME
,
1853 event_notifier_param
);
1857 struct lttng_event_notifier
*event_notifier
;
1860 * We tolerate no failure path after event notifier creation.
1861 * It will stay invariant for the rest of the session.
1863 event_notifier
= lttng_event_notifier_create(NULL
,
1864 event_notifier_param
->event
.token
, event_notifier_group
,
1865 event_notifier_param
, NULL
,
1866 event_notifier_param
->event
.instrumentation
);
1867 WARN_ON_ONCE(!event_notifier
);
1868 if (IS_ERR(event_notifier
)) {
1869 ret
= PTR_ERR(event_notifier
);
1870 goto event_notifier_error
;
1872 priv
= event_notifier
;
1874 event_notifier_file
->private_data
= priv
;
1875 fd_install(event_notifier_fd
, event_notifier_file
);
1876 return event_notifier_fd
;
1878 event_notifier_error
:
1879 atomic_long_dec(&event_notifier_group_file
->f_count
);
1881 fput(event_notifier_file
);
1883 put_unused_fd(event_notifier_fd
);
1890 long lttng_event_notifier_group_ioctl(struct file
*file
, unsigned int cmd
,
1894 case LTTNG_KERNEL_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD
:
1896 return lttng_abi_open_event_notifier_group_stream(file
);
1898 case LTTNG_KERNEL_EVENT_NOTIFIER_CREATE
:
1900 struct lttng_kernel_event_notifier uevent_notifier_param
;
1902 if (copy_from_user(&uevent_notifier_param
,
1903 (struct lttng_kernel_event_notifier __user
*) arg
,
1904 sizeof(uevent_notifier_param
)))
1906 return lttng_abi_create_event_notifier(file
, &uevent_notifier_param
);
1909 return -ENOIOCTLCMD
;
1915 int lttng_event_notifier_group_release(struct inode
*inode
, struct file
*file
)
1917 struct lttng_event_notifier_group
*event_notifier_group
=
1920 if (event_notifier_group
)
1921 lttng_event_notifier_group_destroy(event_notifier_group
);
1925 static const struct file_operations lttng_event_notifier_group_fops
= {
1926 .owner
= THIS_MODULE
,
1927 .release
= lttng_event_notifier_group_release
,
1928 .unlocked_ioctl
= lttng_event_notifier_group_ioctl
,
1929 #ifdef CONFIG_COMPAT
1930 .compat_ioctl
= lttng_event_notifier_group_ioctl
,
1935 * lttng_channel_ioctl - lttng syscall through ioctl
1941 * This ioctl implements lttng commands:
1942 * LTTNG_KERNEL_STREAM
1943 * Returns an event stream file descriptor or failure.
1944 * (typically, one event stream records events from one CPU)
1945 * LTTNG_KERNEL_EVENT
1946 * Returns an event file descriptor or failure.
1947 * LTTNG_KERNEL_CONTEXT
1948 * Prepend a context field to each event in the channel
1949 * LTTNG_KERNEL_ENABLE
1950 * Enable recording for events in this channel (weak enable)
1951 * LTTNG_KERNEL_DISABLE
1952 * Disable recording for events in this channel (strong disable)
1954 * Channel and event file descriptors also hold a reference on the session.
1957 long lttng_channel_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1959 struct lttng_channel
*channel
= file
->private_data
;
1962 case LTTNG_KERNEL_OLD_STREAM
:
1963 case LTTNG_KERNEL_STREAM
:
1964 return lttng_abi_open_stream(file
);
1965 case LTTNG_KERNEL_OLD_EVENT
:
1967 struct lttng_kernel_event
*uevent_param
;
1968 struct lttng_kernel_old_event
*old_uevent_param
;
1971 uevent_param
= kmalloc(sizeof(struct lttng_kernel_event
),
1973 if (!uevent_param
) {
1977 old_uevent_param
= kmalloc(
1978 sizeof(struct lttng_kernel_old_event
),
1980 if (!old_uevent_param
) {
1982 goto old_event_error_free_param
;
1984 if (copy_from_user(old_uevent_param
,
1985 (struct lttng_kernel_old_event __user
*) arg
,
1986 sizeof(struct lttng_kernel_old_event
))) {
1988 goto old_event_error_free_old_param
;
1991 memcpy(uevent_param
->name
, old_uevent_param
->name
,
1992 sizeof(uevent_param
->name
));
1993 uevent_param
->instrumentation
=
1994 old_uevent_param
->instrumentation
;
1996 switch (old_uevent_param
->instrumentation
) {
1997 case LTTNG_KERNEL_KPROBE
:
1998 uevent_param
->u
.kprobe
.addr
=
1999 old_uevent_param
->u
.kprobe
.addr
;
2000 uevent_param
->u
.kprobe
.offset
=
2001 old_uevent_param
->u
.kprobe
.offset
;
2002 memcpy(uevent_param
->u
.kprobe
.symbol_name
,
2003 old_uevent_param
->u
.kprobe
.symbol_name
,
2004 sizeof(uevent_param
->u
.kprobe
.symbol_name
));
2006 case LTTNG_KERNEL_KRETPROBE
:
2007 uevent_param
->u
.kretprobe
.addr
=
2008 old_uevent_param
->u
.kretprobe
.addr
;
2009 uevent_param
->u
.kretprobe
.offset
=
2010 old_uevent_param
->u
.kretprobe
.offset
;
2011 memcpy(uevent_param
->u
.kretprobe
.symbol_name
,
2012 old_uevent_param
->u
.kretprobe
.symbol_name
,
2013 sizeof(uevent_param
->u
.kretprobe
.symbol_name
));
2015 case LTTNG_KERNEL_FUNCTION
:
2017 /* Not implemented. */
2022 ret
= lttng_abi_create_event(file
, uevent_param
);
2024 old_event_error_free_old_param
:
2025 kfree(old_uevent_param
);
2026 old_event_error_free_param
:
2027 kfree(uevent_param
);
2031 case LTTNG_KERNEL_EVENT
:
2033 struct lttng_kernel_event uevent_param
;
2035 if (copy_from_user(&uevent_param
,
2036 (struct lttng_kernel_event __user
*) arg
,
2037 sizeof(uevent_param
)))
2039 return lttng_abi_create_event(file
, &uevent_param
);
2041 case LTTNG_KERNEL_OLD_CONTEXT
:
2043 struct lttng_kernel_context
*ucontext_param
;
2044 struct lttng_kernel_old_context
*old_ucontext_param
;
2047 ucontext_param
= kmalloc(sizeof(struct lttng_kernel_context
),
2049 if (!ucontext_param
) {
2053 old_ucontext_param
= kmalloc(sizeof(struct lttng_kernel_old_context
),
2055 if (!old_ucontext_param
) {
2057 goto old_ctx_error_free_param
;
2060 if (copy_from_user(old_ucontext_param
,
2061 (struct lttng_kernel_old_context __user
*) arg
,
2062 sizeof(struct lttng_kernel_old_context
))) {
2064 goto old_ctx_error_free_old_param
;
2066 ucontext_param
->ctx
= old_ucontext_param
->ctx
;
2067 memcpy(ucontext_param
->padding
, old_ucontext_param
->padding
,
2068 sizeof(ucontext_param
->padding
));
2069 /* only type that uses the union */
2070 if (old_ucontext_param
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_COUNTER
) {
2071 ucontext_param
->u
.perf_counter
.type
=
2072 old_ucontext_param
->u
.perf_counter
.type
;
2073 ucontext_param
->u
.perf_counter
.config
=
2074 old_ucontext_param
->u
.perf_counter
.config
;
2075 memcpy(ucontext_param
->u
.perf_counter
.name
,
2076 old_ucontext_param
->u
.perf_counter
.name
,
2077 sizeof(ucontext_param
->u
.perf_counter
.name
));
2080 ret
= lttng_abi_add_context(file
,
2082 &channel
->ctx
, channel
->session
);
2084 old_ctx_error_free_old_param
:
2085 kfree(old_ucontext_param
);
2086 old_ctx_error_free_param
:
2087 kfree(ucontext_param
);
2091 case LTTNG_KERNEL_CONTEXT
:
2093 struct lttng_kernel_context ucontext_param
;
2095 if (copy_from_user(&ucontext_param
,
2096 (struct lttng_kernel_context __user
*) arg
,
2097 sizeof(ucontext_param
)))
2099 return lttng_abi_add_context(file
,
2101 &channel
->ctx
, channel
->session
);
2103 case LTTNG_KERNEL_OLD_ENABLE
:
2104 case LTTNG_KERNEL_ENABLE
:
2105 return lttng_channel_enable(channel
);
2106 case LTTNG_KERNEL_OLD_DISABLE
:
2107 case LTTNG_KERNEL_DISABLE
:
2108 return lttng_channel_disable(channel
);
2109 case LTTNG_KERNEL_SYSCALL_MASK
:
2110 return lttng_channel_syscall_mask(channel
,
2111 (struct lttng_kernel_syscall_mask __user
*) arg
);
2113 return -ENOIOCTLCMD
;
2118 * lttng_metadata_ioctl - lttng syscall through ioctl
2124 * This ioctl implements lttng commands:
2125 * LTTNG_KERNEL_STREAM
2126 * Returns an event stream file descriptor or failure.
2128 * Channel and event file descriptors also hold a reference on the session.
2131 long lttng_metadata_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2134 case LTTNG_KERNEL_OLD_STREAM
:
2135 case LTTNG_KERNEL_STREAM
:
2136 return lttng_abi_open_metadata_stream(file
);
2138 return -ENOIOCTLCMD
;
2143 * lttng_channel_poll - lttng stream addition/removal monitoring
2148 unsigned int lttng_channel_poll(struct file
*file
, poll_table
*wait
)
2150 struct lttng_channel
*channel
= file
->private_data
;
2151 unsigned int mask
= 0;
2153 if (file
->f_mode
& FMODE_READ
) {
2154 poll_wait_set_exclusive(wait
);
2155 poll_wait(file
, channel
->ops
->get_hp_wait_queue(channel
->chan
),
2158 if (channel
->ops
->is_disabled(channel
->chan
))
2160 if (channel
->ops
->is_finalized(channel
->chan
))
2162 if (channel
->ops
->buffer_has_read_closed_stream(channel
->chan
))
2163 return POLLIN
| POLLRDNORM
;
2171 int lttng_channel_release(struct inode
*inode
, struct file
*file
)
2173 struct lttng_channel
*channel
= file
->private_data
;
2176 fput(channel
->session
->file
);
2181 int lttng_metadata_channel_release(struct inode
*inode
, struct file
*file
)
2183 struct lttng_channel
*channel
= file
->private_data
;
2186 fput(channel
->session
->file
);
2187 lttng_metadata_channel_destroy(channel
);
2193 static const struct file_operations lttng_channel_fops
= {
2194 .owner
= THIS_MODULE
,
2195 .release
= lttng_channel_release
,
2196 .poll
= lttng_channel_poll
,
2197 .unlocked_ioctl
= lttng_channel_ioctl
,
2198 #ifdef CONFIG_COMPAT
2199 .compat_ioctl
= lttng_channel_ioctl
,
2203 static const struct file_operations lttng_metadata_fops
= {
2204 .owner
= THIS_MODULE
,
2205 .release
= lttng_metadata_channel_release
,
2206 .unlocked_ioctl
= lttng_metadata_ioctl
,
2207 #ifdef CONFIG_COMPAT
2208 .compat_ioctl
= lttng_metadata_ioctl
,
2213 * lttng_event_ioctl - lttng syscall through ioctl
2219 * This ioctl implements lttng commands:
2220 * LTTNG_KERNEL_CONTEXT
2221 * Prepend a context field to each record of this event
2222 * LTTNG_KERNEL_ENABLE
2223 * Enable recording for this event (weak enable)
2224 * LTTNG_KERNEL_DISABLE
2225 * Disable recording for this event (strong disable)
2228 long lttng_event_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2230 struct lttng_event
*event
;
2231 struct lttng_event_enabler
*event_enabler
;
2232 enum lttng_event_type
*evtype
= file
->private_data
;
2235 case LTTNG_KERNEL_OLD_CONTEXT
:
2237 /* Not implemented */
2240 case LTTNG_KERNEL_CONTEXT
:
2242 /* Not implemented */
2245 case LTTNG_KERNEL_OLD_ENABLE
:
2246 case LTTNG_KERNEL_ENABLE
:
2248 case LTTNG_TYPE_EVENT
:
2249 event
= file
->private_data
;
2250 return lttng_event_enable(event
);
2251 case LTTNG_TYPE_ENABLER
:
2252 event_enabler
= file
->private_data
;
2253 return lttng_event_enabler_enable(event_enabler
);
2258 case LTTNG_KERNEL_OLD_DISABLE
:
2259 case LTTNG_KERNEL_DISABLE
:
2261 case LTTNG_TYPE_EVENT
:
2262 event
= file
->private_data
;
2263 return lttng_event_disable(event
);
2264 case LTTNG_TYPE_ENABLER
:
2265 event_enabler
= file
->private_data
;
2266 return lttng_event_enabler_disable(event_enabler
);
2271 case LTTNG_KERNEL_FILTER
:
2273 case LTTNG_TYPE_EVENT
:
2275 case LTTNG_TYPE_ENABLER
:
2277 event_enabler
= file
->private_data
;
2278 return lttng_event_enabler_attach_bytecode(event_enabler
,
2279 (struct lttng_kernel_filter_bytecode __user
*) arg
);
2285 case LTTNG_KERNEL_ADD_CALLSITE
:
2287 case LTTNG_TYPE_EVENT
:
2288 event
= file
->private_data
;
2289 return lttng_event_add_callsite(event
,
2290 (struct lttng_kernel_event_callsite __user
*) arg
);
2291 case LTTNG_TYPE_ENABLER
:
2298 return -ENOIOCTLCMD
;
2303 int lttng_event_release(struct inode
*inode
, struct file
*file
)
2305 struct lttng_event
*event
;
2306 struct lttng_event_enabler
*event_enabler
;
2307 enum lttng_event_type
*evtype
= file
->private_data
;
2313 case LTTNG_TYPE_EVENT
:
2314 event
= file
->private_data
;
2316 fput(event
->chan
->file
);
2318 case LTTNG_TYPE_ENABLER
:
2319 event_enabler
= file
->private_data
;
2321 fput(event_enabler
->chan
->file
);
2331 /* TODO: filter control ioctl */
2332 static const struct file_operations lttng_event_fops
= {
2333 .owner
= THIS_MODULE
,
2334 .release
= lttng_event_release
,
2335 .unlocked_ioctl
= lttng_event_ioctl
,
2336 #ifdef CONFIG_COMPAT
2337 .compat_ioctl
= lttng_event_ioctl
,
2341 static int put_u64(uint64_t val
, unsigned long arg
)
2343 return put_user(val
, (uint64_t __user
*) arg
);
2346 static int put_u32(uint32_t val
, unsigned long arg
)
2348 return put_user(val
, (uint32_t __user
*) arg
);
2351 static long lttng_stream_ring_buffer_ioctl(struct file
*filp
,
2352 unsigned int cmd
, unsigned long arg
)
2354 struct lib_ring_buffer
*buf
= filp
->private_data
;
2355 struct channel
*chan
= buf
->backend
.chan
;
2356 const struct lib_ring_buffer_config
*config
= &chan
->backend
.config
;
2357 const struct lttng_channel_ops
*ops
= chan
->backend
.priv_ops
;
2360 if (atomic_read(&chan
->record_disabled
))
2364 case LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN
:
2368 ret
= ops
->timestamp_begin(config
, buf
, &ts
);
2371 return put_u64(ts
, arg
);
2373 case LTTNG_RING_BUFFER_GET_TIMESTAMP_END
:
2377 ret
= ops
->timestamp_end(config
, buf
, &ts
);
2380 return put_u64(ts
, arg
);
2382 case LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED
:
2386 ret
= ops
->events_discarded(config
, buf
, &ed
);
2389 return put_u64(ed
, arg
);
2391 case LTTNG_RING_BUFFER_GET_CONTENT_SIZE
:
2395 ret
= ops
->content_size(config
, buf
, &cs
);
2398 return put_u64(cs
, arg
);
2400 case LTTNG_RING_BUFFER_GET_PACKET_SIZE
:
2404 ret
= ops
->packet_size(config
, buf
, &ps
);
2407 return put_u64(ps
, arg
);
2409 case LTTNG_RING_BUFFER_GET_STREAM_ID
:
2413 ret
= ops
->stream_id(config
, buf
, &si
);
2416 return put_u64(si
, arg
);
2418 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP
:
2422 ret
= ops
->current_timestamp(config
, buf
, &ts
);
2425 return put_u64(ts
, arg
);
2427 case LTTNG_RING_BUFFER_GET_SEQ_NUM
:
2431 ret
= ops
->sequence_number(config
, buf
, &seq
);
2434 return put_u64(seq
, arg
);
2436 case LTTNG_RING_BUFFER_INSTANCE_ID
:
2440 ret
= ops
->instance_id(config
, buf
, &id
);
2443 return put_u64(id
, arg
);
2446 return lib_ring_buffer_file_operations
.unlocked_ioctl(filp
,
2454 #ifdef CONFIG_COMPAT
2455 static long lttng_stream_ring_buffer_compat_ioctl(struct file
*filp
,
2456 unsigned int cmd
, unsigned long arg
)
2458 struct lib_ring_buffer
*buf
= filp
->private_data
;
2459 struct channel
*chan
= buf
->backend
.chan
;
2460 const struct lib_ring_buffer_config
*config
= &chan
->backend
.config
;
2461 const struct lttng_channel_ops
*ops
= chan
->backend
.priv_ops
;
2464 if (atomic_read(&chan
->record_disabled
))
2468 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN
:
2472 ret
= ops
->timestamp_begin(config
, buf
, &ts
);
2475 return put_u64(ts
, arg
);
2477 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END
:
2481 ret
= ops
->timestamp_end(config
, buf
, &ts
);
2484 return put_u64(ts
, arg
);
2486 case LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED
:
2490 ret
= ops
->events_discarded(config
, buf
, &ed
);
2493 return put_u64(ed
, arg
);
2495 case LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE
:
2499 ret
= ops
->content_size(config
, buf
, &cs
);
2502 return put_u64(cs
, arg
);
2504 case LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE
:
2508 ret
= ops
->packet_size(config
, buf
, &ps
);
2511 return put_u64(ps
, arg
);
2513 case LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID
:
2517 ret
= ops
->stream_id(config
, buf
, &si
);
2520 return put_u64(si
, arg
);
2522 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP
:
2526 ret
= ops
->current_timestamp(config
, buf
, &ts
);
2529 return put_u64(ts
, arg
);
2531 case LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM
:
2535 ret
= ops
->sequence_number(config
, buf
, &seq
);
2538 return put_u64(seq
, arg
);
2540 case LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID
:
2544 ret
= ops
->instance_id(config
, buf
, &id
);
2547 return put_u64(id
, arg
);
2550 return lib_ring_buffer_file_operations
.compat_ioctl(filp
,
2557 #endif /* CONFIG_COMPAT */
2559 static void lttng_stream_override_ring_buffer_fops(void)
2561 lttng_stream_ring_buffer_file_operations
.owner
= THIS_MODULE
;
2562 lttng_stream_ring_buffer_file_operations
.open
=
2563 lib_ring_buffer_file_operations
.open
;
2564 lttng_stream_ring_buffer_file_operations
.release
=
2565 lib_ring_buffer_file_operations
.release
;
2566 lttng_stream_ring_buffer_file_operations
.poll
=
2567 lib_ring_buffer_file_operations
.poll
;
2568 lttng_stream_ring_buffer_file_operations
.splice_read
=
2569 lib_ring_buffer_file_operations
.splice_read
;
2570 lttng_stream_ring_buffer_file_operations
.mmap
=
2571 lib_ring_buffer_file_operations
.mmap
;
2572 lttng_stream_ring_buffer_file_operations
.unlocked_ioctl
=
2573 lttng_stream_ring_buffer_ioctl
;
2574 lttng_stream_ring_buffer_file_operations
.llseek
=
2575 lib_ring_buffer_file_operations
.llseek
;
2576 #ifdef CONFIG_COMPAT
2577 lttng_stream_ring_buffer_file_operations
.compat_ioctl
=
2578 lttng_stream_ring_buffer_compat_ioctl
;
2582 int __init
lttng_abi_init(void)
2586 wrapper_vmalloc_sync_mappings();
2589 ret
= lttng_tp_mempool_init();
2594 lttng_proc_dentry
= proc_create_data("lttng", S_IRUSR
| S_IWUSR
, NULL
,
2595 <tng_proc_ops
, NULL
);
2597 if (!lttng_proc_dentry
) {
2598 printk(KERN_ERR
"LTTng: Error creating control file\n");
2602 lttng_stream_override_ring_buffer_fops();
2606 lttng_tp_mempool_destroy();
2607 lttng_clock_unref();
2611 /* No __exit annotation because used by init error path too. */
2612 void lttng_abi_exit(void)
2614 lttng_tp_mempool_destroy();
2615 lttng_clock_unref();
2616 if (lttng_proc_dentry
)
2617 remove_proc_entry("lttng", NULL
);