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 <asm/barrier.h>
27 #include <linux/module.h>
28 #include <linux/proc_fs.h>
29 #include <linux/anon_inodes.h>
30 #include <linux/file.h>
31 #include <linux/uaccess.h>
32 #include <linux/slab.h>
33 #include <linux/err.h>
34 #include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
35 #include <ringbuffer/vfs.h>
36 #include <ringbuffer/backend.h>
37 #include <ringbuffer/frontend.h>
38 #include <wrapper/compiler_attributes.h>
39 #include <wrapper/poll.h>
40 #include <wrapper/kref.h>
41 #include <wrapper/uaccess.h>
42 #include <lttng/string-utils.h>
43 #include <lttng/abi.h>
44 #include <lttng/abi-old.h>
45 #include <lttng/events.h>
46 #include <lttng/events-internal.h>
47 #include <lttng/tracer.h>
48 #include <lttng/tp-mempool.h>
49 #include <ringbuffer/frontend_types.h>
50 #include <ringbuffer/iterator.h>
53 * This is LTTng's own personal way to create a system call as an external
54 * module. We use ioctl() on /proc/lttng.
57 static struct proc_dir_entry
*lttng_proc_dentry
;
59 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
60 static const struct proc_ops lttng_proc_ops
;
62 static const struct file_operations lttng_proc_ops
;
65 static const struct file_operations lttng_session_fops
;
66 static const struct file_operations lttng_event_notifier_group_fops
;
67 static const struct file_operations lttng_channel_fops
;
68 static const struct file_operations lttng_metadata_fops
;
69 static const struct file_operations lttng_event_session_fops
;
70 static const struct file_operations lttng_event_session_enabler_fops
;
71 static struct file_operations lttng_stream_ring_buffer_file_operations
;
73 static int put_u64(uint64_t val
, unsigned long arg
);
74 static int put_u32(uint32_t val
, unsigned long arg
);
77 int lttng_abi_create_event_counter_enabler(struct file
*channel_file
,
78 struct lttng_kernel_counter_event
*counter_event
);
80 long lttng_abi_session_create_counter(
81 struct lttng_kernel_session
*session
,
82 const struct lttng_kernel_counter_conf
*counter_conf
);
84 static int validate_zeroed_padding(char *p
, size_t len
)
88 for (i
= 0; i
< len
; i
++) {
96 * Teardown management: opened file descriptors keep a refcount on the module,
97 * so it can only exit when all file descriptors are closed.
101 int lttng_abi_create_session(void)
103 struct lttng_kernel_session
*session
;
104 struct file
*session_file
;
107 session
= lttng_session_create();
110 session_fd
= get_unused_fd_flags(0);
111 if (session_fd
< 0) {
115 session_file
= anon_inode_getfile("[lttng_session]",
118 if (IS_ERR(session_file
)) {
119 ret
= PTR_ERR(session_file
);
122 session
->priv
->file
= session_file
;
123 fd_install(session_fd
, session_file
);
127 put_unused_fd(session_fd
);
129 lttng_session_destroy(session
);
134 void event_notifier_send_notification_work_wakeup(struct irq_work
*entry
)
136 struct lttng_event_notifier_group
*event_notifier_group
=
137 container_of(entry
, struct lttng_event_notifier_group
,
139 wake_up_interruptible(&event_notifier_group
->read_wait
);
143 int lttng_abi_create_event_notifier_group(void)
145 struct lttng_event_notifier_group
*event_notifier_group
;
146 struct file
*event_notifier_group_file
;
147 int event_notifier_group_fd
, ret
;
149 event_notifier_group
= lttng_event_notifier_group_create();
150 if (!event_notifier_group
)
153 event_notifier_group_fd
= get_unused_fd_flags(0);
154 if (event_notifier_group_fd
< 0) {
155 ret
= event_notifier_group_fd
;
158 event_notifier_group_file
= anon_inode_getfile("[lttng_event_notifier_group]",
159 <tng_event_notifier_group_fops
,
160 event_notifier_group
, O_RDWR
);
161 if (IS_ERR(event_notifier_group_file
)) {
162 ret
= PTR_ERR(event_notifier_group_file
);
166 event_notifier_group
->file
= event_notifier_group_file
;
167 init_waitqueue_head(&event_notifier_group
->read_wait
);
168 init_irq_work(&event_notifier_group
->wakeup_pending
,
169 event_notifier_send_notification_work_wakeup
);
170 fd_install(event_notifier_group_fd
, event_notifier_group_file
);
171 return event_notifier_group_fd
;
174 put_unused_fd(event_notifier_group_fd
);
176 lttng_event_notifier_group_destroy(event_notifier_group
);
181 int lttng_abi_tracepoint_list(void)
183 struct file
*tracepoint_list_file
;
186 file_fd
= get_unused_fd_flags(0);
192 tracepoint_list_file
= anon_inode_getfile("[lttng_tracepoint_list]",
193 <tng_tracepoint_list_fops
,
195 if (IS_ERR(tracepoint_list_file
)) {
196 ret
= PTR_ERR(tracepoint_list_file
);
199 ret
= lttng_tracepoint_list_fops
.open(NULL
, tracepoint_list_file
);
202 fd_install(file_fd
, tracepoint_list_file
);
206 fput(tracepoint_list_file
);
208 put_unused_fd(file_fd
);
213 #ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
215 int lttng_abi_syscall_list(void)
221 int lttng_abi_syscall_list(void)
223 struct file
*syscall_list_file
;
226 file_fd
= get_unused_fd_flags(0);
232 syscall_list_file
= anon_inode_getfile("[lttng_syscall_list]",
233 <tng_syscall_list_fops
,
235 if (IS_ERR(syscall_list_file
)) {
236 ret
= PTR_ERR(syscall_list_file
);
239 ret
= lttng_syscall_list_fops
.open(NULL
, syscall_list_file
);
242 fd_install(file_fd
, syscall_list_file
);
246 fput(syscall_list_file
);
248 put_unused_fd(file_fd
);
255 void lttng_abi_tracer_version(struct lttng_kernel_abi_tracer_version
*v
)
257 v
->major
= LTTNG_MODULES_MAJOR_VERSION
;
258 v
->minor
= LTTNG_MODULES_MINOR_VERSION
;
259 v
->patchlevel
= LTTNG_MODULES_PATCHLEVEL_VERSION
;
263 void lttng_abi_tracer_abi_version(struct lttng_kernel_abi_tracer_abi_version
*v
)
265 v
->major
= LTTNG_KERNEL_ABI_MAJOR_VERSION
;
266 v
->minor
= LTTNG_KERNEL_ABI_MINOR_VERSION
;
270 long lttng_abi_add_context(struct file
*file
,
271 struct lttng_kernel_abi_context
*context_param
,
272 struct lttng_kernel_ctx
**ctx
, struct lttng_kernel_session
*session
)
275 if (session
->priv
->been_active
)
278 switch (context_param
->ctx
) {
279 case LTTNG_KERNEL_ABI_CONTEXT_PID
:
280 return lttng_add_pid_to_ctx(ctx
);
281 case LTTNG_KERNEL_ABI_CONTEXT_PRIO
:
282 return lttng_add_prio_to_ctx(ctx
);
283 case LTTNG_KERNEL_ABI_CONTEXT_NICE
:
284 return lttng_add_nice_to_ctx(ctx
);
285 case LTTNG_KERNEL_ABI_CONTEXT_VPID
:
286 return lttng_add_vpid_to_ctx(ctx
);
287 case LTTNG_KERNEL_ABI_CONTEXT_TID
:
288 return lttng_add_tid_to_ctx(ctx
);
289 case LTTNG_KERNEL_ABI_CONTEXT_VTID
:
290 return lttng_add_vtid_to_ctx(ctx
);
291 case LTTNG_KERNEL_ABI_CONTEXT_PPID
:
292 return lttng_add_ppid_to_ctx(ctx
);
293 case LTTNG_KERNEL_ABI_CONTEXT_VPPID
:
294 return lttng_add_vppid_to_ctx(ctx
);
295 case LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER
:
296 context_param
->u
.perf_counter
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
297 return lttng_add_perf_counter_to_ctx(context_param
->u
.perf_counter
.type
,
298 context_param
->u
.perf_counter
.config
,
299 context_param
->u
.perf_counter
.name
,
301 case LTTNG_KERNEL_ABI_CONTEXT_PROCNAME
:
302 return lttng_add_procname_to_ctx(ctx
);
303 case LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME
:
304 return lttng_add_hostname_to_ctx(ctx
);
305 case LTTNG_KERNEL_ABI_CONTEXT_CPU_ID
:
306 return lttng_add_cpu_id_to_ctx(ctx
);
307 case LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE
:
308 return lttng_add_interruptible_to_ctx(ctx
);
309 case LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE
:
310 return lttng_add_need_reschedule_to_ctx(ctx
);
311 case LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE
:
312 return lttng_add_preemptible_to_ctx(ctx
);
313 case LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE
:
314 return lttng_add_migratable_to_ctx(ctx
);
315 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL
:
316 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER
:
317 return lttng_add_callstack_to_ctx(ctx
, context_param
->ctx
);
318 case LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS
:
319 return lttng_add_cgroup_ns_to_ctx(ctx
);
320 case LTTNG_KERNEL_ABI_CONTEXT_IPC_NS
:
321 return lttng_add_ipc_ns_to_ctx(ctx
);
322 case LTTNG_KERNEL_ABI_CONTEXT_MNT_NS
:
323 return lttng_add_mnt_ns_to_ctx(ctx
);
324 case LTTNG_KERNEL_ABI_CONTEXT_NET_NS
:
325 return lttng_add_net_ns_to_ctx(ctx
);
326 case LTTNG_KERNEL_ABI_CONTEXT_PID_NS
:
327 return lttng_add_pid_ns_to_ctx(ctx
);
328 case LTTNG_KERNEL_ABI_CONTEXT_USER_NS
:
329 return lttng_add_user_ns_to_ctx(ctx
);
330 case LTTNG_KERNEL_ABI_CONTEXT_UTS_NS
:
331 return lttng_add_uts_ns_to_ctx(ctx
);
332 case LTTNG_KERNEL_ABI_CONTEXT_UID
:
333 return lttng_add_uid_to_ctx(ctx
);
334 case LTTNG_KERNEL_ABI_CONTEXT_EUID
:
335 return lttng_add_euid_to_ctx(ctx
);
336 case LTTNG_KERNEL_ABI_CONTEXT_SUID
:
337 return lttng_add_suid_to_ctx(ctx
);
338 case LTTNG_KERNEL_ABI_CONTEXT_GID
:
339 return lttng_add_gid_to_ctx(ctx
);
340 case LTTNG_KERNEL_ABI_CONTEXT_EGID
:
341 return lttng_add_egid_to_ctx(ctx
);
342 case LTTNG_KERNEL_ABI_CONTEXT_SGID
:
343 return lttng_add_sgid_to_ctx(ctx
);
344 case LTTNG_KERNEL_ABI_CONTEXT_VUID
:
345 return lttng_add_vuid_to_ctx(ctx
);
346 case LTTNG_KERNEL_ABI_CONTEXT_VEUID
:
347 return lttng_add_veuid_to_ctx(ctx
);
348 case LTTNG_KERNEL_ABI_CONTEXT_VSUID
:
349 return lttng_add_vsuid_to_ctx(ctx
);
350 case LTTNG_KERNEL_ABI_CONTEXT_VGID
:
351 return lttng_add_vgid_to_ctx(ctx
);
352 case LTTNG_KERNEL_ABI_CONTEXT_VEGID
:
353 return lttng_add_vegid_to_ctx(ctx
);
354 case LTTNG_KERNEL_ABI_CONTEXT_VSGID
:
355 return lttng_add_vsgid_to_ctx(ctx
);
356 case LTTNG_KERNEL_ABI_CONTEXT_TIME_NS
:
357 return lttng_add_time_ns_to_ctx(ctx
);
364 * lttng_ioctl - lttng syscall through ioctl
370 * This ioctl implements lttng commands:
371 * LTTNG_KERNEL_ABI_SESSION
372 * Returns a LTTng trace session file descriptor
373 * LTTNG_KERNEL_ABI_TRACER_VERSION
374 * Returns the LTTng kernel tracer version
375 * LTTNG_KERNEL_ABI_TRACEPOINT_LIST
376 * Returns a file descriptor listing available tracepoints
377 * LTTNG_KERNEL_ABI_WAIT_QUIESCENT
378 * Returns after all previously running probes have completed
379 * LTTNG_KERNEL_ABI_TRACER_ABI_VERSION
380 * Returns the LTTng kernel tracer ABI version
381 * LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE
382 * Returns a LTTng event notifier group file descriptor
384 * The returned session will be deleted when its file descriptor is closed.
387 long lttng_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
390 case LTTNG_KERNEL_ABI_OLD_SESSION
:
391 case LTTNG_KERNEL_ABI_SESSION
:
392 return lttng_abi_create_session();
393 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE
:
394 return lttng_abi_create_event_notifier_group();
395 case LTTNG_KERNEL_ABI_OLD_TRACER_VERSION
:
397 struct lttng_kernel_abi_tracer_version v
;
398 struct lttng_kernel_abi_old_tracer_version oldv
;
399 struct lttng_kernel_abi_old_tracer_version
*uversion
=
400 (struct lttng_kernel_abi_old_tracer_version __user
*) arg
;
402 lttng_abi_tracer_version(&v
);
403 oldv
.major
= v
.major
;
404 oldv
.minor
= v
.minor
;
405 oldv
.patchlevel
= v
.patchlevel
;
407 if (copy_to_user(uversion
, &oldv
, sizeof(oldv
)))
411 case LTTNG_KERNEL_ABI_TRACER_VERSION
:
413 struct lttng_kernel_abi_tracer_version version
;
414 struct lttng_kernel_abi_tracer_version
*uversion
=
415 (struct lttng_kernel_abi_tracer_version __user
*) arg
;
417 lttng_abi_tracer_version(&version
);
419 if (copy_to_user(uversion
, &version
, sizeof(version
)))
423 case LTTNG_KERNEL_ABI_TRACER_ABI_VERSION
:
425 struct lttng_kernel_abi_tracer_abi_version version
;
426 struct lttng_kernel_abi_tracer_abi_version
*uversion
=
427 (struct lttng_kernel_abi_tracer_abi_version __user
*) arg
;
429 lttng_abi_tracer_abi_version(&version
);
431 if (copy_to_user(uversion
, &version
, sizeof(version
)))
435 case LTTNG_KERNEL_ABI_OLD_TRACEPOINT_LIST
:
436 case LTTNG_KERNEL_ABI_TRACEPOINT_LIST
:
437 return lttng_abi_tracepoint_list();
438 case LTTNG_KERNEL_ABI_SYSCALL_LIST
:
439 return lttng_abi_syscall_list();
440 case LTTNG_KERNEL_ABI_OLD_WAIT_QUIESCENT
:
441 case LTTNG_KERNEL_ABI_WAIT_QUIESCENT
:
444 case LTTNG_KERNEL_ABI_OLD_CALIBRATE
:
446 struct lttng_kernel_abi_old_calibrate __user
*ucalibrate
=
447 (struct lttng_kernel_abi_old_calibrate __user
*) arg
;
448 struct lttng_kernel_abi_old_calibrate old_calibrate
;
449 struct lttng_kernel_abi_calibrate calibrate
;
452 if (copy_from_user(&old_calibrate
, ucalibrate
, sizeof(old_calibrate
)))
454 calibrate
.type
= old_calibrate
.type
;
455 ret
= lttng_calibrate(&calibrate
);
456 if (copy_to_user(ucalibrate
, &old_calibrate
, sizeof(old_calibrate
)))
460 case LTTNG_KERNEL_ABI_CALIBRATE
:
462 struct lttng_kernel_abi_calibrate __user
*ucalibrate
=
463 (struct lttng_kernel_abi_calibrate __user
*) arg
;
464 struct lttng_kernel_abi_calibrate calibrate
;
467 if (copy_from_user(&calibrate
, ucalibrate
, sizeof(calibrate
)))
469 ret
= lttng_calibrate(&calibrate
);
470 if (copy_to_user(ucalibrate
, &calibrate
, sizeof(calibrate
)))
479 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
480 static const struct proc_ops lttng_proc_ops
= {
481 .proc_ioctl
= lttng_ioctl
,
483 .proc_compat_ioctl
= lttng_ioctl
,
484 #endif /* CONFIG_COMPAT */
487 static const struct file_operations lttng_proc_ops
= {
488 .owner
= THIS_MODULE
,
489 .unlocked_ioctl
= lttng_ioctl
,
491 .compat_ioctl
= lttng_ioctl
,
492 #endif /* CONFIG_COMPAT */
497 int lttng_abi_create_channel(struct file
*session_file
,
498 struct lttng_kernel_abi_channel
*chan_param
,
499 enum channel_type channel_type
)
501 struct lttng_kernel_session
*session
= session_file
->private_data
;
502 const struct file_operations
*fops
= NULL
;
503 const char *transport_name
;
504 struct lttng_kernel_channel_buffer
*chan
;
505 struct file
*chan_file
;
509 chan_fd
= get_unused_fd_flags(0);
514 switch (channel_type
) {
515 case PER_CPU_CHANNEL
:
516 fops
= <tng_channel_fops
;
518 case METADATA_CHANNEL
:
519 fops
= <tng_metadata_fops
;
523 chan_file
= anon_inode_getfile("[lttng_channel]",
526 if (IS_ERR(chan_file
)) {
527 ret
= PTR_ERR(chan_file
);
530 switch (channel_type
) {
531 case PER_CPU_CHANNEL
:
532 if (chan_param
->output
== LTTNG_KERNEL_ABI_SPLICE
) {
533 transport_name
= chan_param
->overwrite
?
534 "relay-overwrite" : "relay-discard";
535 } else if (chan_param
->output
== LTTNG_KERNEL_ABI_MMAP
) {
536 transport_name
= chan_param
->overwrite
?
537 "relay-overwrite-mmap" : "relay-discard-mmap";
542 case METADATA_CHANNEL
:
543 if (chan_param
->output
== LTTNG_KERNEL_ABI_SPLICE
)
544 transport_name
= "relay-metadata";
545 else if (chan_param
->output
== LTTNG_KERNEL_ABI_MMAP
)
546 transport_name
= "relay-metadata-mmap";
551 transport_name
= "<unknown>";
554 if (!atomic_long_add_unless(&session_file
->f_count
, 1, LONG_MAX
)) {
559 * We tolerate no failure path after channel creation. It will stay
560 * invariant for the rest of the session.
562 chan
= lttng_channel_buffer_create(session
, transport_name
, NULL
,
563 chan_param
->subbuf_size
,
564 chan_param
->num_subbuf
,
565 chan_param
->switch_timer_interval
,
566 chan_param
->read_timer_interval
,
572 chan
->priv
->parent
.file
= chan_file
;
573 chan_file
->private_data
= chan
;
574 fd_install(chan_fd
, chan_file
);
579 atomic_long_dec(&session_file
->f_count
);
583 put_unused_fd(chan_fd
);
589 int lttng_abi_session_set_name(struct lttng_kernel_session
*session
,
590 struct lttng_kernel_abi_session_name
*name
)
594 len
= strnlen(name
->name
, LTTNG_KERNEL_ABI_SESSION_NAME_LEN
);
596 if (len
== LTTNG_KERNEL_ABI_SESSION_NAME_LEN
) {
597 /* Name is too long/malformed */
601 strcpy(session
->priv
->name
, name
->name
);
606 int lttng_abi_session_set_creation_time(struct lttng_kernel_session
*session
,
607 struct lttng_kernel_abi_session_creation_time
*time
)
611 len
= strnlen(time
->iso8601
, LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN
);
613 if (len
== LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN
) {
614 /* Time is too long/malformed */
618 strcpy(session
->priv
->creation_time
, time
->iso8601
);
623 int lttng_counter_release(struct inode
*inode
, struct file
*file
)
625 struct lttng_kernel_channel_counter
*counter
= file
->private_data
;
629 * Do not destroy the counter itself. Wait of the owner
630 * (event_notifier group) to be destroyed.
632 fput(counter
->priv
->owner
);
639 int copy_user_event_param_ext(struct lttng_kernel_abi_event_ext
*event_param_ext
,
640 struct lttng_kernel_abi_event
*event_param
)
642 struct lttng_kernel_abi_event_ext __user
*uevent_ext
=
643 (struct lttng_kernel_abi_event_ext __user
*) (unsigned long) event_param
->event_ext
;
647 /* Use zeroed defaults if extension parameters are not set. */
650 ret
= get_user(len
, &uevent_ext
->len
);
655 ret
= lttng_copy_struct_from_user(event_param_ext
, sizeof(*event_param_ext
), uevent_ext
, len
);
658 /* Ensure that len is consistent with the initial get_user(). */
659 event_param_ext
->len
= len
;
661 /* Validate that we know of all flags and enum values used. */
662 switch (event_param_ext
->match_check
) {
663 case LTTNG_KERNEL_ABI_MATCH_DEFAULT
:
665 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE
:
667 case LTTNG_KERNEL_ABI_MATCH_LAZY
:
676 int user_event_param_ext_get_match_check(const struct lttng_kernel_abi_event_ext
*event_param_ext
,
677 enum lttng_kernel_abi_match_check
*_match_check
)
679 enum lttng_kernel_abi_match_check match_check
= LTTNG_KERNEL_ABI_MATCH_DEFAULT
;
681 if (event_param_ext
->len
< offsetofend(struct lttng_kernel_abi_event_ext
, match_check
))
683 match_check
= event_param_ext
->match_check
;
685 *_match_check
= match_check
;
690 int create_counter_key_from_abi_dimensions(struct lttng_kernel_counter_key
**_counter_key
,
691 uint32_t nr_dimensions
, void __user
*ptr
)
693 struct lttng_kernel_abi_counter_key_dimension __user
*udimension
;
694 struct lttng_kernel_abi_counter_key_dimension kdimension
= {};
695 struct lttng_kernel_counter_key
*counter_key
= NULL
;
696 struct lttng_key_token
*token_array
= NULL
;
700 if (!nr_dimensions
|| nr_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
702 counter_key
= kzalloc(sizeof(*counter_key
), GFP_KERNEL
);
705 counter_key
->nr_dimensions
= nr_dimensions
;
706 /* Only a single dimension is supported. */
707 if (WARN_ON_ONCE(nr_dimensions
!= 1)) {
711 udimension
= (struct lttng_kernel_abi_counter_key_dimension __user
*)ptr
;
712 ret
= lttng_copy_struct_from_user(&kdimension
, sizeof(kdimension
), udimension
, sizeof(*udimension
));
715 if (kdimension
.len
> PAGE_SIZE
) {
719 switch (kdimension
.key_type
) {
720 case LTTNG_KERNEL_ABI_KEY_TYPE_TOKENS
:
722 struct lttng_kernel_abi_counter_key_dimension_tokens kdimension_tokens
= {};
723 struct lttng_kernel_abi_counter_key_dimension_tokens __user
*udimension_tokens
;
724 struct lttng_kernel_abi_key_token __user
*utoken
;
727 udimension_tokens
= (struct lttng_kernel_abi_counter_key_dimension_tokens __user
*)ptr
;
728 ret
= lttng_copy_struct_from_user(&kdimension_tokens
, sizeof(kdimension_tokens
),
729 udimension_tokens
, kdimension
.len
);
732 nr_tokens
= kdimension_tokens
.nr_key_tokens
;
733 if (nr_tokens
> LTTNG_KERNEL_COUNTER_MAX_TOKENS
) {
737 token_array
= kzalloc(nr_tokens
* sizeof(*token_array
), GFP_KERNEL
);
742 counter_key
->dimension_array
[0].token_array
= token_array
;
743 counter_key
->dimension_array
[0].nr_key_tokens
= nr_tokens
;
744 utoken
= (struct lttng_kernel_abi_key_token __user
*)((unsigned long)ptr
+ kdimension
.len
);
745 for (i
= 0; i
< nr_tokens
; i
++) {
746 struct lttng_kernel_abi_key_token ktoken
= {};
747 struct lttng_key_token
*key_token
= &token_array
[i
];
748 uint32_t token_len
= 0;
750 ret
= lttng_copy_struct_from_user(&ktoken
, sizeof(ktoken
), utoken
, sizeof(*utoken
));
753 token_len
+= ktoken
.len
;
754 switch (ktoken
.type
) {
755 case LTTNG_KERNEL_ABI_KEY_TOKEN_STRING
:
757 struct lttng_kernel_abi_key_token_string __user
*utoken_string
;
758 struct lttng_kernel_abi_key_token_string
*ktoken_string
;
759 char __user
*string_ptr
;
762 utoken_string
= (struct lttng_kernel_abi_key_token_string __user
*) utoken
;
763 ret
= lttng_copy_struct_from_user(&ktoken_string
, sizeof(ktoken_string
),
764 utoken_string
, ktoken
.len
);
767 string_ptr
= (char __user
*) ((unsigned long)utoken_string
+ ktoken
.len
);
768 string_len
= ktoken_string
->string_len
;
769 key_token
->type
= LTTNG_KEY_TOKEN_STRING
;
770 if (!string_len
|| string_len
> PAGE_SIZE
) {
774 key_token
->str
= kzalloc(string_len
, GFP_KERNEL
);
775 if (!key_token
->str
) {
779 ret
= copy_from_user(key_token
->str
, string_ptr
, string_len
);
782 if (key_token
->str
[string_len
- 1] != '\0') {
786 token_len
+= string_len
;
789 case LTTNG_KERNEL_ABI_KEY_TOKEN_EVENT_NAME
:
790 key_token
->type
= LTTNG_KEY_TOKEN_EVENT_NAME
;
793 case LTTNG_KERNEL_ABI_KEY_TOKEN_PROVIDER_NAME
:
799 utoken
= (struct lttng_kernel_abi_key_token __user
*)((unsigned long)utoken
+ token_len
);
804 case LTTNG_KERNEL_ABI_KEY_TYPE_INTEGER
:
809 *_counter_key
= counter_key
;
813 destroy_counter_key(counter_key
);
817 int create_counter_key_from_kernel(struct lttng_kernel_counter_key
**_new_key
,
818 const struct lttng_kernel_counter_key
*src_key
)
820 struct lttng_kernel_counter_key
*new_key
;
823 new_key
= kzalloc(sizeof(*new_key
), GFP_KERNEL
);
826 new_key
->nr_dimensions
= src_key
->nr_dimensions
;
827 for (i
= 0; i
< src_key
->nr_dimensions
; i
++) {
828 struct lttng_kernel_counter_key_dimension
*new_dimension
= &new_key
->dimension_array
[i
];
829 const struct lttng_kernel_counter_key_dimension
*src_dimension
= &src_key
->dimension_array
[i
];
830 uint32_t nr_tokens
= src_dimension
->nr_key_tokens
;
833 new_dimension
->nr_key_tokens
= nr_tokens
;
834 new_dimension
->token_array
= kzalloc(nr_tokens
* sizeof(*new_dimension
->token_array
), GFP_KERNEL
);
835 if (!new_dimension
->token_array
) {
839 for (j
= 0; j
< nr_tokens
; j
++) {
840 struct lttng_key_token
*new_key_token
= &new_dimension
->token_array
[j
];
841 struct lttng_key_token
*src_key_token
= &src_dimension
->token_array
[j
];
843 switch (src_key_token
->type
) {
844 case LTTNG_KEY_TOKEN_STRING
:
845 new_key_token
->type
= LTTNG_KEY_TOKEN_STRING
;
846 new_key_token
->str
= kstrdup(src_key_token
->str
, GFP_KERNEL
);
847 if (!new_key_token
->str
) {
852 case LTTNG_KEY_TOKEN_EVENT_NAME
:
853 new_key_token
->type
= LTTNG_KEY_TOKEN_EVENT_NAME
;
866 destroy_counter_key(new_key
);
870 void destroy_counter_key(struct lttng_kernel_counter_key
*counter_key
)
876 for (i
= 0; i
< counter_key
->nr_dimensions
; i
++) {
877 struct lttng_kernel_counter_key_dimension
*dimension
= &counter_key
->dimension_array
[i
];
878 uint32_t nr_tokens
= dimension
->nr_key_tokens
;
881 for (j
= 0; j
< nr_tokens
; j
++) {
882 struct lttng_key_token
*key_token
= &dimension
->token_array
[j
];
884 switch (key_token
->type
) {
885 case LTTNG_KEY_TOKEN_STRING
:
886 kfree(key_token
->str
);
889 case LTTNG_KEY_TOKEN_EVENT_NAME
:
891 case LTTNG_KEY_TOKEN_UNKNOWN
:
898 kfree(dimension
->token_array
);
904 long lttng_counter_ioctl_abi_old_counter_read(struct lttng_kernel_channel_counter
*counter
,
905 unsigned int cmd
, unsigned long arg
)
907 size_t indexes
[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
] = {};
908 struct lttng_kernel_abi_old_counter_read local_counter_read
;
909 struct lttng_kernel_abi_old_counter_read __user
*ucounter_read
=
910 (struct lttng_kernel_abi_old_counter_read __user
*) arg
;
911 bool overflow
, underflow
;
916 if (copy_from_user(&local_counter_read
, ucounter_read
,
917 sizeof(local_counter_read
)))
919 if (validate_zeroed_padding(local_counter_read
.padding
,
920 sizeof(local_counter_read
.padding
)))
922 if (local_counter_read
.index
.number_dimensions
> LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
)
924 /* Cast all indexes into size_t. */
925 for (i
= 0; i
< local_counter_read
.index
.number_dimensions
; i
++)
926 indexes
[i
] = local_counter_read
.index
.dimension_indexes
[i
];
927 cpu
= local_counter_read
.cpu
;
929 ret
= lttng_kernel_counter_read(counter
, indexes
, cpu
, &value
, &overflow
, &underflow
);
932 local_counter_read
.value
.value
= value
;
933 local_counter_read
.value
.overflow
= overflow
;
934 local_counter_read
.value
.underflow
= underflow
;
936 if (copy_to_user(&ucounter_read
->value
, &local_counter_read
.value
,
937 sizeof(local_counter_read
.value
)))
944 long lttng_counter_ioctl_abi_old_counter_aggregate(struct lttng_kernel_channel_counter
*counter
,
945 unsigned int cmd
, unsigned long arg
)
947 size_t indexes
[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
] = {};
948 struct lttng_kernel_abi_old_counter_aggregate local_counter_aggregate
;
949 struct lttng_kernel_abi_old_counter_aggregate __user
*ucounter_aggregate
=
950 (struct lttng_kernel_abi_old_counter_aggregate __user
*) arg
;
951 bool overflow
, underflow
;
955 if (copy_from_user(&local_counter_aggregate
, ucounter_aggregate
,
956 sizeof(local_counter_aggregate
)))
958 if (validate_zeroed_padding(local_counter_aggregate
.padding
,
959 sizeof(local_counter_aggregate
.padding
)))
961 if (local_counter_aggregate
.index
.number_dimensions
> LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
)
963 /* Cast all indexes into size_t. */
964 for (i
= 0; i
< local_counter_aggregate
.index
.number_dimensions
; i
++)
965 indexes
[i
] = local_counter_aggregate
.index
.dimension_indexes
[i
];
967 ret
= lttng_kernel_counter_aggregate(counter
, indexes
, &value
, &overflow
, &underflow
);
970 local_counter_aggregate
.value
.value
= value
;
971 local_counter_aggregate
.value
.overflow
= overflow
;
972 local_counter_aggregate
.value
.underflow
= underflow
;
974 if (copy_to_user(&ucounter_aggregate
->value
, &local_counter_aggregate
.value
,
975 sizeof(local_counter_aggregate
.value
)))
982 long lttng_counter_ioctl_abi_old_counter_clear(struct lttng_kernel_channel_counter
*counter
,
983 unsigned int cmd
, unsigned long arg
)
985 size_t indexes
[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
] = {};
986 struct lttng_kernel_abi_old_counter_clear local_counter_clear
;
987 struct lttng_kernel_abi_old_counter_clear __user
*ucounter_clear
=
988 (struct lttng_kernel_abi_old_counter_clear __user
*) arg
;
991 if (copy_from_user(&local_counter_clear
, ucounter_clear
,
992 sizeof(local_counter_clear
)))
994 if (validate_zeroed_padding(local_counter_clear
.padding
,
995 sizeof(local_counter_clear
.padding
)))
997 if (local_counter_clear
.index
.number_dimensions
> LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX
)
999 /* Cast all indexes into size_t. */
1000 for (i
= 0; i
< local_counter_clear
.index
.number_dimensions
; i
++)
1001 indexes
[i
] = local_counter_clear
.index
.dimension_indexes
[i
];
1002 return lttng_kernel_counter_clear(counter
, indexes
);
1006 long lttng_counter_ioctl_abi_counter_read(struct lttng_kernel_channel_counter
*counter
,
1007 unsigned int cmd
, unsigned long arg
)
1009 size_t indexes
[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
] = {};
1010 struct lttng_kernel_abi_counter_read kcounter_read
= {};
1011 struct lttng_kernel_abi_counter_read __user
*ucounter_read
=
1012 (struct lttng_kernel_abi_counter_read __user
*) arg
;
1013 uint32_t len
, number_dimensions
;
1014 bool overflow
, underflow
;
1019 ret
= get_user(len
, &ucounter_read
->len
);
1022 if (len
> PAGE_SIZE
)
1024 if (len
< offsetofend(struct lttng_kernel_abi_counter_read
, value
))
1026 ret
= lttng_copy_struct_from_user(&kcounter_read
, sizeof(kcounter_read
),
1027 ucounter_read
, len
);
1030 number_dimensions
= kcounter_read
.index
.number_dimensions
;
1031 if (!number_dimensions
|| number_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
1033 /* Cast all indexes into size_t. */
1034 for (i
= 0; i
< number_dimensions
; i
++) {
1035 uint64_t __user
*ptr
= ((uint64_t __user
*)(unsigned long)kcounter_read
.index
.ptr
) + i
;
1038 ret
= get_user(index
, ptr
);
1043 cpu
= kcounter_read
.cpu
;
1044 ret
= lttng_kernel_counter_read(counter
, indexes
, cpu
, &value
, &overflow
, &underflow
);
1047 kcounter_read
.value
.value
= value
;
1048 kcounter_read
.value
.flags
|= underflow
? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_UNDERFLOW
: 0;
1049 kcounter_read
.value
.flags
|= overflow
? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_OVERFLOW
: 0;
1051 if (copy_to_user(&ucounter_read
->value
, &kcounter_read
.value
, sizeof(kcounter_read
.value
)))
1058 long lttng_counter_ioctl_abi_counter_aggregate(struct lttng_kernel_channel_counter
*counter
,
1059 unsigned int cmd
, unsigned long arg
)
1061 size_t indexes
[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
] = {};
1062 struct lttng_kernel_abi_counter_aggregate kcounter_aggregate
= {};
1063 struct lttng_kernel_abi_counter_aggregate __user
*ucounter_aggregate
=
1064 (struct lttng_kernel_abi_counter_aggregate __user
*) arg
;
1065 uint32_t len
, number_dimensions
;
1066 bool overflow
, underflow
;
1070 ret
= get_user(len
, &ucounter_aggregate
->len
);
1073 if (len
> PAGE_SIZE
)
1075 if (len
< offsetofend(struct lttng_kernel_abi_counter_aggregate
, value
))
1077 ret
= lttng_copy_struct_from_user(&kcounter_aggregate
, sizeof(kcounter_aggregate
),
1078 ucounter_aggregate
, len
);
1081 number_dimensions
= kcounter_aggregate
.index
.number_dimensions
;
1082 if (!number_dimensions
|| number_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
1084 /* Cast all indexes into size_t. */
1085 for (i
= 0; i
< number_dimensions
; i
++) {
1086 uint64_t __user
*ptr
= ((uint64_t __user
*)(unsigned long)kcounter_aggregate
.index
.ptr
) + i
;
1089 ret
= get_user(index
, ptr
);
1094 ret
= lttng_kernel_counter_aggregate(counter
, indexes
, &value
, &overflow
, &underflow
);
1097 kcounter_aggregate
.value
.value
= value
;
1098 kcounter_aggregate
.value
.flags
|= underflow
? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_UNDERFLOW
: 0;
1099 kcounter_aggregate
.value
.flags
|= overflow
? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_OVERFLOW
: 0;
1101 if (copy_to_user(&ucounter_aggregate
->value
, &kcounter_aggregate
.value
, sizeof(kcounter_aggregate
.value
)))
1108 long lttng_counter_ioctl_abi_counter_clear(struct lttng_kernel_channel_counter
*counter
,
1109 unsigned int cmd
, unsigned long arg
)
1111 size_t indexes
[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
] = {};
1112 struct lttng_kernel_abi_counter_clear kcounter_clear
= {};
1113 struct lttng_kernel_abi_counter_clear __user
*ucounter_clear
=
1114 (struct lttng_kernel_abi_counter_clear __user
*) arg
;
1115 uint32_t len
, number_dimensions
;
1118 ret
= get_user(len
, &ucounter_clear
->len
);
1121 if (len
> PAGE_SIZE
)
1123 if (len
< offsetofend(struct lttng_kernel_abi_counter_clear
, index
))
1125 ret
= lttng_copy_struct_from_user(&kcounter_clear
, sizeof(kcounter_clear
),
1126 ucounter_clear
, len
);
1129 number_dimensions
= kcounter_clear
.index
.number_dimensions
;
1130 if (!number_dimensions
|| number_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
1132 /* Cast all indexes into size_t. */
1133 for (i
= 0; i
< number_dimensions
; i
++) {
1134 uint64_t __user
*ptr
= ((uint64_t __user
*)(unsigned long)kcounter_clear
.index
.ptr
) + i
;
1137 ret
= get_user(index
, ptr
);
1142 return lttng_kernel_counter_clear(counter
, indexes
);
1146 long lttng_counter_ioctl_abi_counter_event(struct file
*file
,
1147 struct lttng_kernel_channel_counter
*counter
,
1148 unsigned int cmd
, unsigned long arg
)
1150 struct lttng_kernel_abi_counter_event __user
*ucounter_event
=
1151 (struct lttng_kernel_abi_counter_event __user
*) arg
;
1152 struct lttng_kernel_abi_counter_event kcounter_event
= {};
1153 struct lttng_kernel_counter_event
*counter_event
;
1157 ret
= get_user(len
, &ucounter_event
->len
);
1160 if (len
> PAGE_SIZE
)
1162 if (len
< offsetofend(struct lttng_kernel_abi_counter_event
, number_key_dimensions
))
1164 counter_event
= kzalloc(sizeof(*counter_event
), GFP_KERNEL
);
1167 ret
= lttng_copy_struct_from_user(&kcounter_event
, sizeof(kcounter_event
),
1168 ucounter_event
, len
);
1170 goto end_counter_event
;
1171 memcpy(&counter_event
->event_param
, &kcounter_event
.event
, sizeof(counter_event
->event_param
));
1172 ret
= copy_user_event_param_ext(&counter_event
->event_param_ext
, &kcounter_event
.event
);
1174 goto end_counter_event
;
1175 switch (kcounter_event
.action
) {
1176 case LTTNG_KERNEL_ABI_COUNTER_ACTION_INCREMENT
:
1177 /* No specific data for this action. */
1181 goto end_counter_event
;
1183 ret
= create_counter_key_from_abi_dimensions(&counter_event
->counter_key
,
1184 kcounter_event
.number_key_dimensions
,
1185 (void __user
*) arg
+ len
);
1187 goto end_counter_event
;
1188 ret
= lttng_abi_create_event_counter_enabler(file
, counter_event
);
1189 destroy_counter_key(counter_event
->counter_key
);
1191 kfree(counter_event
);
1196 long lttng_counter_ioctl_abi_counter_map_descriptor(struct lttng_kernel_channel_counter
*counter
,
1197 unsigned int cmd
, unsigned long arg
)
1199 struct lttng_kernel_abi_counter_map_descriptor __user
*udescriptor
=
1200 (struct lttng_kernel_abi_counter_map_descriptor __user
*) arg
;
1201 struct lttng_kernel_abi_counter_map_descriptor kdescriptor
= {};
1202 struct lttng_counter_map_descriptor
*descriptor
;
1203 char key
[LTTNG_KERNEL_COUNTER_KEY_LEN
] = {};
1204 uint64_t array_indexes
[1];
1209 ret
= get_user(len
, &udescriptor
->len
);
1212 if (len
> PAGE_SIZE
)
1214 if (len
< offsetofend(struct lttng_kernel_abi_counter_map_descriptor
, array_indexes_len
))
1216 ret
= lttng_copy_struct_from_user(&kdescriptor
, sizeof(kdescriptor
), udescriptor
, len
);
1219 mutex_lock(&counter
->priv
->map
.lock
);
1220 if (kdescriptor
.descriptor_index
>= counter
->priv
->map
.nr_descriptors
) {
1222 goto map_descriptor_error_unlock
;
1224 if (kdescriptor
.array_indexes_len
< 1) {
1226 goto map_descriptor_error_unlock
;
1228 kdescriptor
.array_indexes_len
= 1;
1229 descriptor
= &counter
->priv
->map
.descriptors
[kdescriptor
.descriptor_index
];
1230 kdescriptor
.dimension
= 0;
1231 kdescriptor
.user_token
= descriptor
->user_token
;
1232 memcpy(&key
, descriptor
->key
, LTTNG_KERNEL_COUNTER_KEY_LEN
);
1233 array_indexes
[0] = descriptor
->array_index
;
1234 mutex_unlock(&counter
->priv
->map
.lock
);
1236 key_strlen
= strlen(key
) + 1;
1237 if (kdescriptor
.key_string_len
< key_strlen
)
1239 kdescriptor
.key_string_len
= key_strlen
;
1240 if (copy_to_user((char __user
*)(unsigned long)kdescriptor
.key_string
, key
, key_strlen
))
1242 if (copy_to_user((uint64_t __user
*)(unsigned long)kdescriptor
.array_indexes
, array_indexes
, sizeof(uint64_t)))
1244 if (copy_to_user(udescriptor
, &kdescriptor
, min(sizeof(kdescriptor
), (size_t)len
)))
1248 map_descriptor_error_unlock
:
1249 mutex_unlock(&counter
->priv
->map
.lock
);
1254 long lttng_counter_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1256 struct lttng_kernel_channel_counter
*counter
= file
->private_data
;
1259 case LTTNG_KERNEL_ABI_OLD_COUNTER_READ
:
1260 return lttng_counter_ioctl_abi_old_counter_read(counter
, cmd
, arg
);
1261 case LTTNG_KERNEL_ABI_OLD_COUNTER_AGGREGATE
:
1262 return lttng_counter_ioctl_abi_old_counter_aggregate(counter
, cmd
, arg
);
1263 case LTTNG_KERNEL_ABI_OLD_COUNTER_CLEAR
:
1264 return lttng_counter_ioctl_abi_old_counter_clear(counter
, cmd
, arg
);
1265 case LTTNG_KERNEL_ABI_COUNTER_READ
:
1266 return lttng_counter_ioctl_abi_counter_read(counter
, cmd
, arg
);
1267 case LTTNG_KERNEL_ABI_COUNTER_AGGREGATE
:
1268 return lttng_counter_ioctl_abi_counter_aggregate(counter
, cmd
, arg
);
1269 case LTTNG_KERNEL_ABI_COUNTER_CLEAR
:
1270 return lttng_counter_ioctl_abi_counter_clear(counter
, cmd
, arg
);
1271 case LTTNG_KERNEL_ABI_COUNTER_EVENT
:
1272 return lttng_counter_ioctl_abi_counter_event(file
, counter
, cmd
, arg
);
1273 case LTTNG_KERNEL_ABI_ENABLE
:
1274 return lttng_channel_enable(&counter
->parent
);
1275 case LTTNG_KERNEL_ABI_DISABLE
:
1276 return lttng_channel_disable(&counter
->parent
);
1277 case LTTNG_KERNEL_ABI_SYSCALL_MASK
:
1278 return lttng_syscall_table_get_active_mask(&counter
->priv
->parent
.syscall_table
,
1279 (struct lttng_kernel_abi_syscall_mask __user
*) arg
);
1280 case LTTNG_KERNEL_ABI_COUNTER_MAP_NR_DESCRIPTORS
:
1282 uint64_t __user
*user_nr_descriptors
= (uint64_t __user
*) arg
;
1283 uint64_t nr_descriptors
;
1285 mutex_lock(&counter
->priv
->map
.lock
);
1286 nr_descriptors
= counter
->priv
->map
.nr_descriptors
;
1287 mutex_unlock(&counter
->priv
->map
.lock
);
1288 return put_user(nr_descriptors
, user_nr_descriptors
);
1290 case LTTNG_KERNEL_ABI_COUNTER_MAP_DESCRIPTOR
:
1291 return lttng_counter_ioctl_abi_counter_map_descriptor(counter
, cmd
, arg
);
1297 static const struct file_operations lttng_counter_fops
= {
1298 .owner
= THIS_MODULE
,
1299 .release
= lttng_counter_release
,
1300 .unlocked_ioctl
= lttng_counter_ioctl
,
1301 #ifdef CONFIG_COMPAT
1302 .compat_ioctl
= lttng_counter_ioctl
,
1308 enum tracker_type
get_tracker_type(struct lttng_kernel_abi_tracker_args
*tracker
)
1310 switch (tracker
->type
) {
1311 case LTTNG_KERNEL_ABI_TRACKER_PID
:
1313 case LTTNG_KERNEL_ABI_TRACKER_VPID
:
1314 return TRACKER_VPID
;
1315 case LTTNG_KERNEL_ABI_TRACKER_UID
:
1317 case LTTNG_KERNEL_ABI_TRACKER_VUID
:
1318 return TRACKER_VUID
;
1319 case LTTNG_KERNEL_ABI_TRACKER_GID
:
1321 case LTTNG_KERNEL_ABI_TRACKER_VGID
:
1322 return TRACKER_VGID
;
1324 return TRACKER_UNKNOWN
;
1329 int lttng_abi_copy_user_old_counter_conf(struct lttng_kernel_counter_conf
*counter_conf
,
1330 struct lttng_kernel_abi_old_counter_conf __user
*old_ucounter_conf
)
1332 struct lttng_kernel_abi_old_counter_conf old_kcounter_conf
;
1333 struct lttng_kernel_counter_dimension
*dimension
;
1336 memset(counter_conf
, 0, sizeof(*counter_conf
));
1337 ret
= copy_from_user(&old_kcounter_conf
, old_ucounter_conf
,
1338 sizeof(old_kcounter_conf
));
1341 if (!old_kcounter_conf
.number_dimensions
||
1342 old_kcounter_conf
.number_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
1344 switch (old_kcounter_conf
.arithmetic
) {
1345 case LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR
:
1346 counter_conf
->arithmetic
= LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR
;
1351 switch (old_kcounter_conf
.bitness
) {
1352 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32
:
1353 counter_conf
->bitness
= LTTNG_KERNEL_COUNTER_BITNESS_32
;
1355 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64
:
1356 counter_conf
->bitness
= LTTNG_KERNEL_COUNTER_BITNESS_64
;
1361 counter_conf
->global_sum_step
= old_kcounter_conf
.global_sum_step
;
1362 counter_conf
->flags
|= old_kcounter_conf
.coalesce_hits
?
1363 LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS
: 0;
1364 dimension
= &counter_conf
->dimension_array
[0];
1365 dimension
->flags
|= old_kcounter_conf
.dimensions
[0].has_underflow
?
1366 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_UNDERFLOW
: 0;
1367 dimension
->flags
|= old_kcounter_conf
.dimensions
[0].has_overflow
?
1368 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_OVERFLOW
: 0;
1369 dimension
->size
= old_kcounter_conf
.dimensions
[0].size
;
1370 dimension
->underflow_index
= old_kcounter_conf
.dimensions
[0].underflow_index
;
1371 dimension
->overflow_index
= old_kcounter_conf
.dimensions
[0].overflow_index
;
1376 int lttng_abi_copy_user_counter_conf(struct lttng_kernel_counter_conf
*counter_conf
,
1377 struct lttng_kernel_abi_counter_conf __user
*ucounter_conf
)
1379 uint32_t len
, number_dimensions
;
1380 struct lttng_kernel_abi_counter_conf kcounter_conf
= {};
1381 struct lttng_kernel_counter_dimension
*dimension
;
1382 struct lttng_kernel_abi_counter_dimension kdimension
= {};
1383 struct lttng_kernel_abi_counter_dimension __user
*udimension
;
1386 memset(counter_conf
, 0, sizeof(*counter_conf
));
1387 ret
= get_user(len
, &ucounter_conf
->len
);
1390 if (len
< offsetofend(struct lttng_kernel_abi_counter_conf
, dimension_array
))
1392 if (len
> PAGE_SIZE
)
1395 ret
= lttng_copy_struct_from_user(&kcounter_conf
, sizeof(kcounter_conf
), ucounter_conf
, len
);
1399 /* Validate flags and enumerations */
1400 switch (kcounter_conf
.arithmetic
) {
1401 case LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR
:
1402 counter_conf
->arithmetic
= LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR
;
1407 switch (kcounter_conf
.bitness
) {
1408 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32
:
1409 counter_conf
->bitness
= LTTNG_KERNEL_COUNTER_BITNESS_32
;
1411 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64
:
1412 counter_conf
->bitness
= LTTNG_KERNEL_COUNTER_BITNESS_64
;
1417 if (kcounter_conf
.flags
& ~LTTNG_KERNEL_ABI_COUNTER_CONF_FLAG_COALESCE_HITS
)
1419 counter_conf
->global_sum_step
= kcounter_conf
.global_sum_step
;
1420 counter_conf
->flags
|= (kcounter_conf
.flags
& LTTNG_KERNEL_ABI_COUNTER_CONF_FLAG_COALESCE_HITS
) ?
1421 LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS
: 0;
1423 number_dimensions
= kcounter_conf
.dimension_array
.number_dimensions
;
1424 if (!number_dimensions
|| number_dimensions
> LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS
)
1426 dimension
= &counter_conf
->dimension_array
[0];
1427 len
= kcounter_conf
.dimension_array
.elem_len
;
1428 if (len
> PAGE_SIZE
)
1430 if (len
< offsetofend(struct lttng_kernel_abi_counter_dimension
, overflow_index
))
1432 udimension
= (struct lttng_kernel_abi_counter_dimension __user
*)(unsigned long)kcounter_conf
.dimension_array
.ptr
;
1433 ret
= lttng_copy_struct_from_user(&kdimension
, sizeof(kdimension
), udimension
, len
);
1437 /* Validate flags */
1438 if (kdimension
.flags
& ~(LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW
|
1439 LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW
))
1442 dimension
->flags
|= (kdimension
.flags
& LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW
) ?
1443 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_UNDERFLOW
: 0;
1444 dimension
->flags
|= (kdimension
.flags
& LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW
) ?
1445 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_OVERFLOW
: 0;
1446 dimension
->size
= kdimension
.size
;
1447 dimension
->underflow_index
= kdimension
.underflow_index
;
1448 dimension
->overflow_index
= kdimension
.overflow_index
;
1453 * lttng_session_ioctl - lttng session fd ioctl
1459 * This ioctl implements lttng commands:
1460 * LTTNG_KERNEL_ABI_CHANNEL
1461 * Returns a LTTng channel file descriptor
1462 * LTTNG_KERNEL_ABI_ENABLE
1463 * Enables tracing for a session (weak enable)
1464 * LTTNG_KERNEL_ABI_DISABLE
1465 * Disables tracing for a session (strong disable)
1466 * LTTNG_KERNEL_ABI_METADATA
1467 * Returns a LTTng metadata file descriptor
1468 * LTTNG_KERNEL_ABI_SESSION_TRACK_PID
1469 * Add PID to session PID tracker
1470 * LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID
1471 * Remove PID from session PID tracker
1472 * LTTNG_KERNEL_ABI_SESSION_TRACK_ID
1474 * LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID
1475 * Remove ID from tracker
1477 * The returned channel will be deleted when its file descriptor is closed.
1480 long lttng_session_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1482 struct lttng_kernel_session
*session
= file
->private_data
;
1483 struct lttng_kernel_abi_channel chan_param
;
1484 struct lttng_kernel_abi_old_channel old_chan_param
;
1488 * Handle backward compatibility. OLD commands have wrong
1489 * directions, replace them by the correct direction.
1492 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_PID
:
1493 cmd
= LTTNG_KERNEL_ABI_SESSION_TRACK_PID
;
1495 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_PID
:
1496 cmd
= LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID
;
1498 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_ID
:
1499 cmd
= LTTNG_KERNEL_ABI_SESSION_TRACK_ID
;
1501 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_ID
:
1502 cmd
= LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID
;
1504 case LTTNG_KERNEL_ABI_OLD_SESSION_LIST_TRACKER_IDS
:
1505 cmd
= LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS
;
1507 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_NAME
:
1508 cmd
= LTTNG_KERNEL_ABI_SESSION_SET_NAME
;
1510 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_CREATION_TIME
:
1511 cmd
= LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME
;
1514 /* Nothing to do. */
1519 case LTTNG_KERNEL_ABI_OLD_CHANNEL
:
1521 if (copy_from_user(&old_chan_param
,
1522 (struct lttng_kernel_abi_old_channel __user
*) arg
,
1523 sizeof(struct lttng_kernel_abi_old_channel
)))
1525 chan_param
.overwrite
= old_chan_param
.overwrite
;
1526 chan_param
.subbuf_size
= old_chan_param
.subbuf_size
;
1527 chan_param
.num_subbuf
= old_chan_param
.num_subbuf
;
1528 chan_param
.switch_timer_interval
= old_chan_param
.switch_timer_interval
;
1529 chan_param
.read_timer_interval
= old_chan_param
.read_timer_interval
;
1530 chan_param
.output
= old_chan_param
.output
;
1532 return lttng_abi_create_channel(file
, &chan_param
,
1535 case LTTNG_KERNEL_ABI_CHANNEL
:
1537 if (copy_from_user(&chan_param
,
1538 (struct lttng_kernel_abi_channel __user
*) arg
,
1539 sizeof(struct lttng_kernel_abi_channel
)))
1541 return lttng_abi_create_channel(file
, &chan_param
,
1544 case LTTNG_KERNEL_ABI_OLD_SESSION_START
:
1545 case LTTNG_KERNEL_ABI_OLD_ENABLE
:
1546 case LTTNG_KERNEL_ABI_SESSION_START
:
1547 case LTTNG_KERNEL_ABI_ENABLE
:
1548 return lttng_session_enable(session
);
1549 case LTTNG_KERNEL_ABI_OLD_SESSION_STOP
:
1550 case LTTNG_KERNEL_ABI_OLD_DISABLE
:
1551 case LTTNG_KERNEL_ABI_SESSION_STOP
:
1552 case LTTNG_KERNEL_ABI_DISABLE
:
1553 return lttng_session_disable(session
);
1554 case LTTNG_KERNEL_ABI_OLD_METADATA
:
1556 if (copy_from_user(&old_chan_param
,
1557 (struct lttng_kernel_abi_old_channel __user
*) arg
,
1558 sizeof(struct lttng_kernel_abi_old_channel
)))
1560 chan_param
.overwrite
= old_chan_param
.overwrite
;
1561 chan_param
.subbuf_size
= old_chan_param
.subbuf_size
;
1562 chan_param
.num_subbuf
= old_chan_param
.num_subbuf
;
1563 chan_param
.switch_timer_interval
= old_chan_param
.switch_timer_interval
;
1564 chan_param
.read_timer_interval
= old_chan_param
.read_timer_interval
;
1565 chan_param
.output
= old_chan_param
.output
;
1567 return lttng_abi_create_channel(file
, &chan_param
,
1570 case LTTNG_KERNEL_ABI_METADATA
:
1572 if (copy_from_user(&chan_param
,
1573 (struct lttng_kernel_abi_channel __user
*) arg
,
1574 sizeof(struct lttng_kernel_abi_channel
)))
1576 return lttng_abi_create_channel(file
, &chan_param
,
1579 case LTTNG_KERNEL_ABI_SESSION_TRACK_PID
:
1580 return lttng_session_track_id(session
, TRACKER_PID
, (int) arg
);
1581 case LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID
:
1582 return lttng_session_untrack_id(session
, TRACKER_PID
, (int) arg
);
1583 case LTTNG_KERNEL_ABI_SESSION_TRACK_ID
:
1585 struct lttng_kernel_abi_tracker_args tracker
;
1586 enum tracker_type tracker_type
;
1588 if (copy_from_user(&tracker
,
1589 (struct lttng_kernel_abi_tracker_args __user
*) arg
,
1590 sizeof(struct lttng_kernel_abi_tracker_args
)))
1592 tracker_type
= get_tracker_type(&tracker
);
1593 if (tracker_type
== TRACKER_UNKNOWN
)
1595 return lttng_session_track_id(session
, tracker_type
, tracker
.id
);
1597 case LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID
:
1599 struct lttng_kernel_abi_tracker_args tracker
;
1600 enum tracker_type tracker_type
;
1602 if (copy_from_user(&tracker
,
1603 (struct lttng_kernel_abi_tracker_args __user
*) arg
,
1604 sizeof(struct lttng_kernel_abi_tracker_args
)))
1606 tracker_type
= get_tracker_type(&tracker
);
1607 if (tracker_type
== TRACKER_UNKNOWN
)
1609 return lttng_session_untrack_id(session
, tracker_type
,
1612 case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_PIDS
:
1613 return lttng_session_list_tracker_ids(session
, TRACKER_PID
);
1614 case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS
:
1616 struct lttng_kernel_abi_tracker_args tracker
;
1617 enum tracker_type tracker_type
;
1619 if (copy_from_user(&tracker
,
1620 (struct lttng_kernel_abi_tracker_args __user
*) arg
,
1621 sizeof(struct lttng_kernel_abi_tracker_args
)))
1623 tracker_type
= get_tracker_type(&tracker
);
1624 if (tracker_type
== TRACKER_UNKNOWN
)
1626 return lttng_session_list_tracker_ids(session
, tracker_type
);
1628 case LTTNG_KERNEL_ABI_SESSION_METADATA_REGEN
:
1629 return lttng_session_metadata_regenerate(session
);
1630 case LTTNG_KERNEL_ABI_SESSION_STATEDUMP
:
1631 return lttng_session_statedump(session
);
1632 case LTTNG_KERNEL_ABI_SESSION_SET_NAME
:
1634 struct lttng_kernel_abi_session_name name
;
1636 if (copy_from_user(&name
,
1637 (struct lttng_kernel_abi_session_name __user
*) arg
,
1638 sizeof(struct lttng_kernel_abi_session_name
)))
1640 return lttng_abi_session_set_name(session
, &name
);
1642 case LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME
:
1644 struct lttng_kernel_abi_session_creation_time time
;
1646 if (copy_from_user(&time
,
1647 (struct lttng_kernel_abi_session_creation_time __user
*) arg
,
1648 sizeof(struct lttng_kernel_abi_session_creation_time
)))
1650 return lttng_abi_session_set_creation_time(session
, &time
);
1652 case LTTNG_KERNEL_ABI_COUNTER
:
1654 struct lttng_kernel_counter_conf counter_conf
;
1656 ret
= lttng_abi_copy_user_counter_conf(&counter_conf
,
1657 (struct lttng_kernel_abi_counter_conf __user
*) arg
);
1660 return lttng_abi_session_create_counter(session
, &counter_conf
);
1663 return -ENOIOCTLCMD
;
1668 * Called when the last file reference is dropped.
1670 * Big fat note: channels and events are invariant for the whole session after
1671 * their creation. So this session destruction also destroys all channel and
1672 * event structures specific to this session (they are not destroyed when their
1673 * individual file is released).
1676 int lttng_session_release(struct inode
*inode
, struct file
*file
)
1678 struct lttng_kernel_session
*session
= file
->private_data
;
1681 lttng_session_destroy(session
);
1685 static const struct file_operations lttng_session_fops
= {
1686 .owner
= THIS_MODULE
,
1687 .release
= lttng_session_release
,
1688 .unlocked_ioctl
= lttng_session_ioctl
,
1689 #ifdef CONFIG_COMPAT
1690 .compat_ioctl
= lttng_session_ioctl
,
1695 * When encountering empty buffer, flush current sub-buffer if non-empty
1696 * and retry (if new data available to read after flush).
1699 ssize_t
lttng_event_notifier_group_notif_read(struct file
*filp
, char __user
*user_buf
,
1700 size_t count
, loff_t
*ppos
)
1702 struct lttng_event_notifier_group
*event_notifier_group
= filp
->private_data
;
1703 struct lttng_kernel_ring_buffer_channel
*chan
= event_notifier_group
->chan
;
1704 struct lttng_kernel_ring_buffer
*buf
= event_notifier_group
->buf
;
1705 ssize_t read_count
= 0, len
;
1709 if (!lttng_access_ok(VERIFY_WRITE
, user_buf
, count
))
1712 /* Finish copy of previous record */
1715 len
= chan
->iter
.len_left
;
1716 read_offset
= *ppos
;
1721 while (read_count
< count
) {
1722 size_t copy_len
, space_left
;
1724 len
= lib_ring_buffer_get_next_record(chan
, buf
);
1728 * Check if buffer is finalized (end of file).
1730 if (len
== -ENODATA
) {
1731 /* A 0 read_count will tell about end of file */
1734 if (filp
->f_flags
& O_NONBLOCK
) {
1736 read_count
= -EAGAIN
;
1742 * No data available at the moment, return what
1749 * Wait for returned len to be >= 0 or -ENODATA.
1751 error
= wait_event_interruptible(
1752 event_notifier_group
->read_wait
,
1753 ((len
= lib_ring_buffer_get_next_record(
1754 chan
, buf
)), len
!= -EAGAIN
));
1755 CHAN_WARN_ON(chan
, len
== -EBUSY
);
1760 CHAN_WARN_ON(chan
, len
< 0 && len
!= -ENODATA
);
1764 read_offset
= buf
->iter
.read_offset
;
1766 space_left
= count
- read_count
;
1767 if (len
<= space_left
) {
1769 chan
->iter
.len_left
= 0;
1772 copy_len
= space_left
;
1773 chan
->iter
.len_left
= len
- copy_len
;
1774 *ppos
= read_offset
+ copy_len
;
1776 if (__lib_ring_buffer_copy_to_user(&buf
->backend
, read_offset
,
1777 &user_buf
[read_count
],
1780 * Leave the len_left and ppos values at their current
1781 * state, as we currently have a valid event to read.
1785 read_count
+= copy_len
;
1791 chan
->iter
.len_left
= 0;
1795 lib_ring_buffer_put_current_record(buf
);
1800 * If the ring buffer is non empty (even just a partial subbuffer), return that
1801 * there is data available. Perform a ring buffer flush if we encounter a
1802 * non-empty ring buffer which does not have any consumeable subbuffer available.
1805 unsigned int lttng_event_notifier_group_notif_poll(struct file
*filp
,
1808 unsigned int mask
= 0;
1809 struct lttng_event_notifier_group
*event_notifier_group
= filp
->private_data
;
1810 struct lttng_kernel_ring_buffer_channel
*chan
= event_notifier_group
->chan
;
1811 struct lttng_kernel_ring_buffer
*buf
= event_notifier_group
->buf
;
1812 const struct lttng_kernel_ring_buffer_config
*config
= &chan
->backend
.config
;
1813 int finalized
, disabled
;
1814 unsigned long consumed
, offset
;
1815 size_t subbuffer_header_size
= config
->cb
.subbuffer_header_size();
1817 if (filp
->f_mode
& FMODE_READ
) {
1818 poll_wait_set_exclusive(wait
);
1819 poll_wait(filp
, &event_notifier_group
->read_wait
, wait
);
1821 finalized
= lib_ring_buffer_is_finalized(config
, buf
);
1822 disabled
= lib_ring_buffer_channel_is_disabled(chan
);
1825 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
1826 * finalized load before offsets loads.
1828 WARN_ON(atomic_long_read(&buf
->active_readers
) != 1);
1833 offset
= lib_ring_buffer_get_offset(config
, buf
);
1834 consumed
= lib_ring_buffer_get_consumed(config
, buf
);
1837 * If there is no buffer available to consume.
1839 if (subbuf_trunc(offset
, chan
) - subbuf_trunc(consumed
, chan
) == 0) {
1841 * If there is a non-empty subbuffer, flush and try again.
1843 if (subbuf_offset(offset
, chan
) > subbuffer_header_size
) {
1844 lib_ring_buffer_switch_remote(buf
);
1852 * The memory barriers
1853 * __wait_event()/wake_up_interruptible() take
1854 * care of "raw_spin_is_locked" memory ordering.
1856 if (raw_spin_is_locked(&buf
->raw_tick_nohz_spinlock
))
1862 if (subbuf_trunc(offset
, chan
) - subbuf_trunc(consumed
, chan
)
1863 >= chan
->backend
.buf_size
)
1864 return POLLPRI
| POLLRDBAND
;
1866 return POLLIN
| POLLRDNORM
;
1874 * lttng_event_notifier_group_notif_open - event_notifier ring buffer open file operation
1875 * @inode: opened inode
1876 * @file: opened file
1878 * Open implementation. Makes sure only one open instance of a buffer is
1879 * done at a given moment.
1881 static int lttng_event_notifier_group_notif_open(struct inode
*inode
, struct file
*file
)
1883 struct lttng_event_notifier_group
*event_notifier_group
= inode
->i_private
;
1884 struct lttng_kernel_ring_buffer
*buf
= event_notifier_group
->buf
;
1886 file
->private_data
= event_notifier_group
;
1887 return lib_ring_buffer_open(inode
, file
, buf
);
1891 * lttng_event_notifier_group_notif_release - event_notifier ring buffer release file operation
1892 * @inode: opened inode
1893 * @file: opened file
1895 * Release implementation.
1897 static int lttng_event_notifier_group_notif_release(struct inode
*inode
, struct file
*file
)
1899 struct lttng_event_notifier_group
*event_notifier_group
= file
->private_data
;
1900 struct lttng_kernel_ring_buffer
*buf
= event_notifier_group
->buf
;
1903 ret
= lib_ring_buffer_release(inode
, file
, buf
);
1906 fput(event_notifier_group
->file
);
1910 static const struct file_operations lttng_event_notifier_group_notif_fops
= {
1911 .owner
= THIS_MODULE
,
1912 .open
= lttng_event_notifier_group_notif_open
,
1913 .release
= lttng_event_notifier_group_notif_release
,
1914 .read
= lttng_event_notifier_group_notif_read
,
1915 .poll
= lttng_event_notifier_group_notif_poll
,
1919 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
1923 * Handles the poll operations for the metadata channels.
1926 unsigned int lttng_metadata_ring_buffer_poll(struct file
*filp
,
1929 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1930 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
1932 unsigned int mask
= 0;
1934 if (filp
->f_mode
& FMODE_READ
) {
1935 poll_wait_set_exclusive(wait
);
1936 poll_wait(filp
, &stream
->read_wait
, wait
);
1938 finalized
= stream
->finalized
;
1941 * lib_ring_buffer_is_finalized() contains a smp_rmb()
1942 * ordering finalized load before offsets loads.
1944 WARN_ON(atomic_long_read(&buf
->active_readers
) != 1);
1949 mutex_lock(&stream
->metadata_cache
->lock
);
1950 if (stream
->metadata_cache
->metadata_written
>
1951 stream
->metadata_out
)
1953 mutex_unlock(&stream
->metadata_cache
->lock
);
1960 void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file
*filp
,
1961 unsigned int cmd
, unsigned long arg
)
1963 struct lttng_metadata_stream
*stream
= filp
->private_data
;
1965 stream
->metadata_out
= stream
->metadata_in
;
1969 * Reset the counter of how much metadata has been consumed to 0. That way,
1970 * the consumer receives the content of the metadata cache unchanged. This is
1971 * different from the metadata_regenerate where the offset from epoch is
1972 * resampled, here we want the exact same content as the last time the metadata
1973 * was generated. This command is only possible if all the metadata written
1974 * in the cache has been output to the metadata stream to avoid corrupting the
1977 * Return 0 on success, a negative value on error.
1980 int lttng_metadata_cache_dump(struct lttng_metadata_stream
*stream
)
1983 struct lttng_metadata_cache
*cache
= stream
->metadata_cache
;
1985 mutex_lock(&cache
->lock
);
1986 if (stream
->metadata_out
!= cache
->metadata_written
) {
1990 stream
->metadata_out
= 0;
1991 stream
->metadata_in
= 0;
1992 wake_up_interruptible(&stream
->read_wait
);
1996 mutex_unlock(&cache
->lock
);
2001 long lttng_metadata_ring_buffer_ioctl(struct file
*filp
,
2002 unsigned int cmd
, unsigned long arg
)
2005 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2006 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2007 unsigned int rb_cmd
;
2010 if (cmd
== LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
)
2011 rb_cmd
= LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF
;
2016 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF
:
2018 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2019 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2020 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2022 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
2024 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
2030 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF
:
2033 * Random access is not allowed for metadata channel.
2037 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY
:
2039 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH
:
2041 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2042 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2043 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2046 * Before doing the actual ring buffer flush, write up to one
2047 * packet of metadata in the ring buffer.
2049 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
2054 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION
:
2056 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2058 return put_u64(stream
->version
, arg
);
2060 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP
:
2062 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2064 return lttng_metadata_cache_dump(stream
);
2066 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
2068 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2069 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2070 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2072 ret
= lttng_metadata_output_channel(stream
, chan
, &coherent
);
2074 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
2076 } else if (ret
< 0) {
2084 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2086 /* Performing lib ring buffer ioctl after our own. */
2087 ret
= lib_ring_buffer_ioctl(filp
, rb_cmd
, arg
, buf
);
2092 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF
:
2094 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp
,
2098 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
2100 return put_u32(coherent
, arg
);
2109 #ifdef CONFIG_COMPAT
2111 long lttng_metadata_ring_buffer_compat_ioctl(struct file
*filp
,
2112 unsigned int cmd
, unsigned long arg
)
2115 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2116 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2117 unsigned int rb_cmd
;
2120 if (cmd
== LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
)
2121 rb_cmd
= LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF
;
2126 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF
:
2128 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2129 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2130 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2132 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
2134 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
2140 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF
:
2143 * Random access is not allowed for metadata channel.
2147 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY
:
2149 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH
:
2151 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2152 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2153 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2156 * Before doing the actual ring buffer flush, write up to one
2157 * packet of metadata in the ring buffer.
2159 ret
= lttng_metadata_output_channel(stream
, chan
, NULL
);
2164 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION
:
2166 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2168 return put_u64(stream
->version
, arg
);
2170 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP
:
2172 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2174 return lttng_metadata_cache_dump(stream
);
2176 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
2178 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2179 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2180 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
2182 ret
= lttng_metadata_output_channel(stream
, chan
, &coherent
);
2184 lib_ring_buffer_switch_slow(buf
, SWITCH_ACTIVE
);
2186 } else if (ret
< 0) {
2194 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2196 /* Performing lib ring buffer ioctl after our own. */
2197 ret
= lib_ring_buffer_compat_ioctl(filp
, rb_cmd
, arg
, buf
);
2202 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF
:
2204 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp
,
2208 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
:
2210 return put_u32(coherent
, arg
);
2221 * This is not used by anonymous file descriptors. This code is left
2222 * there if we ever want to implement an inode with open() operation.
2225 int lttng_metadata_ring_buffer_open(struct inode
*inode
, struct file
*file
)
2227 struct lttng_metadata_stream
*stream
= inode
->i_private
;
2228 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2230 file
->private_data
= buf
;
2232 * Since life-time of metadata cache differs from that of
2233 * session, we need to keep our own reference on the transport.
2235 if (!try_module_get(stream
->transport
->owner
)) {
2236 printk(KERN_WARNING
"LTTng: Can't lock transport module.\n");
2239 return lib_ring_buffer_open(inode
, file
, buf
);
2243 int lttng_metadata_ring_buffer_release(struct inode
*inode
, struct file
*file
)
2245 struct lttng_metadata_stream
*stream
= file
->private_data
;
2246 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2248 mutex_lock(&stream
->metadata_cache
->lock
);
2249 list_del(&stream
->node
);
2250 mutex_unlock(&stream
->metadata_cache
->lock
);
2251 kref_put(&stream
->metadata_cache
->refcount
, metadata_cache_destroy
);
2252 module_put(stream
->transport
->owner
);
2254 return lib_ring_buffer_release(inode
, file
, buf
);
2258 ssize_t
lttng_metadata_ring_buffer_splice_read(struct file
*in
, loff_t
*ppos
,
2259 struct pipe_inode_info
*pipe
, size_t len
,
2262 struct lttng_metadata_stream
*stream
= in
->private_data
;
2263 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2265 return lib_ring_buffer_splice_read(in
, ppos
, pipe
, len
,
2270 int lttng_metadata_ring_buffer_mmap(struct file
*filp
,
2271 struct vm_area_struct
*vma
)
2273 struct lttng_metadata_stream
*stream
= filp
->private_data
;
2274 struct lttng_kernel_ring_buffer
*buf
= stream
->priv
;
2276 return lib_ring_buffer_mmap(filp
, vma
, buf
);
2280 const struct file_operations lttng_metadata_ring_buffer_file_operations
= {
2281 .owner
= THIS_MODULE
,
2282 .open
= lttng_metadata_ring_buffer_open
,
2283 .release
= lttng_metadata_ring_buffer_release
,
2284 .poll
= lttng_metadata_ring_buffer_poll
,
2285 .splice_read
= lttng_metadata_ring_buffer_splice_read
,
2286 .mmap
= lttng_metadata_ring_buffer_mmap
,
2287 .unlocked_ioctl
= lttng_metadata_ring_buffer_ioctl
,
2288 .llseek
= vfs_lib_ring_buffer_no_llseek
,
2289 #ifdef CONFIG_COMPAT
2290 .compat_ioctl
= lttng_metadata_ring_buffer_compat_ioctl
,
2295 int lttng_abi_create_stream_fd(struct file
*channel_file
, void *stream_priv
,
2296 const struct file_operations
*fops
, const char *name
)
2299 struct file
*stream_file
;
2301 stream_fd
= get_unused_fd_flags(0);
2302 if (stream_fd
< 0) {
2306 stream_file
= anon_inode_getfile(name
, fops
, stream_priv
, O_RDWR
);
2307 if (IS_ERR(stream_file
)) {
2308 ret
= PTR_ERR(stream_file
);
2312 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
2313 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
2314 * file descriptor, so we set FMODE_PREAD here.
2316 stream_file
->f_mode
|= FMODE_PREAD
;
2317 fd_install(stream_fd
, stream_file
);
2319 * The stream holds a reference to the channel within the generic ring
2320 * buffer library, so no need to hold a refcount on the channel and
2321 * session files here.
2326 put_unused_fd(stream_fd
);
2332 int lttng_abi_open_stream(struct file
*channel_file
)
2334 struct lttng_kernel_channel_buffer
*channel
= channel_file
->private_data
;
2335 struct lttng_kernel_ring_buffer
*buf
;
2339 buf
= channel
->ops
->priv
->buffer_read_open(channel
->priv
->rb_chan
);
2344 ret
= lttng_abi_create_stream_fd(channel_file
, stream_priv
,
2345 <tng_stream_ring_buffer_file_operations
,
2353 channel
->ops
->priv
->buffer_read_close(buf
);
2358 int lttng_abi_open_metadata_stream(struct file
*channel_file
)
2360 struct lttng_kernel_channel_buffer
*channel
= channel_file
->private_data
;
2361 struct lttng_kernel_session
*session
= channel
->parent
.session
;
2362 struct lttng_kernel_ring_buffer
*buf
;
2364 struct lttng_metadata_stream
*metadata_stream
;
2367 buf
= channel
->ops
->priv
->buffer_read_open(channel
->priv
->rb_chan
);
2371 metadata_stream
= kzalloc(sizeof(struct lttng_metadata_stream
),
2373 if (!metadata_stream
) {
2377 metadata_stream
->metadata_cache
= session
->priv
->metadata_cache
;
2378 init_waitqueue_head(&metadata_stream
->read_wait
);
2379 metadata_stream
->priv
= buf
;
2380 stream_priv
= metadata_stream
;
2381 metadata_stream
->transport
= channel
->priv
->transport
;
2382 /* Initial state is an empty metadata, considered as incoherent. */
2383 metadata_stream
->coherent
= false;
2386 * Since life-time of metadata cache differs from that of
2387 * session, we need to keep our own reference on the transport.
2389 if (!try_module_get(metadata_stream
->transport
->owner
)) {
2390 printk(KERN_WARNING
"LTTng: Can't lock transport module.\n");
2395 if (!lttng_kref_get(&session
->priv
->metadata_cache
->refcount
)) {
2400 ret
= lttng_abi_create_stream_fd(channel_file
, stream_priv
,
2401 <tng_metadata_ring_buffer_file_operations
,
2402 "[lttng_metadata_stream]");
2406 mutex_lock(&session
->priv
->metadata_cache
->lock
);
2407 list_add(&metadata_stream
->node
,
2408 &session
->priv
->metadata_cache
->metadata_stream
);
2409 mutex_unlock(&session
->priv
->metadata_cache
->lock
);
2413 kref_put(&session
->priv
->metadata_cache
->refcount
, metadata_cache_destroy
);
2415 module_put(metadata_stream
->transport
->owner
);
2417 kfree(metadata_stream
);
2419 channel
->ops
->priv
->buffer_read_close(buf
);
2424 int lttng_abi_open_event_notifier_group_stream(struct file
*notif_file
)
2426 struct lttng_event_notifier_group
*event_notifier_group
= notif_file
->private_data
;
2427 struct lttng_kernel_ring_buffer_channel
*chan
= event_notifier_group
->chan
;
2428 struct lttng_kernel_ring_buffer
*buf
;
2432 buf
= event_notifier_group
->ops
->priv
->buffer_read_open(chan
);
2436 /* The event_notifier notification fd holds a reference on the event_notifier group */
2437 if (!atomic_long_add_unless(¬if_file
->f_count
, 1, LONG_MAX
)) {
2439 goto refcount_error
;
2441 event_notifier_group
->buf
= buf
;
2442 stream_priv
= event_notifier_group
;
2443 ret
= lttng_abi_create_stream_fd(notif_file
, stream_priv
,
2444 <tng_event_notifier_group_notif_fops
,
2445 "[lttng_event_notifier_stream]");
2452 atomic_long_dec(¬if_file
->f_count
);
2454 event_notifier_group
->ops
->priv
->buffer_read_close(buf
);
2459 int lttng_abi_validate_event_param(struct lttng_kernel_abi_event
*event_param
,
2460 struct lttng_kernel_abi_event_ext
*event_param_ext
)
2462 enum lttng_kernel_abi_match_check match_check
;
2464 if (user_event_param_ext_get_match_check(event_param_ext
, &match_check
))
2467 /* Limit ABI to implemented features. */
2468 switch (event_param
->instrumentation
) {
2469 case LTTNG_KERNEL_ABI_SYSCALL
:
2470 switch (event_param
->u
.syscall
.entryexit
) {
2471 case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
:
2473 case LTTNG_KERNEL_ABI_SYSCALL_ENTRY
:
2475 case LTTNG_KERNEL_ABI_SYSCALL_EXIT
:
2480 switch (event_param
->u
.syscall
.abi
) {
2481 case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL
:
2486 switch (event_param
->u
.syscall
.match
) {
2487 case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME
:
2492 switch (match_check
) {
2493 case LTTNG_KERNEL_ABI_MATCH_DEFAULT
:
2495 case LTTNG_KERNEL_ABI_MATCH_LAZY
:
2502 case LTTNG_KERNEL_ABI_KRETPROBE
:
2503 switch (event_param
->u
.kretprobe
.entryexit
) {
2504 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRYEXIT
:
2506 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRY
:
2508 case LTTNG_KERNEL_ABI_KRETPROBE_EXIT
:
2513 switch (match_check
) {
2514 case LTTNG_KERNEL_ABI_MATCH_DEFAULT
:
2516 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE
:
2523 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2524 switch (match_check
) {
2525 case LTTNG_KERNEL_ABI_MATCH_DEFAULT
:
2527 case LTTNG_KERNEL_ABI_MATCH_LAZY
:
2534 case LTTNG_KERNEL_ABI_KPROBE
:
2536 case LTTNG_KERNEL_ABI_UPROBE
:
2537 switch (match_check
) {
2538 case LTTNG_KERNEL_ABI_MATCH_DEFAULT
:
2540 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE
:
2547 case LTTNG_KERNEL_ABI_FUNCTION
:
2549 case LTTNG_KERNEL_ABI_NOOP
:
2558 int lttng_abi_validate_event_match(struct lttng_kernel_abi_event
*event_param
,
2559 struct lttng_kernel_abi_event_ext
*event_param_ext
)
2561 enum lttng_kernel_abi_match_check match_check
;
2564 if (user_event_param_ext_get_match_check(event_param_ext
, &match_check
))
2567 /* Validate match */
2568 if (match_check
== LTTNG_KERNEL_ABI_MATCH_DEFAULT
) {
2569 switch (event_param
->instrumentation
) {
2570 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2572 case LTTNG_KERNEL_ABI_SYSCALL
:
2573 match_check
= LTTNG_KERNEL_ABI_MATCH_LAZY
;
2575 case LTTNG_KERNEL_ABI_KPROBE
:
2577 case LTTNG_KERNEL_ABI_KRETPROBE
:
2579 case LTTNG_KERNEL_ABI_UPROBE
:
2580 match_check
= LTTNG_KERNEL_ABI_MATCH_IMMEDIATE
;
2583 case LTTNG_KERNEL_ABI_FUNCTION
:
2585 case LTTNG_KERNEL_ABI_NOOP
:
2592 if (match_check
== LTTNG_KERNEL_ABI_MATCH_IMMEDIATE
) {
2593 switch (event_param
->instrumentation
) {
2595 case LTTNG_KERNEL_ABI_KPROBE
:
2596 ret
= lttng_kprobes_match_check(event_param
->u
.kprobe
.symbol_name
,
2597 event_param
->u
.kprobe
.offset
,
2598 event_param
->u
.kprobe
.addr
);
2602 case LTTNG_KERNEL_ABI_KRETPROBE
:
2603 ret
= lttng_kretprobes_match_check(event_param
->u
.kretprobe
.symbol_name
,
2604 event_param
->u
.kretprobe
.offset
,
2605 event_param
->u
.kretprobe
.addr
);
2609 case LTTNG_KERNEL_ABI_UPROBE
:
2611 * uprobes are immediately created, which includes match checking.
2615 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2617 case LTTNG_KERNEL_ABI_SYSCALL
:
2619 case LTTNG_KERNEL_ABI_FUNCTION
:
2621 case LTTNG_KERNEL_ABI_NOOP
:
2631 int lttng_abi_create_event_recorder_enabler(struct file
*channel_file
,
2632 struct lttng_kernel_abi_event
*event_param
,
2633 struct lttng_kernel_abi_event_ext
*event_param_ext
)
2635 const struct file_operations
*fops
;
2636 struct lttng_kernel_channel_buffer
*channel
= channel_file
->private_data
;
2638 struct file
*event_file
;
2641 event_param
->name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2642 switch (event_param
->instrumentation
) {
2643 case LTTNG_KERNEL_ABI_KRETPROBE
:
2644 event_param
->u
.kretprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2646 case LTTNG_KERNEL_ABI_KPROBE
:
2647 event_param
->u
.kprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2649 case LTTNG_KERNEL_ABI_FUNCTION
:
2651 /* Not implemented. */
2657 switch (event_param
->instrumentation
) {
2658 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2660 case LTTNG_KERNEL_ABI_SYSCALL
:
2662 case LTTNG_KERNEL_ABI_KPROBE
:
2664 case LTTNG_KERNEL_ABI_KRETPROBE
:
2665 fops
= <tng_event_session_enabler_fops
;
2668 case LTTNG_KERNEL_ABI_UPROBE
:
2669 fops
= <tng_event_session_fops
;
2672 case LTTNG_KERNEL_ABI_FUNCTION
:
2674 case LTTNG_KERNEL_ABI_NOOP
:
2680 event_fd
= get_unused_fd_flags(0);
2685 event_file
= anon_inode_getfile("[lttng_event_recorder]",
2686 fops
, NULL
, O_RDWR
);
2687 if (IS_ERR(event_file
)) {
2688 ret
= PTR_ERR(event_file
);
2691 /* The event holds a reference on the channel */
2692 if (!atomic_long_add_unless(&channel_file
->f_count
, 1, LONG_MAX
)) {
2694 goto refcount_error
;
2696 ret
= lttng_abi_validate_event_param(event_param
, event_param_ext
);
2699 ret
= lttng_abi_validate_event_match(event_param
, event_param_ext
);
2703 switch (event_param
->instrumentation
) {
2704 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2706 case LTTNG_KERNEL_ABI_SYSCALL
:
2708 struct lttng_event_recorder_enabler
*event_enabler
;
2710 if (strutils_is_star_glob_pattern(event_param
->name
)) {
2712 * If the event name is a star globbing pattern,
2713 * we create the special star globbing enabler.
2715 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB
,
2716 event_param
, channel
);
2718 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2719 event_param
, channel
);
2722 lttng_event_enabler_session_add(channel
->parent
.session
, &event_enabler
->parent
);
2723 priv
= event_enabler
;
2727 case LTTNG_KERNEL_ABI_KPROBE
:
2729 case LTTNG_KERNEL_ABI_KRETPROBE
:
2731 struct lttng_event_recorder_enabler
*event_enabler
;
2733 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2734 event_param
, channel
);
2736 lttng_event_enabler_session_add(channel
->parent
.session
, &event_enabler
->parent
);
2737 priv
= event_enabler
;
2741 case LTTNG_KERNEL_ABI_UPROBE
:
2743 struct lttng_kernel_event_common
*event
;
2744 struct lttng_event_recorder_enabler
*event_enabler
;
2746 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2747 event_param
, channel
);
2748 if (!event_enabler
) {
2753 * We tolerate no failure path after event creation. It
2754 * will stay invariant for the rest of the session.
2756 event
= lttng_kernel_event_create(&event_enabler
->parent
.parent
, NULL
, NULL
);
2757 lttng_event_enabler_destroy(&event_enabler
->parent
.parent
);
2758 if (IS_ERR(event
)) {
2759 ret
= PTR_ERR(event
);
2766 case LTTNG_KERNEL_ABI_FUNCTION
:
2768 case LTTNG_KERNEL_ABI_NOOP
:
2774 event_file
->private_data
= priv
;
2775 fd_install(event_fd
, event_file
);
2779 atomic_long_dec(&channel_file
->f_count
);
2783 put_unused_fd(event_fd
);
2789 int lttng_abi_create_event_counter_enabler(struct file
*channel_file
,
2790 struct lttng_kernel_counter_event
*counter_event
)
2792 const struct file_operations
*fops
;
2793 struct lttng_kernel_channel_counter
*channel
= channel_file
->private_data
;
2794 struct lttng_kernel_abi_event
*event_param
= &counter_event
->event_param
;
2795 struct lttng_kernel_abi_event_ext
*event_param_ext
= &counter_event
->event_param_ext
;
2796 struct lttng_kernel_counter_key
*counter_key
= counter_event
->counter_key
;
2798 struct file
*event_file
;
2801 event_param
->name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2802 switch (event_param
->instrumentation
) {
2803 case LTTNG_KERNEL_ABI_KRETPROBE
:
2804 event_param
->u
.kretprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2806 case LTTNG_KERNEL_ABI_KPROBE
:
2807 event_param
->u
.kprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
2809 case LTTNG_KERNEL_ABI_FUNCTION
:
2811 /* Not implemented. */
2817 switch (event_param
->instrumentation
) {
2818 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2820 case LTTNG_KERNEL_ABI_SYSCALL
:
2822 case LTTNG_KERNEL_ABI_KPROBE
:
2824 case LTTNG_KERNEL_ABI_KRETPROBE
:
2825 fops
= <tng_event_session_enabler_fops
;
2828 case LTTNG_KERNEL_ABI_UPROBE
:
2829 fops
= <tng_event_session_fops
;
2832 case LTTNG_KERNEL_ABI_FUNCTION
:
2834 case LTTNG_KERNEL_ABI_NOOP
:
2840 event_fd
= get_unused_fd_flags(0);
2845 event_file
= anon_inode_getfile("[lttng_event_counter]",
2846 fops
, NULL
, O_RDWR
);
2847 if (IS_ERR(event_file
)) {
2848 ret
= PTR_ERR(event_file
);
2851 /* The event holds a reference on the channel */
2852 if (!atomic_long_add_unless(&channel_file
->f_count
, 1, LONG_MAX
)) {
2854 goto refcount_error
;
2856 ret
= lttng_abi_validate_event_param(event_param
, event_param_ext
);
2859 ret
= lttng_abi_validate_event_match(event_param
, event_param_ext
);
2863 switch (event_param
->instrumentation
) {
2864 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2866 case LTTNG_KERNEL_ABI_SYSCALL
:
2868 struct lttng_event_counter_enabler
*event_enabler
;
2870 if (strutils_is_star_glob_pattern(event_param
->name
)) {
2872 * If the event name is a star globbing pattern,
2873 * we create the special star globbing enabler.
2875 event_enabler
= lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB
,
2876 event_param
, counter_key
, channel
);
2878 event_enabler
= lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2879 event_param
, counter_key
, channel
);
2882 lttng_event_enabler_session_add(channel
->parent
.session
, &event_enabler
->parent
);
2883 priv
= event_enabler
;
2887 case LTTNG_KERNEL_ABI_KPROBE
:
2889 case LTTNG_KERNEL_ABI_KRETPROBE
:
2891 struct lttng_event_counter_enabler
*event_enabler
;
2893 event_enabler
= lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2894 event_param
, counter_key
, channel
);
2896 lttng_event_enabler_session_add(channel
->parent
.session
, &event_enabler
->parent
);
2897 priv
= event_enabler
;
2901 case LTTNG_KERNEL_ABI_UPROBE
:
2903 struct lttng_kernel_event_common
*event
;
2904 struct lttng_event_counter_enabler
*event_enabler
;
2906 event_enabler
= lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
2907 event_param
, counter_key
, channel
);
2908 if (!event_enabler
) {
2913 * We tolerate no failure path after event creation. It
2914 * will stay invariant for the rest of the session.
2916 event
= lttng_kernel_event_create(&event_enabler
->parent
.parent
, NULL
, NULL
);
2917 lttng_event_enabler_destroy(&event_enabler
->parent
.parent
);
2918 if (IS_ERR(event
)) {
2919 ret
= PTR_ERR(event
);
2926 case LTTNG_KERNEL_ABI_FUNCTION
:
2928 case LTTNG_KERNEL_ABI_NOOP
:
2934 event_file
->private_data
= priv
;
2935 fd_install(event_fd
, event_file
);
2939 atomic_long_dec(&channel_file
->f_count
);
2943 put_unused_fd(event_fd
);
2949 long lttng_event_notifier_event_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2951 struct lttng_kernel_event_common
*event
= file
->private_data
;
2954 case LTTNG_KERNEL_ABI_ENABLE
:
2955 return lttng_event_enable(event
);
2956 case LTTNG_KERNEL_ABI_DISABLE
:
2957 return lttng_event_disable(event
);
2958 case LTTNG_KERNEL_ABI_FILTER
:
2960 case LTTNG_KERNEL_ABI_CAPTURE
:
2962 case LTTNG_KERNEL_ABI_ADD_CALLSITE
:
2963 return lttng_event_add_callsite(event
,
2964 (struct lttng_kernel_abi_event_callsite __user
*) arg
);
2966 return -ENOIOCTLCMD
;
2971 long lttng_event_notifier_enabler_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2973 struct lttng_event_enabler_common
*event
= file
->private_data
;
2976 case LTTNG_KERNEL_ABI_ENABLE
:
2977 return lttng_event_enabler_enable(event
);
2978 case LTTNG_KERNEL_ABI_DISABLE
:
2979 return lttng_event_enabler_disable(event
);
2980 case LTTNG_KERNEL_ABI_FILTER
:
2981 return lttng_event_enabler_attach_filter_bytecode(event
,
2982 (struct lttng_kernel_abi_filter_bytecode __user
*) arg
);
2983 case LTTNG_KERNEL_ABI_CAPTURE
:
2985 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2986 container_of(event
, struct lttng_event_notifier_enabler
, parent
);
2987 return lttng_event_notifier_enabler_attach_capture_bytecode(
2988 event_notifier_enabler
,
2989 (struct lttng_kernel_abi_capture_bytecode __user
*) arg
);
2991 case LTTNG_KERNEL_ABI_ADD_CALLSITE
:
2994 return -ENOIOCTLCMD
;
2999 int lttng_event_notifier_event_release(struct inode
*inode
, struct file
*file
)
3001 struct lttng_kernel_event_common
*event
= file
->private_data
;
3004 struct lttng_kernel_event_notifier
*event_notifier
=
3005 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
3006 fput(event_notifier
->priv
->group
->file
);
3012 int lttng_event_notifier_enabler_release(struct inode
*inode
, struct file
*file
)
3014 struct lttng_event_enabler_common
*event_enabler
= file
->private_data
;
3016 if (event_enabler
) {
3017 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
3018 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
3019 fput(event_notifier_enabler
->group
->file
);
3024 static const struct file_operations lttng_event_notifier_event_fops
= {
3025 .owner
= THIS_MODULE
,
3026 .release
= lttng_event_notifier_event_release
,
3027 .unlocked_ioctl
= lttng_event_notifier_event_ioctl
,
3028 #ifdef CONFIG_COMPAT
3029 .compat_ioctl
= lttng_event_notifier_event_ioctl
,
3033 static const struct file_operations lttng_event_notifier_enabler_fops
= {
3034 .owner
= THIS_MODULE
,
3035 .release
= lttng_event_notifier_enabler_release
,
3036 .unlocked_ioctl
= lttng_event_notifier_enabler_ioctl
,
3037 #ifdef CONFIG_COMPAT
3038 .compat_ioctl
= lttng_event_notifier_enabler_ioctl
,
3043 int lttng_abi_create_event_notifier(struct file
*event_notifier_group_file
,
3044 struct lttng_kernel_abi_event_notifier
*event_notifier_param
,
3045 struct lttng_kernel_abi_event_ext
*event_param_ext
)
3047 struct lttng_event_notifier_group
*event_notifier_group
=
3048 event_notifier_group_file
->private_data
;
3049 const struct file_operations
*fops
;
3050 int event_notifier_fd
, ret
;
3051 struct file
*event_notifier_file
;
3054 switch (event_notifier_param
->event
.instrumentation
) {
3055 case LTTNG_KERNEL_ABI_TRACEPOINT
:
3057 case LTTNG_KERNEL_ABI_SYSCALL
:
3059 case LTTNG_KERNEL_ABI_KPROBE
:
3061 case LTTNG_KERNEL_ABI_KRETPROBE
:
3062 fops
= <tng_event_notifier_enabler_fops
;
3065 case LTTNG_KERNEL_ABI_UPROBE
:
3066 fops
= <tng_event_notifier_event_fops
;
3069 case LTTNG_KERNEL_ABI_FUNCTION
:
3071 case LTTNG_KERNEL_ABI_NOOP
:
3078 event_notifier_param
->event
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
3079 switch (event_notifier_param
->event
.instrumentation
) {
3080 case LTTNG_KERNEL_ABI_KRETPROBE
:
3081 event_notifier_param
->event
.u
.kretprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
3083 case LTTNG_KERNEL_ABI_KPROBE
:
3084 event_notifier_param
->event
.u
.kprobe
.symbol_name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
3090 event_notifier_fd
= get_unused_fd_flags(0);
3091 if (event_notifier_fd
< 0) {
3092 ret
= event_notifier_fd
;
3096 event_notifier_file
= anon_inode_getfile("[lttng_event_notifier]",
3097 fops
, NULL
, O_RDWR
);
3098 if (IS_ERR(event_notifier_file
)) {
3099 ret
= PTR_ERR(event_notifier_file
);
3103 /* The event notifier holds a reference on the event notifier group. */
3104 if (!atomic_long_add_unless(&event_notifier_group_file
->f_count
, 1, LONG_MAX
)) {
3106 goto refcount_error
;
3109 ret
= lttng_abi_validate_event_param(&event_notifier_param
->event
, event_param_ext
);
3111 goto event_notifier_error
;
3112 ret
= lttng_abi_validate_event_match(&event_notifier_param
->event
, event_param_ext
);
3114 goto event_notifier_error
;
3116 switch (event_notifier_param
->event
.instrumentation
) {
3117 case LTTNG_KERNEL_ABI_TRACEPOINT
:
3119 case LTTNG_KERNEL_ABI_SYSCALL
:
3121 struct lttng_event_notifier_enabler
*enabler
;
3123 if (strutils_is_star_glob_pattern(event_notifier_param
->event
.name
)) {
3125 * If the event name is a star globbing pattern,
3126 * we create the special star globbing enabler.
3128 enabler
= lttng_event_notifier_enabler_create(
3129 LTTNG_ENABLER_FORMAT_STAR_GLOB
,
3130 event_notifier_param
,
3131 event_notifier_group
);
3133 enabler
= lttng_event_notifier_enabler_create(
3134 LTTNG_ENABLER_FORMAT_NAME
,
3135 event_notifier_param
,
3136 event_notifier_group
);
3139 lttng_event_notifier_enabler_group_add(event_notifier_group
, enabler
);
3144 case LTTNG_KERNEL_ABI_KPROBE
:
3146 case LTTNG_KERNEL_ABI_KRETPROBE
:
3148 struct lttng_event_notifier_enabler
*enabler
;
3150 enabler
= lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
3151 event_notifier_param
, event_notifier_group
);
3153 lttng_event_notifier_enabler_group_add(event_notifier_group
, enabler
);
3158 case LTTNG_KERNEL_ABI_UPROBE
:
3160 struct lttng_kernel_event_common
*event
;
3161 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
3163 event_notifier_enabler
= lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
3164 event_notifier_param
, event_notifier_group
);
3165 if (!event_notifier_enabler
) {
3167 goto event_notifier_error
;
3169 event
= lttng_kernel_event_create(&event_notifier_enabler
->parent
, NULL
, NULL
);
3170 lttng_event_enabler_destroy(&event_notifier_enabler
->parent
);
3171 if (IS_ERR(event
)) {
3172 ret
= PTR_ERR(event
);
3173 goto event_notifier_error
;
3179 case LTTNG_KERNEL_ABI_FUNCTION
:
3181 case LTTNG_KERNEL_ABI_NOOP
:
3185 goto event_notifier_error
;
3187 event_notifier_file
->private_data
= priv
;
3188 fd_install(event_notifier_fd
, event_notifier_file
);
3189 return event_notifier_fd
;
3191 event_notifier_error
:
3192 atomic_long_dec(&event_notifier_group_file
->f_count
);
3194 fput(event_notifier_file
);
3196 put_unused_fd(event_notifier_fd
);
3203 long lttng_abi_session_create_counter(
3204 struct lttng_kernel_session
*session
,
3205 const struct lttng_kernel_counter_conf
*counter_conf
)
3207 int counter_fd
, ret
;
3208 char *counter_transport_name
;
3209 struct lttng_kernel_channel_counter
*chan_counter
= NULL
;
3210 struct file
*counter_file
;
3212 if (counter_conf
->arithmetic
!= LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR
) {
3213 printk(KERN_ERR
"LTTng: Maps: Counter of the wrong arithmetic type.\n");
3217 switch (counter_conf
->bitness
) {
3218 case LTTNG_KERNEL_COUNTER_BITNESS_64
:
3219 counter_transport_name
= "counter-per-cpu-64-modular";
3221 case LTTNG_KERNEL_COUNTER_BITNESS_32
:
3222 counter_transport_name
= "counter-per-cpu-32-modular";
3228 lttng_lock_sessions();
3230 counter_fd
= get_unused_fd_flags(0);
3231 if (counter_fd
< 0) {
3236 counter_file
= anon_inode_getfile("[lttng_counter]",
3237 <tng_counter_fops
,
3239 if (IS_ERR(counter_file
)) {
3240 ret
= PTR_ERR(counter_file
);
3244 if (!atomic_long_add_unless(&session
->priv
->file
->f_count
, 1, LONG_MAX
)) {
3246 goto refcount_error
;
3249 chan_counter
= lttng_kernel_counter_create(counter_transport_name
, 1, counter_conf
->dimension_array
, 0,
3250 counter_conf
->flags
& LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS
);
3251 if (!chan_counter
) {
3256 chan_counter
->priv
->parent
.file
= counter_file
;
3257 chan_counter
->priv
->owner
= session
->priv
->file
;
3258 chan_counter
->parent
.session
= session
;
3259 list_add(&chan_counter
->priv
->parent
.node
, &session
->priv
->chan_head
);
3260 counter_file
->private_data
= chan_counter
;
3262 fd_install(counter_fd
, counter_file
);
3263 lttng_unlock_sessions();
3268 atomic_long_dec(&session
->priv
->file
->f_count
);
3272 put_unused_fd(counter_fd
);
3274 lttng_unlock_sessions();
3279 long lttng_abi_event_notifier_group_create_error_counter(
3280 struct file
*event_notifier_group_file
,
3281 const struct lttng_kernel_counter_conf
*counter_conf
)
3283 int counter_fd
, ret
;
3284 char *counter_transport_name
;
3285 struct lttng_kernel_channel_counter
*chan_counter
= NULL
;
3286 struct file
*counter_file
;
3287 struct lttng_event_notifier_group
*event_notifier_group
=
3288 (struct lttng_event_notifier_group
*) event_notifier_group_file
->private_data
;
3291 if (counter_conf
->arithmetic
!= LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR
) {
3292 printk(KERN_ERR
"LTTng: event_notifier: Error counter of the wrong arithmetic type.\n");
3296 switch (counter_conf
->bitness
) {
3297 case LTTNG_KERNEL_COUNTER_BITNESS_64
:
3298 counter_transport_name
= "counter-per-cpu-64-modular";
3300 case LTTNG_KERNEL_COUNTER_BITNESS_32
:
3301 counter_transport_name
= "counter-per-cpu-32-modular";
3308 * Lock sessions to provide mutual exclusion against concurrent
3309 * modification of event_notifier group, which would result in
3310 * overwriting the error counter if set concurrently.
3312 lttng_lock_sessions();
3314 if (event_notifier_group
->error_counter
) {
3315 printk(KERN_ERR
"Error counter already created in event_notifier group\n");
3320 counter_fd
= get_unused_fd_flags(0);
3321 if (counter_fd
< 0) {
3326 counter_file
= anon_inode_getfile("[lttng_counter]",
3327 <tng_counter_fops
,
3329 if (IS_ERR(counter_file
)) {
3330 ret
= PTR_ERR(counter_file
);
3334 if (!atomic_long_add_unless(&event_notifier_group_file
->f_count
, 1, LONG_MAX
)) {
3336 goto refcount_error
;
3339 counter_len
= counter_conf
->dimension_array
[0].size
;
3340 chan_counter
= lttng_kernel_counter_create(counter_transport_name
, 1, counter_conf
->dimension_array
, 0, false);
3341 if (!chan_counter
) {
3346 chan_counter
->priv
->parent
.file
= counter_file
;
3347 chan_counter
->priv
->owner
= event_notifier_group
->file
;
3348 counter_file
->private_data
= chan_counter
;
3349 event_notifier_group
->error_counter_len
= counter_len
;
3351 * store-release to publish error counter matches load-acquire
3352 * in record_error. Ensures the counter is created and the
3353 * error_counter_len is set before they are used.
3355 smp_store_release(&event_notifier_group
->error_counter
,
3358 fd_install(counter_fd
, counter_file
);
3359 lttng_unlock_sessions();
3364 atomic_long_dec(&event_notifier_group_file
->f_count
);
3368 put_unused_fd(counter_fd
);
3370 lttng_unlock_sessions();
3375 long lttng_event_notifier_group_ioctl(struct file
*file
, unsigned int cmd
,
3381 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD
:
3383 return lttng_abi_open_event_notifier_group_stream(file
);
3385 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_CREATE
:
3387 struct lttng_kernel_abi_event_notifier uevent_notifier_param
;
3388 struct lttng_kernel_abi_event_ext uevent_param_ext
= {};
3391 if (copy_from_user(&uevent_notifier_param
,
3392 (struct lttng_kernel_abi_event_notifier __user
*) arg
,
3393 sizeof(uevent_notifier_param
)))
3395 ret
= copy_user_event_param_ext(&uevent_param_ext
, &uevent_notifier_param
.event
);
3398 return lttng_abi_create_event_notifier(file
, &uevent_notifier_param
, &uevent_param_ext
);
3400 case LTTNG_KERNEL_ABI_OLD_COUNTER
:
3402 struct lttng_kernel_counter_conf counter_conf
;
3404 ret
= lttng_abi_copy_user_old_counter_conf(&counter_conf
,
3405 (struct lttng_kernel_abi_old_counter_conf __user
*) arg
);
3408 return lttng_abi_event_notifier_group_create_error_counter(file
, &counter_conf
);
3410 case LTTNG_KERNEL_ABI_COUNTER
:
3412 struct lttng_kernel_counter_conf counter_conf
;
3414 ret
= lttng_abi_copy_user_counter_conf(&counter_conf
,
3415 (struct lttng_kernel_abi_counter_conf __user
*) arg
);
3418 return lttng_abi_event_notifier_group_create_error_counter(file
, &counter_conf
);
3421 return -ENOIOCTLCMD
;
3427 int lttng_event_notifier_group_release(struct inode
*inode
, struct file
*file
)
3429 struct lttng_event_notifier_group
*event_notifier_group
=
3432 if (event_notifier_group
)
3433 lttng_event_notifier_group_destroy(event_notifier_group
);
3437 static const struct file_operations lttng_event_notifier_group_fops
= {
3438 .owner
= THIS_MODULE
,
3439 .release
= lttng_event_notifier_group_release
,
3440 .unlocked_ioctl
= lttng_event_notifier_group_ioctl
,
3441 #ifdef CONFIG_COMPAT
3442 .compat_ioctl
= lttng_event_notifier_group_ioctl
,
3447 * lttng_channel_ioctl - lttng syscall through ioctl
3453 * This ioctl implements lttng commands:
3454 * LTTNG_KERNEL_ABI_STREAM
3455 * Returns an event stream file descriptor or failure.
3456 * (typically, one event stream records events from one CPU)
3457 * LTTNG_KERNEL_ABI_EVENT
3458 * Returns an event file descriptor or failure.
3459 * LTTNG_KERNEL_ABI_CONTEXT
3460 * Prepend a context field to each event in the channel
3461 * LTTNG_KERNEL_ABI_ENABLE
3462 * Enable recording for events in this channel (weak enable)
3463 * LTTNG_KERNEL_ABI_DISABLE
3464 * Disable recording for events in this channel (strong disable)
3466 * Channel and event file descriptors also hold a reference on the session.
3469 long lttng_channel_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3471 struct lttng_kernel_channel_buffer
*channel
= file
->private_data
;
3474 case LTTNG_KERNEL_ABI_OLD_STREAM
:
3475 case LTTNG_KERNEL_ABI_STREAM
:
3476 return lttng_abi_open_stream(file
);
3477 case LTTNG_KERNEL_ABI_OLD_EVENT
:
3479 struct lttng_kernel_abi_event
*uevent_param
;
3480 struct lttng_kernel_abi_old_event
*old_uevent_param
;
3483 uevent_param
= kmalloc(sizeof(struct lttng_kernel_abi_event
),
3485 if (!uevent_param
) {
3489 old_uevent_param
= kmalloc(
3490 sizeof(struct lttng_kernel_abi_old_event
),
3492 if (!old_uevent_param
) {
3494 goto old_event_error_free_param
;
3496 if (copy_from_user(old_uevent_param
,
3497 (struct lttng_kernel_abi_old_event __user
*) arg
,
3498 sizeof(struct lttng_kernel_abi_old_event
))) {
3500 goto old_event_error_free_old_param
;
3503 memcpy(uevent_param
->name
, old_uevent_param
->name
,
3504 sizeof(uevent_param
->name
));
3505 uevent_param
->instrumentation
=
3506 old_uevent_param
->instrumentation
;
3508 switch (old_uevent_param
->instrumentation
) {
3509 case LTTNG_KERNEL_ABI_KPROBE
:
3510 uevent_param
->u
.kprobe
.addr
=
3511 old_uevent_param
->u
.kprobe
.addr
;
3512 uevent_param
->u
.kprobe
.offset
=
3513 old_uevent_param
->u
.kprobe
.offset
;
3514 memcpy(uevent_param
->u
.kprobe
.symbol_name
,
3515 old_uevent_param
->u
.kprobe
.symbol_name
,
3516 sizeof(uevent_param
->u
.kprobe
.symbol_name
));
3518 case LTTNG_KERNEL_ABI_KRETPROBE
:
3519 uevent_param
->u
.kretprobe
.addr
=
3520 old_uevent_param
->u
.kretprobe
.addr
;
3521 uevent_param
->u
.kretprobe
.offset
=
3522 old_uevent_param
->u
.kretprobe
.offset
;
3523 memcpy(uevent_param
->u
.kretprobe
.symbol_name
,
3524 old_uevent_param
->u
.kretprobe
.symbol_name
,
3525 sizeof(uevent_param
->u
.kretprobe
.symbol_name
));
3527 case LTTNG_KERNEL_ABI_FUNCTION
:
3529 /* Not implemented. */
3534 ret
= lttng_abi_create_event_recorder_enabler(file
, uevent_param
, NULL
);
3536 old_event_error_free_old_param
:
3537 kfree(old_uevent_param
);
3538 old_event_error_free_param
:
3539 kfree(uevent_param
);
3543 case LTTNG_KERNEL_ABI_EVENT
:
3545 struct lttng_kernel_abi_event uevent_param
;
3546 struct lttng_kernel_abi_event_ext uevent_param_ext
= {};
3549 if (copy_from_user(&uevent_param
,
3550 (struct lttng_kernel_abi_event __user
*) arg
,
3551 sizeof(uevent_param
)))
3553 ret
= copy_user_event_param_ext(&uevent_param_ext
, &uevent_param
);
3556 return lttng_abi_create_event_recorder_enabler(file
, &uevent_param
, &uevent_param_ext
);
3558 case LTTNG_KERNEL_ABI_OLD_CONTEXT
:
3560 struct lttng_kernel_abi_context
*ucontext_param
;
3561 struct lttng_kernel_abi_old_context
*old_ucontext_param
;
3564 ucontext_param
= kmalloc(sizeof(struct lttng_kernel_abi_context
),
3566 if (!ucontext_param
) {
3570 old_ucontext_param
= kmalloc(sizeof(struct lttng_kernel_abi_old_context
),
3572 if (!old_ucontext_param
) {
3574 goto old_ctx_error_free_param
;
3577 if (copy_from_user(old_ucontext_param
,
3578 (struct lttng_kernel_abi_old_context __user
*) arg
,
3579 sizeof(struct lttng_kernel_abi_old_context
))) {
3581 goto old_ctx_error_free_old_param
;
3583 ucontext_param
->ctx
= old_ucontext_param
->ctx
;
3584 memcpy(ucontext_param
->padding
, old_ucontext_param
->padding
,
3585 sizeof(ucontext_param
->padding
));
3586 /* only type that uses the union */
3587 if (old_ucontext_param
->ctx
== LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER
) {
3588 ucontext_param
->u
.perf_counter
.type
=
3589 old_ucontext_param
->u
.perf_counter
.type
;
3590 ucontext_param
->u
.perf_counter
.config
=
3591 old_ucontext_param
->u
.perf_counter
.config
;
3592 memcpy(ucontext_param
->u
.perf_counter
.name
,
3593 old_ucontext_param
->u
.perf_counter
.name
,
3594 sizeof(ucontext_param
->u
.perf_counter
.name
));
3597 ret
= lttng_abi_add_context(file
,
3599 &channel
->priv
->ctx
, channel
->parent
.session
);
3601 old_ctx_error_free_old_param
:
3602 kfree(old_ucontext_param
);
3603 old_ctx_error_free_param
:
3604 kfree(ucontext_param
);
3608 case LTTNG_KERNEL_ABI_CONTEXT
:
3610 struct lttng_kernel_abi_context ucontext_param
;
3612 if (copy_from_user(&ucontext_param
,
3613 (struct lttng_kernel_abi_context __user
*) arg
,
3614 sizeof(ucontext_param
)))
3616 return lttng_abi_add_context(file
,
3618 &channel
->priv
->ctx
, channel
->parent
.session
);
3620 case LTTNG_KERNEL_ABI_OLD_ENABLE
:
3621 case LTTNG_KERNEL_ABI_ENABLE
:
3622 return lttng_channel_enable(&channel
->parent
);
3623 case LTTNG_KERNEL_ABI_OLD_DISABLE
:
3624 case LTTNG_KERNEL_ABI_DISABLE
:
3625 return lttng_channel_disable(&channel
->parent
);
3626 case LTTNG_KERNEL_ABI_SYSCALL_MASK
:
3627 return lttng_syscall_table_get_active_mask(&channel
->priv
->parent
.syscall_table
,
3628 (struct lttng_kernel_abi_syscall_mask __user
*) arg
);
3630 return -ENOIOCTLCMD
;
3635 * lttng_metadata_ioctl - lttng syscall through ioctl
3641 * This ioctl implements lttng commands:
3642 * LTTNG_KERNEL_ABI_STREAM
3643 * Returns an event stream file descriptor or failure.
3645 * Channel and event file descriptors also hold a reference on the session.
3648 long lttng_metadata_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3651 case LTTNG_KERNEL_ABI_OLD_STREAM
:
3652 case LTTNG_KERNEL_ABI_STREAM
:
3653 return lttng_abi_open_metadata_stream(file
);
3655 return -ENOIOCTLCMD
;
3660 * lttng_channel_poll - lttng stream addition/removal monitoring
3666 unsigned int lttng_channel_poll(struct file
*file
, poll_table
*wait
)
3668 struct lttng_kernel_channel_buffer
*channel
= file
->private_data
;
3669 unsigned int mask
= 0;
3671 if (file
->f_mode
& FMODE_READ
) {
3672 poll_wait_set_exclusive(wait
);
3673 poll_wait(file
, channel
->ops
->priv
->get_hp_wait_queue(channel
->priv
->rb_chan
),
3676 if (channel
->ops
->priv
->is_disabled(channel
->priv
->rb_chan
))
3678 if (channel
->ops
->priv
->is_finalized(channel
->priv
->rb_chan
))
3680 if (channel
->ops
->priv
->buffer_has_read_closed_stream(channel
->priv
->rb_chan
))
3681 return POLLIN
| POLLRDNORM
;
3689 int lttng_channel_release(struct inode
*inode
, struct file
*file
)
3691 struct lttng_kernel_channel_buffer
*channel
= file
->private_data
;
3694 fput(channel
->parent
.session
->priv
->file
);
3699 int lttng_metadata_channel_release(struct inode
*inode
, struct file
*file
)
3701 struct lttng_kernel_channel_buffer
*channel
= file
->private_data
;
3704 fput(channel
->parent
.session
->priv
->file
);
3705 lttng_metadata_channel_buffer_destroy(channel
);
3711 static const struct file_operations lttng_channel_fops
= {
3712 .owner
= THIS_MODULE
,
3713 .release
= lttng_channel_release
,
3714 .poll
= lttng_channel_poll
,
3715 .unlocked_ioctl
= lttng_channel_ioctl
,
3716 #ifdef CONFIG_COMPAT
3717 .compat_ioctl
= lttng_channel_ioctl
,
3721 static const struct file_operations lttng_metadata_fops
= {
3722 .owner
= THIS_MODULE
,
3723 .release
= lttng_metadata_channel_release
,
3724 .unlocked_ioctl
= lttng_metadata_ioctl
,
3725 #ifdef CONFIG_COMPAT
3726 .compat_ioctl
= lttng_metadata_ioctl
,
3731 * lttng_event_ioctl - lttng syscall through ioctl
3737 * This ioctl implements lttng commands:
3738 * LTTNG_KERNEL_ABI_CONTEXT
3739 * Prepend a context field to each record of this event
3740 * LTTNG_KERNEL_ABI_ENABLE
3741 * Enable recording for this event (weak enable)
3742 * LTTNG_KERNEL_ABI_DISABLE
3743 * Disable recording for this event (strong disable)
3746 long lttng_event_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3748 struct lttng_kernel_event_common
*event
= file
->private_data
;
3751 case LTTNG_KERNEL_ABI_OLD_CONTEXT
:
3753 /* Not implemented */
3756 case LTTNG_KERNEL_ABI_CONTEXT
:
3758 /* Not implemented */
3761 case LTTNG_KERNEL_ABI_OLD_ENABLE
:
3762 case LTTNG_KERNEL_ABI_ENABLE
:
3763 return lttng_event_enable(event
);
3764 case LTTNG_KERNEL_ABI_OLD_DISABLE
:
3765 case LTTNG_KERNEL_ABI_DISABLE
:
3766 return lttng_event_disable(event
);
3767 case LTTNG_KERNEL_ABI_FILTER
:
3769 case LTTNG_KERNEL_ABI_ADD_CALLSITE
:
3770 return lttng_event_add_callsite(event
,
3771 (struct lttng_kernel_abi_event_callsite __user
*) arg
);
3773 return -ENOIOCTLCMD
;
3778 * lttng_event_recorder_enabler_ioctl - lttng syscall through ioctl
3784 * This ioctl implements lttng commands:
3785 * LTTNG_KERNEL_ABI_CONTEXT
3786 * Prepend a context field to each record of this event
3787 * LTTNG_KERNEL_ABI_ENABLE
3788 * Enable recording for this event (weak enable)
3789 * LTTNG_KERNEL_ABI_DISABLE
3790 * Disable recording for this event (strong disable)
3793 long lttng_event_enabler_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3795 struct lttng_event_enabler_common
*event_enabler
= file
->private_data
;
3798 case LTTNG_KERNEL_ABI_OLD_CONTEXT
:
3800 /* Not implemented */
3803 case LTTNG_KERNEL_ABI_CONTEXT
:
3805 /* Not implemented */
3808 case LTTNG_KERNEL_ABI_OLD_ENABLE
:
3809 case LTTNG_KERNEL_ABI_ENABLE
:
3810 return lttng_event_enabler_enable(event_enabler
);
3811 case LTTNG_KERNEL_ABI_OLD_DISABLE
:
3812 case LTTNG_KERNEL_ABI_DISABLE
:
3813 return lttng_event_enabler_disable(event_enabler
);
3814 case LTTNG_KERNEL_ABI_FILTER
:
3816 * Filters are only supported by tracepoint and syscall instrumentation.
3818 switch (event_enabler
->event_param
.instrumentation
) {
3819 case LTTNG_KERNEL_ABI_TRACEPOINT
:
3821 case LTTNG_KERNEL_ABI_SYSCALL
:
3822 return lttng_event_enabler_attach_filter_bytecode(event_enabler
,
3823 (struct lttng_kernel_abi_filter_bytecode __user
*) arg
);
3828 case LTTNG_KERNEL_ABI_ADD_CALLSITE
:
3831 return -ENOIOCTLCMD
;
3836 int lttng_event_session_release(struct inode
*inode
, struct file
*file
)
3838 struct lttng_kernel_event_common
*event
= file
->private_data
;
3841 struct lttng_kernel_event_session_common_private
*event_session_priv
=
3842 container_of(event
->priv
, struct lttng_kernel_event_session_common_private
, parent
);
3843 fput(event_session_priv
->chan
->priv
->file
);
3849 int lttng_event_session_enabler_release(struct inode
*inode
, struct file
*file
)
3851 struct lttng_event_enabler_common
*event_enabler
= file
->private_data
;
3853 if (event_enabler
) {
3854 struct lttng_event_enabler_session_common
*event_session_enabler
=
3855 container_of(event_enabler
, struct lttng_event_enabler_session_common
, parent
);
3856 fput(event_session_enabler
->chan
->priv
->file
);
3861 static const struct file_operations lttng_event_session_fops
= {
3862 .owner
= THIS_MODULE
,
3863 .release
= lttng_event_session_release
,
3864 .unlocked_ioctl
= lttng_event_ioctl
,
3865 #ifdef CONFIG_COMPAT
3866 .compat_ioctl
= lttng_event_ioctl
,
3870 static const struct file_operations lttng_event_session_enabler_fops
= {
3871 .owner
= THIS_MODULE
,
3872 .release
= lttng_event_session_enabler_release
,
3873 .unlocked_ioctl
= lttng_event_enabler_ioctl
,
3874 #ifdef CONFIG_COMPAT
3875 .compat_ioctl
= lttng_event_enabler_ioctl
,
3879 static int put_u64(uint64_t val
, unsigned long arg
)
3881 return put_user(val
, (uint64_t __user
*) arg
);
3884 static int put_u32(uint32_t val
, unsigned long arg
)
3886 return put_user(val
, (uint32_t __user
*) arg
);
3889 static long lttng_stream_ring_buffer_ioctl(struct file
*filp
,
3890 unsigned int cmd
, unsigned long arg
)
3892 struct lttng_kernel_ring_buffer
*buf
= filp
->private_data
;
3893 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
3894 const struct lttng_kernel_ring_buffer_config
*config
= &chan
->backend
.config
;
3895 const struct lttng_kernel_channel_buffer_ops
*ops
= chan
->backend
.priv_ops
;
3898 if (atomic_read(&chan
->record_disabled
))
3902 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_BEGIN
:
3906 ret
= ops
->priv
->timestamp_begin(config
, buf
, &ts
);
3909 return put_u64(ts
, arg
);
3911 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_END
:
3915 ret
= ops
->priv
->timestamp_end(config
, buf
, &ts
);
3918 return put_u64(ts
, arg
);
3920 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_EVENTS_DISCARDED
:
3924 ret
= ops
->priv
->events_discarded(config
, buf
, &ed
);
3927 return put_u64(ed
, arg
);
3929 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CONTENT_SIZE
:
3933 ret
= ops
->priv
->content_size(config
, buf
, &cs
);
3936 return put_u64(cs
, arg
);
3938 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_PACKET_SIZE
:
3942 ret
= ops
->priv
->packet_size(config
, buf
, &ps
);
3945 return put_u64(ps
, arg
);
3947 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_STREAM_ID
:
3951 ret
= ops
->priv
->stream_id(config
, buf
, &si
);
3954 return put_u64(si
, arg
);
3956 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP
:
3960 ret
= ops
->priv
->current_timestamp(config
, buf
, &ts
);
3963 return put_u64(ts
, arg
);
3965 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SEQ_NUM
:
3969 ret
= ops
->priv
->sequence_number(config
, buf
, &seq
);
3972 return put_u64(seq
, arg
);
3974 case LTTNG_KERNEL_ABI_RING_BUFFER_INSTANCE_ID
:
3978 ret
= ops
->priv
->instance_id(config
, buf
, &id
);
3981 return put_u64(id
, arg
);
3984 return lib_ring_buffer_file_operations
.unlocked_ioctl(filp
,
3992 #ifdef CONFIG_COMPAT
3993 static long lttng_stream_ring_buffer_compat_ioctl(struct file
*filp
,
3994 unsigned int cmd
, unsigned long arg
)
3996 struct lttng_kernel_ring_buffer
*buf
= filp
->private_data
;
3997 struct lttng_kernel_ring_buffer_channel
*chan
= buf
->backend
.chan
;
3998 const struct lttng_kernel_ring_buffer_config
*config
= &chan
->backend
.config
;
3999 const struct lttng_kernel_channel_buffer_ops
*ops
= chan
->backend
.priv_ops
;
4002 if (atomic_read(&chan
->record_disabled
))
4006 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN
:
4010 ret
= ops
->priv
->timestamp_begin(config
, buf
, &ts
);
4013 return put_u64(ts
, arg
);
4015 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_END
:
4019 ret
= ops
->priv
->timestamp_end(config
, buf
, &ts
);
4022 return put_u64(ts
, arg
);
4024 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED
:
4028 ret
= ops
->priv
->events_discarded(config
, buf
, &ed
);
4031 return put_u64(ed
, arg
);
4033 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_CONTENT_SIZE
:
4037 ret
= ops
->priv
->content_size(config
, buf
, &cs
);
4040 return put_u64(cs
, arg
);
4042 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_PACKET_SIZE
:
4046 ret
= ops
->priv
->packet_size(config
, buf
, &ps
);
4049 return put_u64(ps
, arg
);
4051 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_STREAM_ID
:
4055 ret
= ops
->priv
->stream_id(config
, buf
, &si
);
4058 return put_u64(si
, arg
);
4060 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP
:
4064 ret
= ops
->priv
->current_timestamp(config
, buf
, &ts
);
4067 return put_u64(ts
, arg
);
4069 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_SEQ_NUM
:
4073 ret
= ops
->priv
->sequence_number(config
, buf
, &seq
);
4076 return put_u64(seq
, arg
);
4078 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_INSTANCE_ID
:
4082 ret
= ops
->priv
->instance_id(config
, buf
, &id
);
4085 return put_u64(id
, arg
);
4088 return lib_ring_buffer_file_operations
.compat_ioctl(filp
,
4095 #endif /* CONFIG_COMPAT */
4097 static void lttng_stream_override_ring_buffer_fops(void)
4099 lttng_stream_ring_buffer_file_operations
.owner
= THIS_MODULE
;
4100 lttng_stream_ring_buffer_file_operations
.open
=
4101 lib_ring_buffer_file_operations
.open
;
4102 lttng_stream_ring_buffer_file_operations
.release
=
4103 lib_ring_buffer_file_operations
.release
;
4104 lttng_stream_ring_buffer_file_operations
.poll
=
4105 lib_ring_buffer_file_operations
.poll
;
4106 lttng_stream_ring_buffer_file_operations
.splice_read
=
4107 lib_ring_buffer_file_operations
.splice_read
;
4108 lttng_stream_ring_buffer_file_operations
.mmap
=
4109 lib_ring_buffer_file_operations
.mmap
;
4110 lttng_stream_ring_buffer_file_operations
.unlocked_ioctl
=
4111 lttng_stream_ring_buffer_ioctl
;
4112 lttng_stream_ring_buffer_file_operations
.llseek
=
4113 lib_ring_buffer_file_operations
.llseek
;
4114 #ifdef CONFIG_COMPAT
4115 lttng_stream_ring_buffer_file_operations
.compat_ioctl
=
4116 lttng_stream_ring_buffer_compat_ioctl
;
4120 int __init
lttng_abi_init(void)
4124 wrapper_vmalloc_sync_mappings();
4127 ret
= lttng_tp_mempool_init();
4132 lttng_proc_dentry
= proc_create_data("lttng", S_IRUSR
| S_IWUSR
, NULL
,
4133 <tng_proc_ops
, NULL
);
4135 if (!lttng_proc_dentry
) {
4136 printk(KERN_ERR
"LTTng: Error creating control file\n");
4140 lttng_stream_override_ring_buffer_fops();
4144 lttng_tp_mempool_destroy();
4145 lttng_clock_unref();
4149 /* No __exit annotation because used by init error path too. */
4150 void lttng_abi_exit(void)
4152 lttng_tp_mempool_destroy();
4153 lttng_clock_unref();
4154 if (lttng_proc_dentry
)
4155 remove_proc_entry("lttng", NULL
);