projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: scsi: sd: Atomic write support added in 6.11-rc1
[lttng-modules.git] / src / lttng-abi.c
1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
2 *
3 * lttng-abi.c
4 *
5 * LTTng ABI
6 *
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 *
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.
24 */
25
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>
51
52 /*
53 * This is LTTng's own personal way to create a system call as an external
54 * module. We use ioctl() on /proc/lttng.
55 */
56
57 static struct proc_dir_entry *lttng_proc_dentry;
58
59 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
60 static const struct proc_ops lttng_proc_ops;
61 #else
62 static const struct file_operations lttng_proc_ops;
63 #endif
64
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;
72
73 static int put_u64(uint64_t val, unsigned long arg);
74 static int put_u32(uint32_t val, unsigned long arg);
75
76 static
77 int lttng_abi_create_event_counter_enabler(struct file *channel_file,
78 struct lttng_kernel_counter_event *counter_event);
79 static
80 long lttng_abi_session_create_counter(
81 struct lttng_kernel_session *session,
82 const struct lttng_kernel_counter_conf *counter_conf);
83
84 static int validate_zeroed_padding(char *p, size_t len)
85 {
86 size_t i;
87
88 for (i = 0; i < len; i++) {
89 if (p[i])
90 return -1;
91 }
92 return 0;
93 }
94
95 /*
96 * Teardown management: opened file descriptors keep a refcount on the module,
97 * so it can only exit when all file descriptors are closed.
98 */
99
100 static
101 int lttng_abi_create_session(void)
102 {
103 struct lttng_kernel_session *session;
104 struct file *session_file;
105 int session_fd, ret;
106
107 session = lttng_session_create();
108 if (!session)
109 return -ENOMEM;
110 session_fd = get_unused_fd_flags(0);
111 if (session_fd < 0) {
112 ret = session_fd;
113 goto fd_error;
114 }
115 session_file = anon_inode_getfile("[lttng_session]",
116 &lttng_session_fops,
117 session, O_RDWR);
118 if (IS_ERR(session_file)) {
119 ret = PTR_ERR(session_file);
120 goto file_error;
121 }
122 session->priv->file = session_file;
123 fd_install(session_fd, session_file);
124 return session_fd;
125
126 file_error:
127 put_unused_fd(session_fd);
128 fd_error:
129 lttng_session_destroy(session);
130 return ret;
131 }
132
133 static
134 void event_notifier_send_notification_work_wakeup(struct irq_work *entry)
135 {
136 struct lttng_event_notifier_group *event_notifier_group =
137 container_of(entry, struct lttng_event_notifier_group,
138 wakeup_pending);
139 wake_up_interruptible(&event_notifier_group->read_wait);
140 }
141
142 static
143 int lttng_abi_create_event_notifier_group(void)
144 {
145 struct lttng_event_notifier_group *event_notifier_group;
146 struct file *event_notifier_group_file;
147 int event_notifier_group_fd, ret;
148
149 event_notifier_group = lttng_event_notifier_group_create();
150 if (!event_notifier_group)
151 return -ENOMEM;
152
153 event_notifier_group_fd = get_unused_fd_flags(0);
154 if (event_notifier_group_fd < 0) {
155 ret = event_notifier_group_fd;
156 goto fd_error;
157 }
158 event_notifier_group_file = anon_inode_getfile("[lttng_event_notifier_group]",
159 &lttng_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);
163 goto file_error;
164 }
165
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;
172
173 file_error:
174 put_unused_fd(event_notifier_group_fd);
175 fd_error:
176 lttng_event_notifier_group_destroy(event_notifier_group);
177 return ret;
178 }
179
180 static
181 int lttng_abi_tracepoint_list(void)
182 {
183 struct file *tracepoint_list_file;
184 int file_fd, ret;
185
186 file_fd = get_unused_fd_flags(0);
187 if (file_fd < 0) {
188 ret = file_fd;
189 goto fd_error;
190 }
191
192 tracepoint_list_file = anon_inode_getfile("[lttng_tracepoint_list]",
193 &lttng_tracepoint_list_fops,
194 NULL, O_RDWR);
195 if (IS_ERR(tracepoint_list_file)) {
196 ret = PTR_ERR(tracepoint_list_file);
197 goto file_error;
198 }
199 ret = lttng_tracepoint_list_fops.open(NULL, tracepoint_list_file);
200 if (ret < 0)
201 goto open_error;
202 fd_install(file_fd, tracepoint_list_file);
203 return file_fd;
204
205 open_error:
206 fput(tracepoint_list_file);
207 file_error:
208 put_unused_fd(file_fd);
209 fd_error:
210 return ret;
211 }
212
213 #ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
214 static inline
215 int lttng_abi_syscall_list(void)
216 {
217 return -ENOSYS;
218 }
219 #else
220 static
221 int lttng_abi_syscall_list(void)
222 {
223 struct file *syscall_list_file;
224 int file_fd, ret;
225
226 file_fd = get_unused_fd_flags(0);
227 if (file_fd < 0) {
228 ret = file_fd;
229 goto fd_error;
230 }
231
232 syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
233 &lttng_syscall_list_fops,
234 NULL, O_RDWR);
235 if (IS_ERR(syscall_list_file)) {
236 ret = PTR_ERR(syscall_list_file);
237 goto file_error;
238 }
239 ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
240 if (ret < 0)
241 goto open_error;
242 fd_install(file_fd, syscall_list_file);
243 return file_fd;
244
245 open_error:
246 fput(syscall_list_file);
247 file_error:
248 put_unused_fd(file_fd);
249 fd_error:
250 return ret;
251 }
252 #endif
253
254 static
255 void lttng_abi_tracer_version(struct lttng_kernel_abi_tracer_version *v)
256 {
257 v->major = LTTNG_MODULES_MAJOR_VERSION;
258 v->minor = LTTNG_MODULES_MINOR_VERSION;
259 v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
260 }
261
262 static
263 void lttng_abi_tracer_abi_version(struct lttng_kernel_abi_tracer_abi_version *v)
264 {
265 v->major = LTTNG_KERNEL_ABI_MAJOR_VERSION;
266 v->minor = LTTNG_KERNEL_ABI_MINOR_VERSION;
267 }
268
269 static
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)
273 {
274
275 if (session->priv->been_active)
276 return -EPERM;
277
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,
300 ctx);
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);
358 default:
359 return -EINVAL;
360 }
361 }
362
363 /**
364 * lttng_ioctl - lttng syscall through ioctl
365 *
366 * @file: the file
367 * @cmd: the command
368 * @arg: command arg
369 *
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
383 *
384 * The returned session will be deleted when its file descriptor is closed.
385 */
386 static
387 long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
388 {
389 switch (cmd) {
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:
396 {
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;
401
402 lttng_abi_tracer_version(&v);
403 oldv.major = v.major;
404 oldv.minor = v.minor;
405 oldv.patchlevel = v.patchlevel;
406
407 if (copy_to_user(uversion, &oldv, sizeof(oldv)))
408 return -EFAULT;
409 return 0;
410 }
411 case LTTNG_KERNEL_ABI_TRACER_VERSION:
412 {
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;
416
417 lttng_abi_tracer_version(&version);
418
419 if (copy_to_user(uversion, &version, sizeof(version)))
420 return -EFAULT;
421 return 0;
422 }
423 case LTTNG_KERNEL_ABI_TRACER_ABI_VERSION:
424 {
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;
428
429 lttng_abi_tracer_abi_version(&version);
430
431 if (copy_to_user(uversion, &version, sizeof(version)))
432 return -EFAULT;
433 return 0;
434 }
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:
442 synchronize_trace();
443 return 0;
444 case LTTNG_KERNEL_ABI_OLD_CALIBRATE:
445 {
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;
450 int ret;
451
452 if (copy_from_user(&old_calibrate, ucalibrate, sizeof(old_calibrate)))
453 return -EFAULT;
454 calibrate.type = old_calibrate.type;
455 ret = lttng_calibrate(&calibrate);
456 if (copy_to_user(ucalibrate, &old_calibrate, sizeof(old_calibrate)))
457 return -EFAULT;
458 return ret;
459 }
460 case LTTNG_KERNEL_ABI_CALIBRATE:
461 {
462 struct lttng_kernel_abi_calibrate __user *ucalibrate =
463 (struct lttng_kernel_abi_calibrate __user *) arg;
464 struct lttng_kernel_abi_calibrate calibrate;
465 int ret;
466
467 if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate)))
468 return -EFAULT;
469 ret = lttng_calibrate(&calibrate);
470 if (copy_to_user(ucalibrate, &calibrate, sizeof(calibrate)))
471 return -EFAULT;
472 return ret;
473 }
474 default:
475 return -ENOIOCTLCMD;
476 }
477 }
478
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,
482 #ifdef CONFIG_COMPAT
483 .proc_compat_ioctl = lttng_ioctl,
484 #endif /* CONFIG_COMPAT */
485 };
486 #else
487 static const struct file_operations lttng_proc_ops = {
488 .owner = THIS_MODULE,
489 .unlocked_ioctl = lttng_ioctl,
490 #ifdef CONFIG_COMPAT
491 .compat_ioctl = lttng_ioctl,
492 #endif /* CONFIG_COMPAT */
493 };
494 #endif
495
496 static
497 int lttng_abi_create_channel(struct file *session_file,
498 struct lttng_kernel_abi_channel *chan_param,
499 enum channel_type channel_type)
500 {
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;
506 int chan_fd;
507 int ret = 0;
508
509 chan_fd = get_unused_fd_flags(0);
510 if (chan_fd < 0) {
511 ret = chan_fd;
512 goto fd_error;
513 }
514 switch (channel_type) {
515 case PER_CPU_CHANNEL:
516 fops = &lttng_channel_fops;
517 break;
518 case METADATA_CHANNEL:
519 fops = &lttng_metadata_fops;
520 break;
521 }
522
523 chan_file = anon_inode_getfile("[lttng_channel]",
524 fops,
525 NULL, O_RDWR);
526 if (IS_ERR(chan_file)) {
527 ret = PTR_ERR(chan_file);
528 goto file_error;
529 }
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";
538 } else {
539 return -EINVAL;
540 }
541 break;
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";
547 else
548 return -EINVAL;
549 break;
550 default:
551 transport_name = "<unknown>";
552 break;
553 }
554 if (!atomic_long_add_unless(&session_file->f_count, 1, LONG_MAX)) {
555 ret = -EOVERFLOW;
556 goto refcount_error;
557 }
558 /*
559 * We tolerate no failure path after channel creation. It will stay
560 * invariant for the rest of the session.
561 */
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,
567 channel_type);
568 if (!chan) {
569 ret = -EINVAL;
570 goto chan_error;
571 }
572 chan->priv->parent.file = chan_file;
573 chan_file->private_data = chan;
574 fd_install(chan_fd, chan_file);
575
576 return chan_fd;
577
578 chan_error:
579 atomic_long_dec(&session_file->f_count);
580 refcount_error:
581 fput(chan_file);
582 file_error:
583 put_unused_fd(chan_fd);
584 fd_error:
585 return ret;
586 }
587
588 static
589 int lttng_abi_session_set_name(struct lttng_kernel_session *session,
590 struct lttng_kernel_abi_session_name *name)
591 {
592 size_t len;
593
594 len = strnlen(name->name, LTTNG_KERNEL_ABI_SESSION_NAME_LEN);
595
596 if (len == LTTNG_KERNEL_ABI_SESSION_NAME_LEN) {
597 /* Name is too long/malformed */
598 return -EINVAL;
599 }
600
601 strcpy(session->priv->name, name->name);
602 return 0;
603 }
604
605 static
606 int lttng_abi_session_set_creation_time(struct lttng_kernel_session *session,
607 struct lttng_kernel_abi_session_creation_time *time)
608 {
609 size_t len;
610
611 len = strnlen(time->iso8601, LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN);
612
613 if (len == LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN) {
614 /* Time is too long/malformed */
615 return -EINVAL;
616 }
617
618 strcpy(session->priv->creation_time, time->iso8601);
619 return 0;
620 }
621
622 static
623 int lttng_counter_release(struct inode *inode, struct file *file)
624 {
625 struct lttng_kernel_channel_counter *counter = file->private_data;
626
627 if (counter) {
628 /*
629 * Do not destroy the counter itself. Wait of the owner
630 * (event_notifier group) to be destroyed.
631 */
632 fput(counter->priv->owner);
633 }
634
635 return 0;
636 }
637
638 static
639 int copy_user_event_param_ext(struct lttng_kernel_abi_event_ext *event_param_ext,
640 struct lttng_kernel_abi_event *event_param)
641 {
642 struct lttng_kernel_abi_event_ext __user *uevent_ext =
643 (struct lttng_kernel_abi_event_ext __user *) (unsigned long) event_param->event_ext;
644 uint32_t len;
645 int ret;
646
647 /* Use zeroed defaults if extension parameters are not set. */
648 if (!uevent_ext)
649 return 0;
650 ret = get_user(len, &uevent_ext->len);
651 if (ret)
652 return ret;
653 if (len > PAGE_SIZE)
654 return -E2BIG;
655 ret = lttng_copy_struct_from_user(event_param_ext, sizeof(*event_param_ext), uevent_ext, len);
656 if (ret)
657 return ret;
658 /* Ensure that len is consistent with the initial get_user(). */
659 event_param_ext->len = len;
660
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:
664 lttng_fallthrough;
665 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
666 lttng_fallthrough;
667 case LTTNG_KERNEL_ABI_MATCH_LAZY:
668 break;
669 default:
670 return -EINVAL;
671 }
672 return 0;
673 }
674
675 static
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)
678 {
679 enum lttng_kernel_abi_match_check match_check = LTTNG_KERNEL_ABI_MATCH_DEFAULT;
680
681 if (event_param_ext->len < offsetofend(struct lttng_kernel_abi_event_ext, match_check))
682 goto end;
683 match_check = event_param_ext->match_check;
684 end:
685 *_match_check = match_check;
686 return 0;
687 }
688
689 static
690 int create_counter_key_from_abi_dimensions(struct lttng_kernel_counter_key **_counter_key,
691 uint32_t nr_dimensions, void __user *ptr)
692 {
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;
697 uint32_t i;
698 int ret = 0;
699
700 if (!nr_dimensions || nr_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
701 return -EINVAL;
702 counter_key = kzalloc(sizeof(*counter_key), GFP_KERNEL);
703 if (!counter_key)
704 return -ENOMEM;
705 counter_key->nr_dimensions = nr_dimensions;
706 /* Only a single dimension is supported. */
707 if (WARN_ON_ONCE(nr_dimensions != 1)) {
708 ret = -EINVAL;
709 goto error;
710 }
711 udimension = (struct lttng_kernel_abi_counter_key_dimension __user *)ptr;
712 ret = lttng_copy_struct_from_user(&kdimension, sizeof(kdimension), udimension, sizeof(*udimension));
713 if (ret)
714 goto error;
715 if (kdimension.len > PAGE_SIZE) {
716 ret = -E2BIG;
717 goto error;
718 }
719 switch (kdimension.key_type) {
720 case LTTNG_KERNEL_ABI_KEY_TYPE_TOKENS:
721 {
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;
725 uint32_t nr_tokens;
726
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);
730 if (ret)
731 goto error;
732 nr_tokens = kdimension_tokens.nr_key_tokens;
733 if (nr_tokens > LTTNG_KERNEL_COUNTER_MAX_TOKENS) {
734 ret = -EINVAL;
735 goto error;
736 }
737 token_array = kzalloc(nr_tokens * sizeof(*token_array), GFP_KERNEL);
738 if (!token_array) {
739 ret = -ENOMEM;
740 goto error;
741 }
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;
749
750 ret = lttng_copy_struct_from_user(&ktoken, sizeof(ktoken), utoken, sizeof(*utoken));
751 if (ret)
752 goto error;
753 token_len += ktoken.len;
754 switch (ktoken.type) {
755 case LTTNG_KERNEL_ABI_KEY_TOKEN_STRING:
756 {
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;
760 size_t string_len;
761
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);
765 if (ret)
766 goto error;
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) {
771 ret = -EINVAL;
772 goto error;
773 }
774 key_token->str = kzalloc(string_len, GFP_KERNEL);
775 if (!key_token->str) {
776 ret = -ENOMEM;
777 goto error;
778 }
779 ret = copy_from_user(key_token->str, string_ptr, string_len);
780 if (ret)
781 goto error;
782 if (key_token->str[string_len - 1] != '\0') {
783 ret = -EINVAL;
784 goto error;
785 }
786 token_len += string_len;
787 break;
788 }
789 case LTTNG_KERNEL_ABI_KEY_TOKEN_EVENT_NAME:
790 key_token->type = LTTNG_KEY_TOKEN_EVENT_NAME;
791 break;
792
793 case LTTNG_KERNEL_ABI_KEY_TOKEN_PROVIDER_NAME:
794 lttng_fallthrough;
795 default:
796 ret = -EINVAL;
797 goto error;
798 }
799 utoken = (struct lttng_kernel_abi_key_token __user *)((unsigned long)utoken + token_len);
800 }
801
802 break;
803 }
804 case LTTNG_KERNEL_ABI_KEY_TYPE_INTEGER:
805 default:
806 ret = -EINVAL;
807 goto error;
808 }
809 *_counter_key = counter_key;
810 return 0;
811
812 error:
813 destroy_counter_key(counter_key);
814 return ret;
815 }
816
817 int create_counter_key_from_kernel(struct lttng_kernel_counter_key **_new_key,
818 const struct lttng_kernel_counter_key *src_key)
819 {
820 struct lttng_kernel_counter_key *new_key;
821 int i, ret = 0;
822
823 new_key = kzalloc(sizeof(*new_key), GFP_KERNEL);
824 if (!new_key)
825 return -ENOMEM;
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;
831 int j;
832
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) {
836 ret = -ENOMEM;
837 goto error;
838 }
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];
842
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) {
848 ret = -ENOMEM;
849 goto error;
850 }
851 break;
852 case LTTNG_KEY_TOKEN_EVENT_NAME:
853 new_key_token->type = LTTNG_KEY_TOKEN_EVENT_NAME;
854 break;
855
856 default:
857 ret = -EINVAL;
858 goto error;
859 }
860 }
861 }
862 *_new_key = new_key;
863 return 0;
864
865 error:
866 destroy_counter_key(new_key);
867 return ret;
868 }
869
870 void destroy_counter_key(struct lttng_kernel_counter_key *counter_key)
871 {
872 int i;
873
874 if (!counter_key)
875 return;
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;
879 int j;
880
881 for (j = 0; j < nr_tokens; j++) {
882 struct lttng_key_token *key_token = &dimension->token_array[j];
883
884 switch (key_token->type) {
885 case LTTNG_KEY_TOKEN_STRING:
886 kfree(key_token->str);
887 break;
888
889 case LTTNG_KEY_TOKEN_EVENT_NAME:
890 lttng_fallthrough;
891 case LTTNG_KEY_TOKEN_UNKNOWN:
892 break;
893
894 default:
895 WARN_ON_ONCE(1);
896 }
897 }
898 kfree(dimension->token_array);
899 }
900 kfree(counter_key);
901 }
902
903 static
904 long lttng_counter_ioctl_abi_old_counter_read(struct lttng_kernel_channel_counter *counter,
905 unsigned int cmd, unsigned long arg)
906 {
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;
912 int64_t value;
913 int32_t cpu;
914 int ret, i;
915
916 if (copy_from_user(&local_counter_read, ucounter_read,
917 sizeof(local_counter_read)))
918 return -EFAULT;
919 if (validate_zeroed_padding(local_counter_read.padding,
920 sizeof(local_counter_read.padding)))
921 return -EINVAL;
922 if (local_counter_read.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
923 return -EINVAL;
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;
928
929 ret = lttng_kernel_counter_read(counter, indexes, cpu, &value, &overflow, &underflow);
930 if (ret)
931 return ret;
932 local_counter_read.value.value = value;
933 local_counter_read.value.overflow = overflow;
934 local_counter_read.value.underflow = underflow;
935
936 if (copy_to_user(&ucounter_read->value, &local_counter_read.value,
937 sizeof(local_counter_read.value)))
938 return -EFAULT;
939
940 return 0;
941 }
942
943 static
944 long lttng_counter_ioctl_abi_old_counter_aggregate(struct lttng_kernel_channel_counter *counter,
945 unsigned int cmd, unsigned long arg)
946 {
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;
952 int64_t value;
953 int ret, i;
954
955 if (copy_from_user(&local_counter_aggregate, ucounter_aggregate,
956 sizeof(local_counter_aggregate)))
957 return -EFAULT;
958 if (validate_zeroed_padding(local_counter_aggregate.padding,
959 sizeof(local_counter_aggregate.padding)))
960 return -EINVAL;
961 if (local_counter_aggregate.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
962 return -EINVAL;
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];
966
967 ret = lttng_kernel_counter_aggregate(counter, indexes, &value, &overflow, &underflow);
968 if (ret)
969 return ret;
970 local_counter_aggregate.value.value = value;
971 local_counter_aggregate.value.overflow = overflow;
972 local_counter_aggregate.value.underflow = underflow;
973
974 if (copy_to_user(&ucounter_aggregate->value, &local_counter_aggregate.value,
975 sizeof(local_counter_aggregate.value)))
976 return -EFAULT;
977
978 return 0;
979 }
980
981 static
982 long lttng_counter_ioctl_abi_old_counter_clear(struct lttng_kernel_channel_counter *counter,
983 unsigned int cmd, unsigned long arg)
984 {
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;
989 int i;
990
991 if (copy_from_user(&local_counter_clear, ucounter_clear,
992 sizeof(local_counter_clear)))
993 return -EFAULT;
994 if (validate_zeroed_padding(local_counter_clear.padding,
995 sizeof(local_counter_clear.padding)))
996 return -EINVAL;
997 if (local_counter_clear.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
998 return -EINVAL;
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);
1003 }
1004
1005 static
1006 long lttng_counter_ioctl_abi_counter_read(struct lttng_kernel_channel_counter *counter,
1007 unsigned int cmd, unsigned long arg)
1008 {
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;
1015 int64_t value;
1016 int32_t cpu;
1017 int ret, i;
1018
1019 ret = get_user(len, &ucounter_read->len);
1020 if (ret)
1021 return ret;
1022 if (len > PAGE_SIZE)
1023 return -E2BIG;
1024 if (len < offsetofend(struct lttng_kernel_abi_counter_read, value))
1025 return -EINVAL;
1026 ret = lttng_copy_struct_from_user(&kcounter_read, sizeof(kcounter_read),
1027 ucounter_read, len);
1028 if (ret)
1029 return ret;
1030 number_dimensions = kcounter_read.index.number_dimensions;
1031 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1032 return -EINVAL;
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;
1036 uint64_t index;
1037
1038 ret = get_user(index, ptr);
1039 if (ret)
1040 return ret;
1041 indexes[i] = index;
1042 }
1043 cpu = kcounter_read.cpu;
1044 ret = lttng_kernel_counter_read(counter, indexes, cpu, &value, &overflow, &underflow);
1045 if (ret)
1046 return ret;
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;
1050
1051 if (copy_to_user(&ucounter_read->value, &kcounter_read.value, sizeof(kcounter_read.value)))
1052 return -EFAULT;
1053
1054 return 0;
1055 }
1056
1057 static
1058 long lttng_counter_ioctl_abi_counter_aggregate(struct lttng_kernel_channel_counter *counter,
1059 unsigned int cmd, unsigned long arg)
1060 {
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;
1067 int64_t value;
1068 int ret, i;
1069
1070 ret = get_user(len, &ucounter_aggregate->len);
1071 if (ret)
1072 return ret;
1073 if (len > PAGE_SIZE)
1074 return -E2BIG;
1075 if (len < offsetofend(struct lttng_kernel_abi_counter_aggregate, value))
1076 return -EINVAL;
1077 ret = lttng_copy_struct_from_user(&kcounter_aggregate, sizeof(kcounter_aggregate),
1078 ucounter_aggregate, len);
1079 if (ret)
1080 return ret;
1081 number_dimensions = kcounter_aggregate.index.number_dimensions;
1082 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1083 return -EINVAL;
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;
1087 uint64_t index;
1088
1089 ret = get_user(index, ptr);
1090 if (ret)
1091 return ret;
1092 indexes[i] = index;
1093 }
1094 ret = lttng_kernel_counter_aggregate(counter, indexes, &value, &overflow, &underflow);
1095 if (ret)
1096 return ret;
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;
1100
1101 if (copy_to_user(&ucounter_aggregate->value, &kcounter_aggregate.value, sizeof(kcounter_aggregate.value)))
1102 return -EFAULT;
1103
1104 return 0;
1105 }
1106
1107 static
1108 long lttng_counter_ioctl_abi_counter_clear(struct lttng_kernel_channel_counter *counter,
1109 unsigned int cmd, unsigned long arg)
1110 {
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;
1116 int ret, i;
1117
1118 ret = get_user(len, &ucounter_clear->len);
1119 if (ret)
1120 return ret;
1121 if (len > PAGE_SIZE)
1122 return -E2BIG;
1123 if (len < offsetofend(struct lttng_kernel_abi_counter_clear, index))
1124 return -EINVAL;
1125 ret = lttng_copy_struct_from_user(&kcounter_clear, sizeof(kcounter_clear),
1126 ucounter_clear, len);
1127 if (ret)
1128 return ret;
1129 number_dimensions = kcounter_clear.index.number_dimensions;
1130 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1131 return -EINVAL;
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;
1135 uint64_t index;
1136
1137 ret = get_user(index, ptr);
1138 if (ret)
1139 return ret;
1140 indexes[i] = index;
1141 }
1142 return lttng_kernel_counter_clear(counter, indexes);
1143 }
1144
1145 static
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)
1149 {
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;
1154 uint32_t len;
1155 int ret;
1156
1157 ret = get_user(len, &ucounter_event->len);
1158 if (ret)
1159 return ret;
1160 if (len > PAGE_SIZE)
1161 return -E2BIG;
1162 if (len < offsetofend(struct lttng_kernel_abi_counter_event, number_key_dimensions))
1163 return -EINVAL;
1164 counter_event = kzalloc(sizeof(*counter_event), GFP_KERNEL);
1165 if (!counter_event)
1166 return -ENOMEM;
1167 ret = lttng_copy_struct_from_user(&kcounter_event, sizeof(kcounter_event),
1168 ucounter_event, len);
1169 if (ret)
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);
1173 if (ret)
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. */
1178 break;
1179 default:
1180 ret = -EINVAL;
1181 goto end_counter_event;
1182 }
1183 ret = create_counter_key_from_abi_dimensions(&counter_event->counter_key,
1184 kcounter_event.number_key_dimensions,
1185 (void __user *) arg + len);
1186 if (ret)
1187 goto end_counter_event;
1188 ret = lttng_abi_create_event_counter_enabler(file, counter_event);
1189 destroy_counter_key(counter_event->counter_key);
1190 end_counter_event:
1191 kfree(counter_event);
1192 return ret;
1193 }
1194
1195 static
1196 long lttng_counter_ioctl_abi_counter_map_descriptor(struct lttng_kernel_channel_counter *counter,
1197 unsigned int cmd, unsigned long arg)
1198 {
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];
1205 size_t key_strlen;
1206 uint32_t len;
1207 int ret;
1208
1209 ret = get_user(len, &udescriptor->len);
1210 if (ret)
1211 return ret;
1212 if (len > PAGE_SIZE)
1213 return -E2BIG;
1214 if (len < offsetofend(struct lttng_kernel_abi_counter_map_descriptor, array_indexes_len))
1215 return -EINVAL;
1216 ret = lttng_copy_struct_from_user(&kdescriptor, sizeof(kdescriptor), udescriptor, len);
1217 if (ret)
1218 return ret;
1219 mutex_lock(&counter->priv->map.lock);
1220 if (kdescriptor.descriptor_index >= counter->priv->map.nr_descriptors) {
1221 ret = -EOVERFLOW;
1222 goto map_descriptor_error_unlock;
1223 }
1224 if (kdescriptor.array_indexes_len < 1) {
1225 ret = -EINVAL;
1226 goto map_descriptor_error_unlock;
1227 }
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);
1235
1236 key_strlen = strlen(key) + 1;
1237 if (kdescriptor.key_string_len < key_strlen)
1238 return -ENOSPC;
1239 kdescriptor.key_string_len = key_strlen;
1240 if (copy_to_user((char __user *)(unsigned long)kdescriptor.key_string, key, key_strlen))
1241 return -EFAULT;
1242 if (copy_to_user((uint64_t __user *)(unsigned long)kdescriptor.array_indexes, array_indexes, sizeof(uint64_t)))
1243 return -EFAULT;
1244 if (copy_to_user(udescriptor, &kdescriptor, min(sizeof(kdescriptor), (size_t)len)))
1245 return -EFAULT;
1246 return 0;
1247
1248 map_descriptor_error_unlock:
1249 mutex_unlock(&counter->priv->map.lock);
1250 return ret;
1251 }
1252
1253 static
1254 long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1255 {
1256 struct lttng_kernel_channel_counter *counter = file->private_data;
1257
1258 switch (cmd) {
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:
1281 {
1282 uint64_t __user *user_nr_descriptors = (uint64_t __user *) arg;
1283 uint64_t nr_descriptors;
1284
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);
1289 }
1290 case LTTNG_KERNEL_ABI_COUNTER_MAP_DESCRIPTOR:
1291 return lttng_counter_ioctl_abi_counter_map_descriptor(counter, cmd, arg);
1292 default:
1293 return -ENOSYS;
1294 }
1295 }
1296
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,
1303 #endif
1304 };
1305
1306
1307 static
1308 enum tracker_type get_tracker_type(struct lttng_kernel_abi_tracker_args *tracker)
1309 {
1310 switch (tracker->type) {
1311 case LTTNG_KERNEL_ABI_TRACKER_PID:
1312 return TRACKER_PID;
1313 case LTTNG_KERNEL_ABI_TRACKER_VPID:
1314 return TRACKER_VPID;
1315 case LTTNG_KERNEL_ABI_TRACKER_UID:
1316 return TRACKER_UID;
1317 case LTTNG_KERNEL_ABI_TRACKER_VUID:
1318 return TRACKER_VUID;
1319 case LTTNG_KERNEL_ABI_TRACKER_GID:
1320 return TRACKER_GID;
1321 case LTTNG_KERNEL_ABI_TRACKER_VGID:
1322 return TRACKER_VGID;
1323 default:
1324 return TRACKER_UNKNOWN;
1325 }
1326 }
1327
1328 static
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)
1331 {
1332 struct lttng_kernel_abi_old_counter_conf old_kcounter_conf;
1333 struct lttng_kernel_counter_dimension *dimension;
1334 int ret;
1335
1336 memset(counter_conf, 0, sizeof(*counter_conf));
1337 ret = copy_from_user(&old_kcounter_conf, old_ucounter_conf,
1338 sizeof(old_kcounter_conf));
1339 if (ret)
1340 return ret;
1341 if (!old_kcounter_conf.number_dimensions ||
1342 old_kcounter_conf.number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1343 return -EINVAL;
1344 switch (old_kcounter_conf.arithmetic) {
1345 case LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR:
1346 counter_conf->arithmetic = LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR;
1347 break;
1348 default:
1349 return -EINVAL;
1350 }
1351 switch (old_kcounter_conf.bitness) {
1352 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32:
1353 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_32;
1354 break;
1355 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64:
1356 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_64;
1357 break;
1358 default:
1359 return -EINVAL;
1360 }
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;
1372 return 0;
1373 }
1374
1375 static
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)
1378 {
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;
1384 int ret;
1385
1386 memset(counter_conf, 0, sizeof(*counter_conf));
1387 ret = get_user(len, &ucounter_conf->len);
1388 if (ret)
1389 return ret;
1390 if (len < offsetofend(struct lttng_kernel_abi_counter_conf, dimension_array))
1391 return -EINVAL;
1392 if (len > PAGE_SIZE)
1393 return -EINVAL;
1394
1395 ret = lttng_copy_struct_from_user(&kcounter_conf, sizeof(kcounter_conf), ucounter_conf, len);
1396 if (ret)
1397 return ret;
1398
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;
1403 break;
1404 default:
1405 return -EINVAL;
1406 }
1407 switch (kcounter_conf.bitness) {
1408 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32:
1409 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_32;
1410 break;
1411 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64:
1412 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_64;
1413 break;
1414 default:
1415 return -EINVAL;
1416 }
1417 if (kcounter_conf.flags & ~LTTNG_KERNEL_ABI_COUNTER_CONF_FLAG_COALESCE_HITS)
1418 return -EINVAL;
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;
1422
1423 number_dimensions = kcounter_conf.dimension_array.number_dimensions;
1424 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1425 return -EINVAL;
1426 dimension = &counter_conf->dimension_array[0];
1427 len = kcounter_conf.dimension_array.elem_len;
1428 if (len > PAGE_SIZE)
1429 return -E2BIG;
1430 if (len < offsetofend(struct lttng_kernel_abi_counter_dimension, overflow_index))
1431 return -EINVAL;
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);
1434 if (ret)
1435 return ret;
1436
1437 /* Validate flags */
1438 if (kdimension.flags & ~(LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW |
1439 LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW))
1440 return -EINVAL;
1441
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;
1449 return 0;
1450 }
1451
1452 /**
1453 * lttng_session_ioctl - lttng session fd ioctl
1454 *
1455 * @file: the file
1456 * @cmd: the command
1457 * @arg: command arg
1458 *
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
1473 * Add ID to tracker
1474 * LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID
1475 * Remove ID from tracker
1476 *
1477 * The returned channel will be deleted when its file descriptor is closed.
1478 */
1479 static
1480 long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1481 {
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;
1485 int ret;
1486
1487 /*
1488 * Handle backward compatibility. OLD commands have wrong
1489 * directions, replace them by the correct direction.
1490 */
1491 switch (cmd) {
1492 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_PID:
1493 cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_PID;
1494 break;
1495 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_PID:
1496 cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID;
1497 break;
1498 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_ID:
1499 cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_ID;
1500 break;
1501 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_ID:
1502 cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID;
1503 break;
1504 case LTTNG_KERNEL_ABI_OLD_SESSION_LIST_TRACKER_IDS:
1505 cmd = LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS;
1506 break;
1507 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_NAME:
1508 cmd = LTTNG_KERNEL_ABI_SESSION_SET_NAME;
1509 break;
1510 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_CREATION_TIME:
1511 cmd = LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME;
1512 break;
1513 default:
1514 /* Nothing to do. */
1515 break;
1516 }
1517
1518 switch (cmd) {
1519 case LTTNG_KERNEL_ABI_OLD_CHANNEL:
1520 {
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)))
1524 return -EFAULT;
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;
1531
1532 return lttng_abi_create_channel(file, &chan_param,
1533 PER_CPU_CHANNEL);
1534 }
1535 case LTTNG_KERNEL_ABI_CHANNEL:
1536 {
1537 if (copy_from_user(&chan_param,
1538 (struct lttng_kernel_abi_channel __user *) arg,
1539 sizeof(struct lttng_kernel_abi_channel)))
1540 return -EFAULT;
1541 return lttng_abi_create_channel(file, &chan_param,
1542 PER_CPU_CHANNEL);
1543 }
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:
1555 {
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)))
1559 return -EFAULT;
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;
1566
1567 return lttng_abi_create_channel(file, &chan_param,
1568 METADATA_CHANNEL);
1569 }
1570 case LTTNG_KERNEL_ABI_METADATA:
1571 {
1572 if (copy_from_user(&chan_param,
1573 (struct lttng_kernel_abi_channel __user *) arg,
1574 sizeof(struct lttng_kernel_abi_channel)))
1575 return -EFAULT;
1576 return lttng_abi_create_channel(file, &chan_param,
1577 METADATA_CHANNEL);
1578 }
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:
1584 {
1585 struct lttng_kernel_abi_tracker_args tracker;
1586 enum tracker_type tracker_type;
1587
1588 if (copy_from_user(&tracker,
1589 (struct lttng_kernel_abi_tracker_args __user *) arg,
1590 sizeof(struct lttng_kernel_abi_tracker_args)))
1591 return -EFAULT;
1592 tracker_type = get_tracker_type(&tracker);
1593 if (tracker_type == TRACKER_UNKNOWN)
1594 return -EINVAL;
1595 return lttng_session_track_id(session, tracker_type, tracker.id);
1596 }
1597 case LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID:
1598 {
1599 struct lttng_kernel_abi_tracker_args tracker;
1600 enum tracker_type tracker_type;
1601
1602 if (copy_from_user(&tracker,
1603 (struct lttng_kernel_abi_tracker_args __user *) arg,
1604 sizeof(struct lttng_kernel_abi_tracker_args)))
1605 return -EFAULT;
1606 tracker_type = get_tracker_type(&tracker);
1607 if (tracker_type == TRACKER_UNKNOWN)
1608 return -EINVAL;
1609 return lttng_session_untrack_id(session, tracker_type,
1610 tracker.id);
1611 }
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:
1615 {
1616 struct lttng_kernel_abi_tracker_args tracker;
1617 enum tracker_type tracker_type;
1618
1619 if (copy_from_user(&tracker,
1620 (struct lttng_kernel_abi_tracker_args __user *) arg,
1621 sizeof(struct lttng_kernel_abi_tracker_args)))
1622 return -EFAULT;
1623 tracker_type = get_tracker_type(&tracker);
1624 if (tracker_type == TRACKER_UNKNOWN)
1625 return -EINVAL;
1626 return lttng_session_list_tracker_ids(session, tracker_type);
1627 }
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:
1633 {
1634 struct lttng_kernel_abi_session_name name;
1635
1636 if (copy_from_user(&name,
1637 (struct lttng_kernel_abi_session_name __user *) arg,
1638 sizeof(struct lttng_kernel_abi_session_name)))
1639 return -EFAULT;
1640 return lttng_abi_session_set_name(session, &name);
1641 }
1642 case LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME:
1643 {
1644 struct lttng_kernel_abi_session_creation_time time;
1645
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)))
1649 return -EFAULT;
1650 return lttng_abi_session_set_creation_time(session, &time);
1651 }
1652 case LTTNG_KERNEL_ABI_COUNTER:
1653 {
1654 struct lttng_kernel_counter_conf counter_conf;
1655
1656 ret = lttng_abi_copy_user_counter_conf(&counter_conf,
1657 (struct lttng_kernel_abi_counter_conf __user *) arg);
1658 if (ret)
1659 return ret;
1660 return lttng_abi_session_create_counter(session, &counter_conf);
1661 }
1662 default:
1663 return -ENOIOCTLCMD;
1664 }
1665 }
1666
1667 /*
1668 * Called when the last file reference is dropped.
1669 *
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).
1674 */
1675 static
1676 int lttng_session_release(struct inode *inode, struct file *file)
1677 {
1678 struct lttng_kernel_session *session = file->private_data;
1679
1680 if (session)
1681 lttng_session_destroy(session);
1682 return 0;
1683 }
1684
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,
1691 #endif
1692 };
1693
1694 /*
1695 * When encountering empty buffer, flush current sub-buffer if non-empty
1696 * and retry (if new data available to read after flush).
1697 */
1698 static
1699 ssize_t lttng_event_notifier_group_notif_read(struct file *filp, char __user *user_buf,
1700 size_t count, loff_t *ppos)
1701 {
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;
1706 size_t read_offset;
1707
1708 might_sleep();
1709 if (!lttng_access_ok(VERIFY_WRITE, user_buf, count))
1710 return -EFAULT;
1711
1712 /* Finish copy of previous record */
1713 if (*ppos != 0) {
1714 if (count != 0) {
1715 len = chan->iter.len_left;
1716 read_offset = *ppos;
1717 goto skip_get_next;
1718 }
1719 }
1720
1721 while (read_count < count) {
1722 size_t copy_len, space_left;
1723
1724 len = lib_ring_buffer_get_next_record(chan, buf);
1725 len_test:
1726 if (len < 0) {
1727 /*
1728 * Check if buffer is finalized (end of file).
1729 */
1730 if (len == -ENODATA) {
1731 /* A 0 read_count will tell about end of file */
1732 goto nodata;
1733 }
1734 if (filp->f_flags & O_NONBLOCK) {
1735 if (!read_count)
1736 read_count = -EAGAIN;
1737 goto nodata;
1738 } else {
1739 int error;
1740
1741 /*
1742 * No data available at the moment, return what
1743 * we got.
1744 */
1745 if (read_count)
1746 goto nodata;
1747
1748 /*
1749 * Wait for returned len to be >= 0 or -ENODATA.
1750 */
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);
1756 if (error) {
1757 read_count = error;
1758 goto nodata;
1759 }
1760 CHAN_WARN_ON(chan, len < 0 && len != -ENODATA);
1761 goto len_test;
1762 }
1763 }
1764 read_offset = buf->iter.read_offset;
1765 skip_get_next:
1766 space_left = count - read_count;
1767 if (len <= space_left) {
1768 copy_len = len;
1769 chan->iter.len_left = 0;
1770 *ppos = 0;
1771 } else {
1772 copy_len = space_left;
1773 chan->iter.len_left = len - copy_len;
1774 *ppos = read_offset + copy_len;
1775 }
1776 if (__lib_ring_buffer_copy_to_user(&buf->backend, read_offset,
1777 &user_buf[read_count],
1778 copy_len)) {
1779 /*
1780 * Leave the len_left and ppos values at their current
1781 * state, as we currently have a valid event to read.
1782 */
1783 return -EFAULT;
1784 }
1785 read_count += copy_len;
1786 }
1787 goto put_record;
1788
1789 nodata:
1790 *ppos = 0;
1791 chan->iter.len_left = 0;
1792
1793 put_record:
1794 if (*ppos == 0)
1795 lib_ring_buffer_put_current_record(buf);
1796 return read_count;
1797 }
1798
1799 /*
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.
1803 */
1804 static
1805 unsigned int lttng_event_notifier_group_notif_poll(struct file *filp,
1806 poll_table *wait)
1807 {
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();
1816
1817 if (filp->f_mode & FMODE_READ) {
1818 poll_wait_set_exclusive(wait);
1819 poll_wait(filp, &event_notifier_group->read_wait, wait);
1820
1821 finalized = lib_ring_buffer_is_finalized(config, buf);
1822 disabled = lib_ring_buffer_channel_is_disabled(chan);
1823
1824 /*
1825 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
1826 * finalized load before offsets loads.
1827 */
1828 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
1829 retry:
1830 if (disabled)
1831 return POLLERR;
1832
1833 offset = lib_ring_buffer_get_offset(config, buf);
1834 consumed = lib_ring_buffer_get_consumed(config, buf);
1835
1836 /*
1837 * If there is no buffer available to consume.
1838 */
1839 if (subbuf_trunc(offset, chan) - subbuf_trunc(consumed, chan) == 0) {
1840 /*
1841 * If there is a non-empty subbuffer, flush and try again.
1842 */
1843 if (subbuf_offset(offset, chan) > subbuffer_header_size) {
1844 lib_ring_buffer_switch_remote(buf);
1845 goto retry;
1846 }
1847
1848 if (finalized)
1849 return POLLHUP;
1850 else {
1851 /*
1852 * The memory barriers
1853 * __wait_event()/wake_up_interruptible() take
1854 * care of "raw_spin_is_locked" memory ordering.
1855 */
1856 if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
1857 goto retry;
1858 else
1859 return 0;
1860 }
1861 } else {
1862 if (subbuf_trunc(offset, chan) - subbuf_trunc(consumed, chan)
1863 >= chan->backend.buf_size)
1864 return POLLPRI | POLLRDBAND;
1865 else
1866 return POLLIN | POLLRDNORM;
1867 }
1868 }
1869
1870 return mask;
1871 }
1872
1873 /**
1874 * lttng_event_notifier_group_notif_open - event_notifier ring buffer open file operation
1875 * @inode: opened inode
1876 * @file: opened file
1877 *
1878 * Open implementation. Makes sure only one open instance of a buffer is
1879 * done at a given moment.
1880 */
1881 static int lttng_event_notifier_group_notif_open(struct inode *inode, struct file *file)
1882 {
1883 struct lttng_event_notifier_group *event_notifier_group = inode->i_private;
1884 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
1885
1886 file->private_data = event_notifier_group;
1887 return lib_ring_buffer_open(inode, file, buf);
1888 }
1889
1890 /**
1891 * lttng_event_notifier_group_notif_release - event_notifier ring buffer release file operation
1892 * @inode: opened inode
1893 * @file: opened file
1894 *
1895 * Release implementation.
1896 */
1897 static int lttng_event_notifier_group_notif_release(struct inode *inode, struct file *file)
1898 {
1899 struct lttng_event_notifier_group *event_notifier_group = file->private_data;
1900 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
1901 int ret;
1902
1903 ret = lib_ring_buffer_release(inode, file, buf);
1904 if (ret)
1905 return ret;
1906 fput(event_notifier_group->file);
1907 return 0;
1908 }
1909
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,
1916 };
1917
1918 /**
1919 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
1920 * @filp: the file
1921 * @wait: poll table
1922 *
1923 * Handles the poll operations for the metadata channels.
1924 */
1925 static
1926 unsigned int lttng_metadata_ring_buffer_poll(struct file *filp,
1927 poll_table *wait)
1928 {
1929 struct lttng_metadata_stream *stream = filp->private_data;
1930 struct lttng_kernel_ring_buffer *buf = stream->priv;
1931 int finalized;
1932 unsigned int mask = 0;
1933
1934 if (filp->f_mode & FMODE_READ) {
1935 poll_wait_set_exclusive(wait);
1936 poll_wait(filp, &stream->read_wait, wait);
1937
1938 finalized = stream->finalized;
1939
1940 /*
1941 * lib_ring_buffer_is_finalized() contains a smp_rmb()
1942 * ordering finalized load before offsets loads.
1943 */
1944 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
1945
1946 if (finalized)
1947 mask |= POLLHUP;
1948
1949 mutex_lock(&stream->metadata_cache->lock);
1950 if (stream->metadata_cache->metadata_written >
1951 stream->metadata_out)
1952 mask |= POLLIN;
1953 mutex_unlock(&stream->metadata_cache->lock);
1954 }
1955
1956 return mask;
1957 }
1958
1959 static
1960 void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file *filp,
1961 unsigned int cmd, unsigned long arg)
1962 {
1963 struct lttng_metadata_stream *stream = filp->private_data;
1964
1965 stream->metadata_out = stream->metadata_in;
1966 }
1967
1968 /*
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
1975 * metadata file.
1976 *
1977 * Return 0 on success, a negative value on error.
1978 */
1979 static
1980 int lttng_metadata_cache_dump(struct lttng_metadata_stream *stream)
1981 {
1982 int ret;
1983 struct lttng_metadata_cache *cache = stream->metadata_cache;
1984
1985 mutex_lock(&cache->lock);
1986 if (stream->metadata_out != cache->metadata_written) {
1987 ret = -EBUSY;
1988 goto end;
1989 }
1990 stream->metadata_out = 0;
1991 stream->metadata_in = 0;
1992 wake_up_interruptible(&stream->read_wait);
1993 ret = 0;
1994
1995 end:
1996 mutex_unlock(&cache->lock);
1997 return ret;
1998 }
1999
2000 static
2001 long lttng_metadata_ring_buffer_ioctl(struct file *filp,
2002 unsigned int cmd, unsigned long arg)
2003 {
2004 int ret;
2005 struct lttng_metadata_stream *stream = filp->private_data;
2006 struct lttng_kernel_ring_buffer *buf = stream->priv;
2007 unsigned int rb_cmd;
2008 bool coherent;
2009
2010 if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
2011 rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF;
2012 else
2013 rb_cmd = cmd;
2014
2015 switch (cmd) {
2016 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF:
2017 {
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;
2021
2022 ret = lttng_metadata_output_channel(stream, chan, NULL);
2023 if (ret > 0) {
2024 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2025 ret = 0;
2026 } else if (ret < 0)
2027 goto err;
2028 break;
2029 }
2030 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF:
2031 {
2032 /*
2033 * Random access is not allowed for metadata channel.
2034 */
2035 return -ENOSYS;
2036 }
2037 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY:
2038 lttng_fallthrough;
2039 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH:
2040 {
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;
2044
2045 /*
2046 * Before doing the actual ring buffer flush, write up to one
2047 * packet of metadata in the ring buffer.
2048 */
2049 ret = lttng_metadata_output_channel(stream, chan, NULL);
2050 if (ret < 0)
2051 goto err;
2052 break;
2053 }
2054 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION:
2055 {
2056 struct lttng_metadata_stream *stream = filp->private_data;
2057
2058 return put_u64(stream->version, arg);
2059 }
2060 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP:
2061 {
2062 struct lttng_metadata_stream *stream = filp->private_data;
2063
2064 return lttng_metadata_cache_dump(stream);
2065 }
2066 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
2067 {
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;
2071
2072 ret = lttng_metadata_output_channel(stream, chan, &coherent);
2073 if (ret > 0) {
2074 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2075 ret = 0;
2076 } else if (ret < 0) {
2077 goto err;
2078 }
2079 break;
2080 }
2081 default:
2082 break;
2083 }
2084 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2085
2086 /* Performing lib ring buffer ioctl after our own. */
2087 ret = lib_ring_buffer_ioctl(filp, rb_cmd, arg, buf);
2088 if (ret < 0)
2089 goto err;
2090
2091 switch (cmd) {
2092 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF:
2093 {
2094 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
2095 cmd, arg);
2096 break;
2097 }
2098 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
2099 {
2100 return put_u32(coherent, arg);
2101 }
2102 default:
2103 break;
2104 }
2105 err:
2106 return ret;
2107 }
2108
2109 #ifdef CONFIG_COMPAT
2110 static
2111 long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp,
2112 unsigned int cmd, unsigned long arg)
2113 {
2114 int ret;
2115 struct lttng_metadata_stream *stream = filp->private_data;
2116 struct lttng_kernel_ring_buffer *buf = stream->priv;
2117 unsigned int rb_cmd;
2118 bool coherent;
2119
2120 if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
2121 rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF;
2122 else
2123 rb_cmd = cmd;
2124
2125 switch (cmd) {
2126 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF:
2127 {
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;
2131
2132 ret = lttng_metadata_output_channel(stream, chan, NULL);
2133 if (ret > 0) {
2134 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2135 ret = 0;
2136 } else if (ret < 0)
2137 goto err;
2138 break;
2139 }
2140 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF:
2141 {
2142 /*
2143 * Random access is not allowed for metadata channel.
2144 */
2145 return -ENOSYS;
2146 }
2147 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY:
2148 lttng_fallthrough;
2149 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH:
2150 {
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;
2154
2155 /*
2156 * Before doing the actual ring buffer flush, write up to one
2157 * packet of metadata in the ring buffer.
2158 */
2159 ret = lttng_metadata_output_channel(stream, chan, NULL);
2160 if (ret < 0)
2161 goto err;
2162 break;
2163 }
2164 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION:
2165 {
2166 struct lttng_metadata_stream *stream = filp->private_data;
2167
2168 return put_u64(stream->version, arg);
2169 }
2170 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP:
2171 {
2172 struct lttng_metadata_stream *stream = filp->private_data;
2173
2174 return lttng_metadata_cache_dump(stream);
2175 }
2176 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
2177 {
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;
2181
2182 ret = lttng_metadata_output_channel(stream, chan, &coherent);
2183 if (ret > 0) {
2184 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2185 ret = 0;
2186 } else if (ret < 0) {
2187 goto err;
2188 }
2189 break;
2190 }
2191 default:
2192 break;
2193 }
2194 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2195
2196 /* Performing lib ring buffer ioctl after our own. */
2197 ret = lib_ring_buffer_compat_ioctl(filp, rb_cmd, arg, buf);
2198 if (ret < 0)
2199 goto err;
2200
2201 switch (cmd) {
2202 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF:
2203 {
2204 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
2205 cmd, arg);
2206 break;
2207 }
2208 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
2209 {
2210 return put_u32(coherent, arg);
2211 }
2212 default:
2213 break;
2214 }
2215 err:
2216 return ret;
2217 }
2218 #endif
2219
2220 /*
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.
2223 */
2224 static
2225 int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file)
2226 {
2227 struct lttng_metadata_stream *stream = inode->i_private;
2228 struct lttng_kernel_ring_buffer *buf = stream->priv;
2229
2230 file->private_data = buf;
2231 /*
2232 * Since life-time of metadata cache differs from that of
2233 * session, we need to keep our own reference on the transport.
2234 */
2235 if (!try_module_get(stream->transport->owner)) {
2236 printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
2237 return -EBUSY;
2238 }
2239 return lib_ring_buffer_open(inode, file, buf);
2240 }
2241
2242 static
2243 int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file)
2244 {
2245 struct lttng_metadata_stream *stream = file->private_data;
2246 struct lttng_kernel_ring_buffer *buf = stream->priv;
2247
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);
2253 kfree(stream);
2254 return lib_ring_buffer_release(inode, file, buf);
2255 }
2256
2257 static
2258 ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
2259 struct pipe_inode_info *pipe, size_t len,
2260 unsigned int flags)
2261 {
2262 struct lttng_metadata_stream *stream = in->private_data;
2263 struct lttng_kernel_ring_buffer *buf = stream->priv;
2264
2265 return lib_ring_buffer_splice_read(in, ppos, pipe, len,
2266 flags, buf);
2267 }
2268
2269 static
2270 int lttng_metadata_ring_buffer_mmap(struct file *filp,
2271 struct vm_area_struct *vma)
2272 {
2273 struct lttng_metadata_stream *stream = filp->private_data;
2274 struct lttng_kernel_ring_buffer *buf = stream->priv;
2275
2276 return lib_ring_buffer_mmap(filp, vma, buf);
2277 }
2278
2279 static
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,
2291 #endif
2292 };
2293
2294 static
2295 int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
2296 const struct file_operations *fops, const char *name)
2297 {
2298 int stream_fd, ret;
2299 struct file *stream_file;
2300
2301 stream_fd = get_unused_fd_flags(0);
2302 if (stream_fd < 0) {
2303 ret = stream_fd;
2304 goto fd_error;
2305 }
2306 stream_file = anon_inode_getfile(name, fops, stream_priv, O_RDWR);
2307 if (IS_ERR(stream_file)) {
2308 ret = PTR_ERR(stream_file);
2309 goto file_error;
2310 }
2311 /*
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.
2315 */
2316 stream_file->f_mode |= FMODE_PREAD;
2317 fd_install(stream_fd, stream_file);
2318 /*
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.
2322 */
2323 return stream_fd;
2324
2325 file_error:
2326 put_unused_fd(stream_fd);
2327 fd_error:
2328 return ret;
2329 }
2330
2331 static
2332 int lttng_abi_open_stream(struct file *channel_file)
2333 {
2334 struct lttng_kernel_channel_buffer *channel = channel_file->private_data;
2335 struct lttng_kernel_ring_buffer *buf;
2336 int ret;
2337 void *stream_priv;
2338
2339 buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan);
2340 if (!buf)
2341 return -ENOENT;
2342
2343 stream_priv = buf;
2344 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
2345 &lttng_stream_ring_buffer_file_operations,
2346 "[lttng_stream]");
2347 if (ret < 0)
2348 goto fd_error;
2349
2350 return ret;
2351
2352 fd_error:
2353 channel->ops->priv->buffer_read_close(buf);
2354 return ret;
2355 }
2356
2357 static
2358 int lttng_abi_open_metadata_stream(struct file *channel_file)
2359 {
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;
2363 int ret;
2364 struct lttng_metadata_stream *metadata_stream;
2365 void *stream_priv;
2366
2367 buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan);
2368 if (!buf)
2369 return -ENOENT;
2370
2371 metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
2372 GFP_KERNEL);
2373 if (!metadata_stream) {
2374 ret = -ENOMEM;
2375 goto nomem;
2376 }
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;
2384
2385 /*
2386 * Since life-time of metadata cache differs from that of
2387 * session, we need to keep our own reference on the transport.
2388 */
2389 if (!try_module_get(metadata_stream->transport->owner)) {
2390 printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
2391 ret = -EINVAL;
2392 goto notransport;
2393 }
2394
2395 if (!lttng_kref_get(&session->priv->metadata_cache->refcount)) {
2396 ret = -EOVERFLOW;
2397 goto kref_error;
2398 }
2399
2400 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
2401 &lttng_metadata_ring_buffer_file_operations,
2402 "[lttng_metadata_stream]");
2403 if (ret < 0)
2404 goto fd_error;
2405
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);
2410 return ret;
2411
2412 fd_error:
2413 kref_put(&session->priv->metadata_cache->refcount, metadata_cache_destroy);
2414 kref_error:
2415 module_put(metadata_stream->transport->owner);
2416 notransport:
2417 kfree(metadata_stream);
2418 nomem:
2419 channel->ops->priv->buffer_read_close(buf);
2420 return ret;
2421 }
2422
2423 static
2424 int lttng_abi_open_event_notifier_group_stream(struct file *notif_file)
2425 {
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;
2429 int ret;
2430 void *stream_priv;
2431
2432 buf = event_notifier_group->ops->priv->buffer_read_open(chan);
2433 if (!buf)
2434 return -ENOENT;
2435
2436 /* The event_notifier notification fd holds a reference on the event_notifier group */
2437 if (!atomic_long_add_unless(&notif_file->f_count, 1, LONG_MAX)) {
2438 ret = -EOVERFLOW;
2439 goto refcount_error;
2440 }
2441 event_notifier_group->buf = buf;
2442 stream_priv = event_notifier_group;
2443 ret = lttng_abi_create_stream_fd(notif_file, stream_priv,
2444 &lttng_event_notifier_group_notif_fops,
2445 "[lttng_event_notifier_stream]");
2446 if (ret < 0)
2447 goto fd_error;
2448
2449 return ret;
2450
2451 fd_error:
2452 atomic_long_dec(&notif_file->f_count);
2453 refcount_error:
2454 event_notifier_group->ops->priv->buffer_read_close(buf);
2455 return ret;
2456 }
2457
2458 static
2459 int lttng_abi_validate_event_param(struct lttng_kernel_abi_event *event_param,
2460 struct lttng_kernel_abi_event_ext *event_param_ext)
2461 {
2462 enum lttng_kernel_abi_match_check match_check;
2463
2464 if (user_event_param_ext_get_match_check(event_param_ext, &match_check))
2465 return -EINVAL;
2466
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:
2472 lttng_fallthrough;
2473 case LTTNG_KERNEL_ABI_SYSCALL_ENTRY:
2474 lttng_fallthrough;
2475 case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
2476 break;
2477 default:
2478 return -EINVAL;
2479 }
2480 switch (event_param->u.syscall.abi) {
2481 case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
2482 break;
2483 default:
2484 return -EINVAL;
2485 }
2486 switch (event_param->u.syscall.match) {
2487 case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME:
2488 break;
2489 default:
2490 return -EINVAL;
2491 }
2492 switch (match_check) {
2493 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2494 lttng_fallthrough;
2495 case LTTNG_KERNEL_ABI_MATCH_LAZY:
2496 break;
2497 default:
2498 return -EINVAL;
2499 }
2500 break;
2501
2502 case LTTNG_KERNEL_ABI_KRETPROBE:
2503 switch (event_param->u.kretprobe.entryexit) {
2504 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRYEXIT:
2505 lttng_fallthrough;
2506 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRY:
2507 lttng_fallthrough;
2508 case LTTNG_KERNEL_ABI_KRETPROBE_EXIT:
2509 break;
2510 default:
2511 return -EINVAL;
2512 }
2513 switch (match_check) {
2514 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2515 lttng_fallthrough;
2516 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
2517 break;
2518 default:
2519 return -EINVAL;
2520 }
2521 break;
2522
2523 case LTTNG_KERNEL_ABI_TRACEPOINT:
2524 switch (match_check) {
2525 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2526 lttng_fallthrough;
2527 case LTTNG_KERNEL_ABI_MATCH_LAZY:
2528 break;
2529 default:
2530 return -EINVAL;
2531 }
2532 break;
2533
2534 case LTTNG_KERNEL_ABI_KPROBE:
2535 lttng_fallthrough;
2536 case LTTNG_KERNEL_ABI_UPROBE:
2537 switch (match_check) {
2538 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2539 lttng_fallthrough;
2540 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
2541 break;
2542 default:
2543 return -EINVAL;
2544 }
2545 break;
2546
2547 case LTTNG_KERNEL_ABI_FUNCTION:
2548 lttng_fallthrough;
2549 case LTTNG_KERNEL_ABI_NOOP:
2550 lttng_fallthrough;
2551 default:
2552 return -EINVAL;
2553 }
2554 return 0;
2555 }
2556
2557 static
2558 int lttng_abi_validate_event_match(struct lttng_kernel_abi_event *event_param,
2559 struct lttng_kernel_abi_event_ext *event_param_ext)
2560 {
2561 enum lttng_kernel_abi_match_check match_check;
2562 int ret;
2563
2564 if (user_event_param_ext_get_match_check(event_param_ext, &match_check))
2565 return -EINVAL;
2566
2567 /* Validate match */
2568 if (match_check == LTTNG_KERNEL_ABI_MATCH_DEFAULT) {
2569 switch (event_param->instrumentation) {
2570 case LTTNG_KERNEL_ABI_TRACEPOINT:
2571 lttng_fallthrough;
2572 case LTTNG_KERNEL_ABI_SYSCALL:
2573 match_check = LTTNG_KERNEL_ABI_MATCH_LAZY;
2574 break;
2575 case LTTNG_KERNEL_ABI_KPROBE:
2576 lttng_fallthrough;
2577 case LTTNG_KERNEL_ABI_KRETPROBE:
2578 lttng_fallthrough;
2579 case LTTNG_KERNEL_ABI_UPROBE:
2580 match_check = LTTNG_KERNEL_ABI_MATCH_IMMEDIATE;
2581 break;
2582
2583 case LTTNG_KERNEL_ABI_FUNCTION:
2584 lttng_fallthrough;
2585 case LTTNG_KERNEL_ABI_NOOP:
2586 lttng_fallthrough;
2587 default:
2588 return -EINVAL;
2589 }
2590 }
2591
2592 if (match_check == LTTNG_KERNEL_ABI_MATCH_IMMEDIATE) {
2593 switch (event_param->instrumentation) {
2594 break;
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);
2599 if (ret)
2600 return ret;
2601 break;
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);
2606 if (ret)
2607 return ret;
2608 break;
2609 case LTTNG_KERNEL_ABI_UPROBE:
2610 /*
2611 * uprobes are immediately created, which includes match checking.
2612 */
2613 break;
2614
2615 case LTTNG_KERNEL_ABI_TRACEPOINT:
2616 lttng_fallthrough;
2617 case LTTNG_KERNEL_ABI_SYSCALL:
2618 lttng_fallthrough;
2619 case LTTNG_KERNEL_ABI_FUNCTION:
2620 lttng_fallthrough;
2621 case LTTNG_KERNEL_ABI_NOOP:
2622 lttng_fallthrough;
2623 default:
2624 return -EINVAL;
2625 }
2626 }
2627 return 0;
2628 }
2629
2630 static
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)
2634 {
2635 const struct file_operations *fops;
2636 struct lttng_kernel_channel_buffer *channel = channel_file->private_data;
2637 int event_fd, ret;
2638 struct file *event_file;
2639 void *priv;
2640
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';
2645 break;
2646 case LTTNG_KERNEL_ABI_KPROBE:
2647 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
2648 break;
2649 case LTTNG_KERNEL_ABI_FUNCTION:
2650 WARN_ON_ONCE(1);
2651 /* Not implemented. */
2652 break;
2653 default:
2654 break;
2655 }
2656
2657 switch (event_param->instrumentation) {
2658 case LTTNG_KERNEL_ABI_TRACEPOINT:
2659 lttng_fallthrough;
2660 case LTTNG_KERNEL_ABI_SYSCALL:
2661 lttng_fallthrough;
2662 case LTTNG_KERNEL_ABI_KPROBE:
2663 lttng_fallthrough;
2664 case LTTNG_KERNEL_ABI_KRETPROBE:
2665 fops = &lttng_event_session_enabler_fops;
2666 break;
2667
2668 case LTTNG_KERNEL_ABI_UPROBE:
2669 fops = &lttng_event_session_fops;
2670 break;
2671
2672 case LTTNG_KERNEL_ABI_FUNCTION:
2673 lttng_fallthrough;
2674 case LTTNG_KERNEL_ABI_NOOP:
2675 lttng_fallthrough;
2676 default:
2677 return -EINVAL;
2678 }
2679
2680 event_fd = get_unused_fd_flags(0);
2681 if (event_fd < 0) {
2682 ret = event_fd;
2683 goto fd_error;
2684 }
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);
2689 goto file_error;
2690 }
2691 /* The event holds a reference on the channel */
2692 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
2693 ret = -EOVERFLOW;
2694 goto refcount_error;
2695 }
2696 ret = lttng_abi_validate_event_param(event_param, event_param_ext);
2697 if (ret)
2698 goto event_error;
2699 ret = lttng_abi_validate_event_match(event_param, event_param_ext);
2700 if (ret)
2701 goto event_error;
2702
2703 switch (event_param->instrumentation) {
2704 case LTTNG_KERNEL_ABI_TRACEPOINT:
2705 lttng_fallthrough;
2706 case LTTNG_KERNEL_ABI_SYSCALL:
2707 {
2708 struct lttng_event_recorder_enabler *event_enabler;
2709
2710 if (strutils_is_star_glob_pattern(event_param->name)) {
2711 /*
2712 * If the event name is a star globbing pattern,
2713 * we create the special star globbing enabler.
2714 */
2715 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
2716 event_param, channel);
2717 } else {
2718 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2719 event_param, channel);
2720 }
2721 if (event_enabler)
2722 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2723 priv = event_enabler;
2724 break;
2725 }
2726
2727 case LTTNG_KERNEL_ABI_KPROBE:
2728 lttng_fallthrough;
2729 case LTTNG_KERNEL_ABI_KRETPROBE:
2730 {
2731 struct lttng_event_recorder_enabler *event_enabler;
2732
2733 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2734 event_param, channel);
2735 if (event_enabler)
2736 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2737 priv = event_enabler;
2738 break;
2739 }
2740
2741 case LTTNG_KERNEL_ABI_UPROBE:
2742 {
2743 struct lttng_kernel_event_common *event;
2744 struct lttng_event_recorder_enabler *event_enabler;
2745
2746 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2747 event_param, channel);
2748 if (!event_enabler) {
2749 ret = -ENOMEM;
2750 goto event_error;
2751 }
2752 /*
2753 * We tolerate no failure path after event creation. It
2754 * will stay invariant for the rest of the session.
2755 */
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);
2760 goto event_error;
2761 }
2762 priv = event;
2763 break;
2764 }
2765
2766 case LTTNG_KERNEL_ABI_FUNCTION:
2767 lttng_fallthrough;
2768 case LTTNG_KERNEL_ABI_NOOP:
2769 lttng_fallthrough;
2770 default:
2771 ret = -EINVAL;
2772 goto event_error;
2773 }
2774 event_file->private_data = priv;
2775 fd_install(event_fd, event_file);
2776 return event_fd;
2777
2778 event_error:
2779 atomic_long_dec(&channel_file->f_count);
2780 refcount_error:
2781 fput(event_file);
2782 file_error:
2783 put_unused_fd(event_fd);
2784 fd_error:
2785 return ret;
2786 }
2787
2788 static
2789 int lttng_abi_create_event_counter_enabler(struct file *channel_file,
2790 struct lttng_kernel_counter_event *counter_event)
2791 {
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;
2797 int event_fd, ret;
2798 struct file *event_file;
2799 void *priv;
2800
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';
2805 break;
2806 case LTTNG_KERNEL_ABI_KPROBE:
2807 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
2808 break;
2809 case LTTNG_KERNEL_ABI_FUNCTION:
2810 WARN_ON_ONCE(1);
2811 /* Not implemented. */
2812 break;
2813 default:
2814 break;
2815 }
2816
2817 switch (event_param->instrumentation) {
2818 case LTTNG_KERNEL_ABI_TRACEPOINT:
2819 lttng_fallthrough;
2820 case LTTNG_KERNEL_ABI_SYSCALL:
2821 lttng_fallthrough;
2822 case LTTNG_KERNEL_ABI_KPROBE:
2823 lttng_fallthrough;
2824 case LTTNG_KERNEL_ABI_KRETPROBE:
2825 fops = &lttng_event_session_enabler_fops;
2826 break;
2827
2828 case LTTNG_KERNEL_ABI_UPROBE:
2829 fops = &lttng_event_session_fops;
2830 break;
2831
2832 case LTTNG_KERNEL_ABI_FUNCTION:
2833 lttng_fallthrough;
2834 case LTTNG_KERNEL_ABI_NOOP:
2835 lttng_fallthrough;
2836 default:
2837 return -EINVAL;
2838 }
2839
2840 event_fd = get_unused_fd_flags(0);
2841 if (event_fd < 0) {
2842 ret = event_fd;
2843 goto fd_error;
2844 }
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);
2849 goto file_error;
2850 }
2851 /* The event holds a reference on the channel */
2852 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
2853 ret = -EOVERFLOW;
2854 goto refcount_error;
2855 }
2856 ret = lttng_abi_validate_event_param(event_param, event_param_ext);
2857 if (ret)
2858 goto event_error;
2859 ret = lttng_abi_validate_event_match(event_param, event_param_ext);
2860 if (ret)
2861 goto event_error;
2862
2863 switch (event_param->instrumentation) {
2864 case LTTNG_KERNEL_ABI_TRACEPOINT:
2865 lttng_fallthrough;
2866 case LTTNG_KERNEL_ABI_SYSCALL:
2867 {
2868 struct lttng_event_counter_enabler *event_enabler;
2869
2870 if (strutils_is_star_glob_pattern(event_param->name)) {
2871 /*
2872 * If the event name is a star globbing pattern,
2873 * we create the special star globbing enabler.
2874 */
2875 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
2876 event_param, counter_key, channel);
2877 } else {
2878 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2879 event_param, counter_key, channel);
2880 }
2881 if (event_enabler)
2882 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2883 priv = event_enabler;
2884 break;
2885 }
2886
2887 case LTTNG_KERNEL_ABI_KPROBE:
2888 lttng_fallthrough;
2889 case LTTNG_KERNEL_ABI_KRETPROBE:
2890 {
2891 struct lttng_event_counter_enabler *event_enabler;
2892
2893 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2894 event_param, counter_key, channel);
2895 if (event_enabler)
2896 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2897 priv = event_enabler;
2898 break;
2899 }
2900
2901 case LTTNG_KERNEL_ABI_UPROBE:
2902 {
2903 struct lttng_kernel_event_common *event;
2904 struct lttng_event_counter_enabler *event_enabler;
2905
2906 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2907 event_param, counter_key, channel);
2908 if (!event_enabler) {
2909 ret = -ENOMEM;
2910 goto event_error;
2911 }
2912 /*
2913 * We tolerate no failure path after event creation. It
2914 * will stay invariant for the rest of the session.
2915 */
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);
2920 goto event_error;
2921 }
2922 priv = event;
2923 break;
2924 }
2925
2926 case LTTNG_KERNEL_ABI_FUNCTION:
2927 lttng_fallthrough;
2928 case LTTNG_KERNEL_ABI_NOOP:
2929 lttng_fallthrough;
2930 default:
2931 ret = -EINVAL;
2932 goto event_error;
2933 }
2934 event_file->private_data = priv;
2935 fd_install(event_fd, event_file);
2936 return event_fd;
2937
2938 event_error:
2939 atomic_long_dec(&channel_file->f_count);
2940 refcount_error:
2941 fput(event_file);
2942 file_error:
2943 put_unused_fd(event_fd);
2944 fd_error:
2945 return ret;
2946 }
2947
2948 static
2949 long lttng_event_notifier_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2950 {
2951 struct lttng_kernel_event_common *event = file->private_data;
2952
2953 switch (cmd) {
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:
2959 return -EINVAL;
2960 case LTTNG_KERNEL_ABI_CAPTURE:
2961 return -EINVAL;
2962 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
2963 return lttng_event_add_callsite(event,
2964 (struct lttng_kernel_abi_event_callsite __user *) arg);
2965 default:
2966 return -ENOIOCTLCMD;
2967 }
2968 }
2969
2970 static
2971 long lttng_event_notifier_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2972 {
2973 struct lttng_event_enabler_common *event = file->private_data;
2974
2975 switch (cmd) {
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:
2984 {
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);
2990 }
2991 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
2992 return -EINVAL;
2993 default:
2994 return -ENOIOCTLCMD;
2995 }
2996 }
2997
2998 static
2999 int lttng_event_notifier_event_release(struct inode *inode, struct file *file)
3000 {
3001 struct lttng_kernel_event_common *event = file->private_data;
3002
3003 if (event) {
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);
3007 }
3008 return 0;
3009 }
3010
3011 static
3012 int lttng_event_notifier_enabler_release(struct inode *inode, struct file *file)
3013 {
3014 struct lttng_event_enabler_common *event_enabler = file->private_data;
3015
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);
3020 }
3021 return 0;
3022 }
3023
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,
3030 #endif
3031 };
3032
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,
3039 #endif
3040 };
3041
3042 static
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)
3046 {
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;
3052 void *priv;
3053
3054 switch (event_notifier_param->event.instrumentation) {
3055 case LTTNG_KERNEL_ABI_TRACEPOINT:
3056 lttng_fallthrough;
3057 case LTTNG_KERNEL_ABI_SYSCALL:
3058 lttng_fallthrough;
3059 case LTTNG_KERNEL_ABI_KPROBE:
3060 lttng_fallthrough;
3061 case LTTNG_KERNEL_ABI_KRETPROBE:
3062 fops = &lttng_event_notifier_enabler_fops;
3063 break;
3064
3065 case LTTNG_KERNEL_ABI_UPROBE:
3066 fops = &lttng_event_notifier_event_fops;
3067 break;
3068
3069 case LTTNG_KERNEL_ABI_FUNCTION:
3070 lttng_fallthrough;
3071 case LTTNG_KERNEL_ABI_NOOP:
3072 lttng_fallthrough;
3073 default:
3074 ret = -EINVAL;
3075 goto inval_instr;
3076 }
3077
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';
3082 break;
3083 case LTTNG_KERNEL_ABI_KPROBE:
3084 event_notifier_param->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
3085 break;
3086 default:
3087 break;
3088 }
3089
3090 event_notifier_fd = get_unused_fd_flags(0);
3091 if (event_notifier_fd < 0) {
3092 ret = event_notifier_fd;
3093 goto fd_error;
3094 }
3095
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);
3100 goto file_error;
3101 }
3102
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)) {
3105 ret = -EOVERFLOW;
3106 goto refcount_error;
3107 }
3108
3109 ret = lttng_abi_validate_event_param(&event_notifier_param->event, event_param_ext);
3110 if (ret)
3111 goto event_notifier_error;
3112 ret = lttng_abi_validate_event_match(&event_notifier_param->event, event_param_ext);
3113 if (ret)
3114 goto event_notifier_error;
3115
3116 switch (event_notifier_param->event.instrumentation) {
3117 case LTTNG_KERNEL_ABI_TRACEPOINT:
3118 lttng_fallthrough;
3119 case LTTNG_KERNEL_ABI_SYSCALL:
3120 {
3121 struct lttng_event_notifier_enabler *enabler;
3122
3123 if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) {
3124 /*
3125 * If the event name is a star globbing pattern,
3126 * we create the special star globbing enabler.
3127 */
3128 enabler = lttng_event_notifier_enabler_create(
3129 LTTNG_ENABLER_FORMAT_STAR_GLOB,
3130 event_notifier_param,
3131 event_notifier_group);
3132 } else {
3133 enabler = lttng_event_notifier_enabler_create(
3134 LTTNG_ENABLER_FORMAT_NAME,
3135 event_notifier_param,
3136 event_notifier_group);
3137 }
3138 if (enabler)
3139 lttng_event_notifier_enabler_group_add(event_notifier_group, enabler);
3140 priv = enabler;
3141 break;
3142 }
3143
3144 case LTTNG_KERNEL_ABI_KPROBE:
3145 lttng_fallthrough;
3146 case LTTNG_KERNEL_ABI_KRETPROBE:
3147 {
3148 struct lttng_event_notifier_enabler *enabler;
3149
3150 enabler = lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
3151 event_notifier_param, event_notifier_group);
3152 if (enabler)
3153 lttng_event_notifier_enabler_group_add(event_notifier_group, enabler);
3154 priv = enabler;
3155 break;
3156 }
3157
3158 case LTTNG_KERNEL_ABI_UPROBE:
3159 {
3160 struct lttng_kernel_event_common *event;
3161 struct lttng_event_notifier_enabler *event_notifier_enabler;
3162
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) {
3166 ret = -ENOMEM;
3167 goto event_notifier_error;
3168 }
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;
3174 }
3175 priv = event;
3176 break;
3177 }
3178
3179 case LTTNG_KERNEL_ABI_FUNCTION:
3180 lttng_fallthrough;
3181 case LTTNG_KERNEL_ABI_NOOP:
3182 lttng_fallthrough;
3183 default:
3184 ret = -EINVAL;
3185 goto event_notifier_error;
3186 }
3187 event_notifier_file->private_data = priv;
3188 fd_install(event_notifier_fd, event_notifier_file);
3189 return event_notifier_fd;
3190
3191 event_notifier_error:
3192 atomic_long_dec(&event_notifier_group_file->f_count);
3193 refcount_error:
3194 fput(event_notifier_file);
3195 file_error:
3196 put_unused_fd(event_notifier_fd);
3197 fd_error:
3198 inval_instr:
3199 return ret;
3200 }
3201
3202 static
3203 long lttng_abi_session_create_counter(
3204 struct lttng_kernel_session *session,
3205 const struct lttng_kernel_counter_conf *counter_conf)
3206 {
3207 int counter_fd, ret;
3208 char *counter_transport_name;
3209 struct lttng_kernel_channel_counter *chan_counter = NULL;
3210 struct file *counter_file;
3211
3212 if (counter_conf->arithmetic != LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR) {
3213 printk(KERN_ERR "LTTng: Maps: Counter of the wrong arithmetic type.\n");
3214 return -EINVAL;
3215 }
3216
3217 switch (counter_conf->bitness) {
3218 case LTTNG_KERNEL_COUNTER_BITNESS_64:
3219 counter_transport_name = "counter-per-cpu-64-modular";
3220 break;
3221 case LTTNG_KERNEL_COUNTER_BITNESS_32:
3222 counter_transport_name = "counter-per-cpu-32-modular";
3223 break;
3224 default:
3225 return -EINVAL;
3226 }
3227
3228 lttng_lock_sessions();
3229
3230 counter_fd = get_unused_fd_flags(0);
3231 if (counter_fd < 0) {
3232 ret = counter_fd;
3233 goto fd_error;
3234 }
3235
3236 counter_file = anon_inode_getfile("[lttng_counter]",
3237 &lttng_counter_fops,
3238 NULL, O_RDONLY);
3239 if (IS_ERR(counter_file)) {
3240 ret = PTR_ERR(counter_file);
3241 goto file_error;
3242 }
3243
3244 if (!atomic_long_add_unless(&session->priv->file->f_count, 1, LONG_MAX)) {
3245 ret = -EOVERFLOW;
3246 goto refcount_error;
3247 }
3248
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) {
3252 ret = -EINVAL;
3253 goto create_error;
3254 }
3255
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;
3261
3262 fd_install(counter_fd, counter_file);
3263 lttng_unlock_sessions();
3264
3265 return counter_fd;
3266
3267 create_error:
3268 atomic_long_dec(&session->priv->file->f_count);
3269 refcount_error:
3270 fput(counter_file);
3271 file_error:
3272 put_unused_fd(counter_fd);
3273 fd_error:
3274 lttng_unlock_sessions();
3275 return ret;
3276 }
3277
3278 static
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)
3282 {
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;
3289 size_t counter_len;
3290
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");
3293 return -EINVAL;
3294 }
3295
3296 switch (counter_conf->bitness) {
3297 case LTTNG_KERNEL_COUNTER_BITNESS_64:
3298 counter_transport_name = "counter-per-cpu-64-modular";
3299 break;
3300 case LTTNG_KERNEL_COUNTER_BITNESS_32:
3301 counter_transport_name = "counter-per-cpu-32-modular";
3302 break;
3303 default:
3304 return -EINVAL;
3305 }
3306
3307 /*
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.
3311 */
3312 lttng_lock_sessions();
3313
3314 if (event_notifier_group->error_counter) {
3315 printk(KERN_ERR "Error counter already created in event_notifier group\n");
3316 ret = -EBUSY;
3317 goto fd_error;
3318 }
3319
3320 counter_fd = get_unused_fd_flags(0);
3321 if (counter_fd < 0) {
3322 ret = counter_fd;
3323 goto fd_error;
3324 }
3325
3326 counter_file = anon_inode_getfile("[lttng_counter]",
3327 &lttng_counter_fops,
3328 NULL, O_RDONLY);
3329 if (IS_ERR(counter_file)) {
3330 ret = PTR_ERR(counter_file);
3331 goto file_error;
3332 }
3333
3334 if (!atomic_long_add_unless(&event_notifier_group_file->f_count, 1, LONG_MAX)) {
3335 ret = -EOVERFLOW;
3336 goto refcount_error;
3337 }
3338
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) {
3342 ret = -EINVAL;
3343 goto create_error;
3344 }
3345
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;
3350 /*
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.
3354 */
3355 smp_store_release(&event_notifier_group->error_counter,
3356 chan_counter);
3357
3358 fd_install(counter_fd, counter_file);
3359 lttng_unlock_sessions();
3360
3361 return counter_fd;
3362
3363 create_error:
3364 atomic_long_dec(&event_notifier_group_file->f_count);
3365 refcount_error:
3366 fput(counter_file);
3367 file_error:
3368 put_unused_fd(counter_fd);
3369 fd_error:
3370 lttng_unlock_sessions();
3371 return ret;
3372 }
3373
3374 static
3375 long lttng_event_notifier_group_ioctl(struct file *file, unsigned int cmd,
3376 unsigned long arg)
3377 {
3378 int ret;
3379
3380 switch (cmd) {
3381 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD:
3382 {
3383 return lttng_abi_open_event_notifier_group_stream(file);
3384 }
3385 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_CREATE:
3386 {
3387 struct lttng_kernel_abi_event_notifier uevent_notifier_param;
3388 struct lttng_kernel_abi_event_ext uevent_param_ext = {};
3389 int ret;
3390
3391 if (copy_from_user(&uevent_notifier_param,
3392 (struct lttng_kernel_abi_event_notifier __user *) arg,
3393 sizeof(uevent_notifier_param)))
3394 return -EFAULT;
3395 ret = copy_user_event_param_ext(&uevent_param_ext, &uevent_notifier_param.event);
3396 if (ret)
3397 return ret;
3398 return lttng_abi_create_event_notifier(file, &uevent_notifier_param, &uevent_param_ext);
3399 }
3400 case LTTNG_KERNEL_ABI_OLD_COUNTER:
3401 {
3402 struct lttng_kernel_counter_conf counter_conf;
3403
3404 ret = lttng_abi_copy_user_old_counter_conf(&counter_conf,
3405 (struct lttng_kernel_abi_old_counter_conf __user *) arg);
3406 if (ret)
3407 return ret;
3408 return lttng_abi_event_notifier_group_create_error_counter(file, &counter_conf);
3409 }
3410 case LTTNG_KERNEL_ABI_COUNTER:
3411 {
3412 struct lttng_kernel_counter_conf counter_conf;
3413
3414 ret = lttng_abi_copy_user_counter_conf(&counter_conf,
3415 (struct lttng_kernel_abi_counter_conf __user *) arg);
3416 if (ret)
3417 return ret;
3418 return lttng_abi_event_notifier_group_create_error_counter(file, &counter_conf);
3419 }
3420 default:
3421 return -ENOIOCTLCMD;
3422 }
3423 return 0;
3424 }
3425
3426 static
3427 int lttng_event_notifier_group_release(struct inode *inode, struct file *file)
3428 {
3429 struct lttng_event_notifier_group *event_notifier_group =
3430 file->private_data;
3431
3432 if (event_notifier_group)
3433 lttng_event_notifier_group_destroy(event_notifier_group);
3434 return 0;
3435 }
3436
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,
3443 #endif
3444 };
3445
3446 /**
3447 * lttng_channel_ioctl - lttng syscall through ioctl
3448 *
3449 * @file: the file
3450 * @cmd: the command
3451 * @arg: command arg
3452 *
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)
3465 *
3466 * Channel and event file descriptors also hold a reference on the session.
3467 */
3468 static
3469 long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3470 {
3471 struct lttng_kernel_channel_buffer *channel = file->private_data;
3472
3473 switch (cmd) {
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:
3478 {
3479 struct lttng_kernel_abi_event *uevent_param;
3480 struct lttng_kernel_abi_old_event *old_uevent_param;
3481 int ret;
3482
3483 uevent_param = kmalloc(sizeof(struct lttng_kernel_abi_event),
3484 GFP_KERNEL);
3485 if (!uevent_param) {
3486 ret = -ENOMEM;
3487 goto old_event_end;
3488 }
3489 old_uevent_param = kmalloc(
3490 sizeof(struct lttng_kernel_abi_old_event),
3491 GFP_KERNEL);
3492 if (!old_uevent_param) {
3493 ret = -ENOMEM;
3494 goto old_event_error_free_param;
3495 }
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))) {
3499 ret = -EFAULT;
3500 goto old_event_error_free_old_param;
3501 }
3502
3503 memcpy(uevent_param->name, old_uevent_param->name,
3504 sizeof(uevent_param->name));
3505 uevent_param->instrumentation =
3506 old_uevent_param->instrumentation;
3507
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));
3517 break;
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));
3526 break;
3527 case LTTNG_KERNEL_ABI_FUNCTION:
3528 WARN_ON_ONCE(1);
3529 /* Not implemented. */
3530 break;
3531 default:
3532 break;
3533 }
3534 ret = lttng_abi_create_event_recorder_enabler(file, uevent_param, NULL);
3535
3536 old_event_error_free_old_param:
3537 kfree(old_uevent_param);
3538 old_event_error_free_param:
3539 kfree(uevent_param);
3540 old_event_end:
3541 return ret;
3542 }
3543 case LTTNG_KERNEL_ABI_EVENT:
3544 {
3545 struct lttng_kernel_abi_event uevent_param;
3546 struct lttng_kernel_abi_event_ext uevent_param_ext = {};
3547 int ret;
3548
3549 if (copy_from_user(&uevent_param,
3550 (struct lttng_kernel_abi_event __user *) arg,
3551 sizeof(uevent_param)))
3552 return -EFAULT;
3553 ret = copy_user_event_param_ext(&uevent_param_ext, &uevent_param);
3554 if (ret)
3555 return ret;
3556 return lttng_abi_create_event_recorder_enabler(file, &uevent_param, &uevent_param_ext);
3557 }
3558 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
3559 {
3560 struct lttng_kernel_abi_context *ucontext_param;
3561 struct lttng_kernel_abi_old_context *old_ucontext_param;
3562 int ret;
3563
3564 ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_context),
3565 GFP_KERNEL);
3566 if (!ucontext_param) {
3567 ret = -ENOMEM;
3568 goto old_ctx_end;
3569 }
3570 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_old_context),
3571 GFP_KERNEL);
3572 if (!old_ucontext_param) {
3573 ret = -ENOMEM;
3574 goto old_ctx_error_free_param;
3575 }
3576
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))) {
3580 ret = -EFAULT;
3581 goto old_ctx_error_free_old_param;
3582 }
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));
3595 }
3596
3597 ret = lttng_abi_add_context(file,
3598 ucontext_param,
3599 &channel->priv->ctx, channel->parent.session);
3600
3601 old_ctx_error_free_old_param:
3602 kfree(old_ucontext_param);
3603 old_ctx_error_free_param:
3604 kfree(ucontext_param);
3605 old_ctx_end:
3606 return ret;
3607 }
3608 case LTTNG_KERNEL_ABI_CONTEXT:
3609 {
3610 struct lttng_kernel_abi_context ucontext_param;
3611
3612 if (copy_from_user(&ucontext_param,
3613 (struct lttng_kernel_abi_context __user *) arg,
3614 sizeof(ucontext_param)))
3615 return -EFAULT;
3616 return lttng_abi_add_context(file,
3617 &ucontext_param,
3618 &channel->priv->ctx, channel->parent.session);
3619 }
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);
3629 default:
3630 return -ENOIOCTLCMD;
3631 }
3632 }
3633
3634 /**
3635 * lttng_metadata_ioctl - lttng syscall through ioctl
3636 *
3637 * @file: the file
3638 * @cmd: the command
3639 * @arg: command arg
3640 *
3641 * This ioctl implements lttng commands:
3642 * LTTNG_KERNEL_ABI_STREAM
3643 * Returns an event stream file descriptor or failure.
3644 *
3645 * Channel and event file descriptors also hold a reference on the session.
3646 */
3647 static
3648 long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3649 {
3650 switch (cmd) {
3651 case LTTNG_KERNEL_ABI_OLD_STREAM:
3652 case LTTNG_KERNEL_ABI_STREAM:
3653 return lttng_abi_open_metadata_stream(file);
3654 default:
3655 return -ENOIOCTLCMD;
3656 }
3657 }
3658
3659 /**
3660 * lttng_channel_poll - lttng stream addition/removal monitoring
3661 *
3662 * @file: the file
3663 * @wait: poll table
3664 */
3665 static
3666 unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
3667 {
3668 struct lttng_kernel_channel_buffer *channel = file->private_data;
3669 unsigned int mask = 0;
3670
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),
3674 wait);
3675
3676 if (channel->ops->priv->is_disabled(channel->priv->rb_chan))
3677 return POLLERR;
3678 if (channel->ops->priv->is_finalized(channel->priv->rb_chan))
3679 return POLLHUP;
3680 if (channel->ops->priv->buffer_has_read_closed_stream(channel->priv->rb_chan))
3681 return POLLIN | POLLRDNORM;
3682 return 0;
3683 }
3684 return mask;
3685
3686 }
3687
3688 static
3689 int lttng_channel_release(struct inode *inode, struct file *file)
3690 {
3691 struct lttng_kernel_channel_buffer *channel = file->private_data;
3692
3693 if (channel)
3694 fput(channel->parent.session->priv->file);
3695 return 0;
3696 }
3697
3698 static
3699 int lttng_metadata_channel_release(struct inode *inode, struct file *file)
3700 {
3701 struct lttng_kernel_channel_buffer *channel = file->private_data;
3702
3703 if (channel) {
3704 fput(channel->parent.session->priv->file);
3705 lttng_metadata_channel_buffer_destroy(channel);
3706 }
3707
3708 return 0;
3709 }
3710
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,
3718 #endif
3719 };
3720
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,
3727 #endif
3728 };
3729
3730 /**
3731 * lttng_event_ioctl - lttng syscall through ioctl
3732 *
3733 * @file: the file
3734 * @cmd: the command
3735 * @arg: command arg
3736 *
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)
3744 */
3745 static
3746 long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3747 {
3748 struct lttng_kernel_event_common *event = file->private_data;
3749
3750 switch (cmd) {
3751 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
3752 {
3753 /* Not implemented */
3754 return -ENOSYS;
3755 }
3756 case LTTNG_KERNEL_ABI_CONTEXT:
3757 {
3758 /* Not implemented */
3759 return -ENOSYS;
3760 }
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:
3768 return -EINVAL;
3769 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
3770 return lttng_event_add_callsite(event,
3771 (struct lttng_kernel_abi_event_callsite __user *) arg);
3772 default:
3773 return -ENOIOCTLCMD;
3774 }
3775 }
3776
3777 /**
3778 * lttng_event_recorder_enabler_ioctl - lttng syscall through ioctl
3779 *
3780 * @file: the file
3781 * @cmd: the command
3782 * @arg: command arg
3783 *
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)
3791 */
3792 static
3793 long lttng_event_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3794 {
3795 struct lttng_event_enabler_common *event_enabler = file->private_data;
3796
3797 switch (cmd) {
3798 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
3799 {
3800 /* Not implemented */
3801 return -ENOSYS;
3802 }
3803 case LTTNG_KERNEL_ABI_CONTEXT:
3804 {
3805 /* Not implemented */
3806 return -ENOSYS;
3807 }
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:
3815 /*
3816 * Filters are only supported by tracepoint and syscall instrumentation.
3817 */
3818 switch (event_enabler->event_param.instrumentation) {
3819 case LTTNG_KERNEL_ABI_TRACEPOINT:
3820 lttng_fallthrough;
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);
3824
3825 default:
3826 return -EINVAL;
3827 }
3828 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
3829 return -EINVAL;
3830 default:
3831 return -ENOIOCTLCMD;
3832 }
3833 }
3834
3835 static
3836 int lttng_event_session_release(struct inode *inode, struct file *file)
3837 {
3838 struct lttng_kernel_event_common *event = file->private_data;
3839
3840 if (event) {
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);
3844 }
3845 return 0;
3846 }
3847
3848 static
3849 int lttng_event_session_enabler_release(struct inode *inode, struct file *file)
3850 {
3851 struct lttng_event_enabler_common *event_enabler = file->private_data;
3852
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);
3857 }
3858 return 0;
3859 }
3860
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,
3867 #endif
3868 };
3869
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,
3876 #endif
3877 };
3878
3879 static int put_u64(uint64_t val, unsigned long arg)
3880 {
3881 return put_user(val, (uint64_t __user *) arg);
3882 }
3883
3884 static int put_u32(uint32_t val, unsigned long arg)
3885 {
3886 return put_user(val, (uint32_t __user *) arg);
3887 }
3888
3889 static long lttng_stream_ring_buffer_ioctl(struct file *filp,
3890 unsigned int cmd, unsigned long arg)
3891 {
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;
3896 int ret;
3897
3898 if (atomic_read(&chan->record_disabled))
3899 return -EIO;
3900
3901 switch (cmd) {
3902 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_BEGIN:
3903 {
3904 uint64_t ts;
3905
3906 ret = ops->priv->timestamp_begin(config, buf, &ts);
3907 if (ret < 0)
3908 goto error;
3909 return put_u64(ts, arg);
3910 }
3911 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_END:
3912 {
3913 uint64_t ts;
3914
3915 ret = ops->priv->timestamp_end(config, buf, &ts);
3916 if (ret < 0)
3917 goto error;
3918 return put_u64(ts, arg);
3919 }
3920 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_EVENTS_DISCARDED:
3921 {
3922 uint64_t ed;
3923
3924 ret = ops->priv->events_discarded(config, buf, &ed);
3925 if (ret < 0)
3926 goto error;
3927 return put_u64(ed, arg);
3928 }
3929 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CONTENT_SIZE:
3930 {
3931 uint64_t cs;
3932
3933 ret = ops->priv->content_size(config, buf, &cs);
3934 if (ret < 0)
3935 goto error;
3936 return put_u64(cs, arg);
3937 }
3938 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_PACKET_SIZE:
3939 {
3940 uint64_t ps;
3941
3942 ret = ops->priv->packet_size(config, buf, &ps);
3943 if (ret < 0)
3944 goto error;
3945 return put_u64(ps, arg);
3946 }
3947 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_STREAM_ID:
3948 {
3949 uint64_t si;
3950
3951 ret = ops->priv->stream_id(config, buf, &si);
3952 if (ret < 0)
3953 goto error;
3954 return put_u64(si, arg);
3955 }
3956 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP:
3957 {
3958 uint64_t ts;
3959
3960 ret = ops->priv->current_timestamp(config, buf, &ts);
3961 if (ret < 0)
3962 goto error;
3963 return put_u64(ts, arg);
3964 }
3965 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SEQ_NUM:
3966 {
3967 uint64_t seq;
3968
3969 ret = ops->priv->sequence_number(config, buf, &seq);
3970 if (ret < 0)
3971 goto error;
3972 return put_u64(seq, arg);
3973 }
3974 case LTTNG_KERNEL_ABI_RING_BUFFER_INSTANCE_ID:
3975 {
3976 uint64_t id;
3977
3978 ret = ops->priv->instance_id(config, buf, &id);
3979 if (ret < 0)
3980 goto error;
3981 return put_u64(id, arg);
3982 }
3983 default:
3984 return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
3985 cmd, arg);
3986 }
3987
3988 error:
3989 return -ENOSYS;
3990 }
3991
3992 #ifdef CONFIG_COMPAT
3993 static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp,
3994 unsigned int cmd, unsigned long arg)
3995 {
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;
4000 int ret;
4001
4002 if (atomic_read(&chan->record_disabled))
4003 return -EIO;
4004
4005 switch (cmd) {
4006 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN:
4007 {
4008 uint64_t ts;
4009
4010 ret = ops->priv->timestamp_begin(config, buf, &ts);
4011 if (ret < 0)
4012 goto error;
4013 return put_u64(ts, arg);
4014 }
4015 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_END:
4016 {
4017 uint64_t ts;
4018
4019 ret = ops->priv->timestamp_end(config, buf, &ts);
4020 if (ret < 0)
4021 goto error;
4022 return put_u64(ts, arg);
4023 }
4024 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED:
4025 {
4026 uint64_t ed;
4027
4028 ret = ops->priv->events_discarded(config, buf, &ed);
4029 if (ret < 0)
4030 goto error;
4031 return put_u64(ed, arg);
4032 }
4033 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_CONTENT_SIZE:
4034 {
4035 uint64_t cs;
4036
4037 ret = ops->priv->content_size(config, buf, &cs);
4038 if (ret < 0)
4039 goto error;
4040 return put_u64(cs, arg);
4041 }
4042 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_PACKET_SIZE:
4043 {
4044 uint64_t ps;
4045
4046 ret = ops->priv->packet_size(config, buf, &ps);
4047 if (ret < 0)
4048 goto error;
4049 return put_u64(ps, arg);
4050 }
4051 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_STREAM_ID:
4052 {
4053 uint64_t si;
4054
4055 ret = ops->priv->stream_id(config, buf, &si);
4056 if (ret < 0)
4057 goto error;
4058 return put_u64(si, arg);
4059 }
4060 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP:
4061 {
4062 uint64_t ts;
4063
4064 ret = ops->priv->current_timestamp(config, buf, &ts);
4065 if (ret < 0)
4066 goto error;
4067 return put_u64(ts, arg);
4068 }
4069 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_SEQ_NUM:
4070 {
4071 uint64_t seq;
4072
4073 ret = ops->priv->sequence_number(config, buf, &seq);
4074 if (ret < 0)
4075 goto error;
4076 return put_u64(seq, arg);
4077 }
4078 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_INSTANCE_ID:
4079 {
4080 uint64_t id;
4081
4082 ret = ops->priv->instance_id(config, buf, &id);
4083 if (ret < 0)
4084 goto error;
4085 return put_u64(id, arg);
4086 }
4087 default:
4088 return lib_ring_buffer_file_operations.compat_ioctl(filp,
4089 cmd, arg);
4090 }
4091
4092 error:
4093 return -ENOSYS;
4094 }
4095 #endif /* CONFIG_COMPAT */
4096
4097 static void lttng_stream_override_ring_buffer_fops(void)
4098 {
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;
4117 #endif
4118 }
4119
4120 int __init lttng_abi_init(void)
4121 {
4122 int ret = 0;
4123
4124 wrapper_vmalloc_sync_mappings();
4125 lttng_clock_ref();
4126
4127 ret = lttng_tp_mempool_init();
4128 if (ret) {
4129 goto error;
4130 }
4131
4132 lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
4133 &lttng_proc_ops, NULL);
4134
4135 if (!lttng_proc_dentry) {
4136 printk(KERN_ERR "LTTng: Error creating control file\n");
4137 ret = -ENOMEM;
4138 goto error;
4139 }
4140 lttng_stream_override_ring_buffer_fops();
4141 return 0;
4142
4143 error:
4144 lttng_tp_mempool_destroy();
4145 lttng_clock_unref();
4146 return ret;
4147 }
4148
4149 /* No __exit annotation because used by init error path too. */
4150 void lttng_abi_exit(void)
4151 {
4152 lttng_tp_mempool_destroy();
4153 lttng_clock_unref();
4154 if (lttng_proc_dentry)
4155 remove_proc_entry("lttng", NULL);
4156 }
LTTng 2.0/0.x modules
This page took 0.103353 seconds and 5 git commands to generate.