projects / lttng-modules.git / blob
? search:


64ea99da27fc6e126358f223f25972d74bac301f
[lttng-modules.git] / lttng-abi.c
1 /* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
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 <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/anon_inodes.h>
29 #include <linux/file.h>
30 #include <linux/uaccess.h>
31 #include <linux/slab.h>
32 #include <linux/err.h>
33 #include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
34 #include <wrapper/ringbuffer/vfs.h>
35 #include <wrapper/ringbuffer/backend.h>
36 #include <wrapper/ringbuffer/frontend.h>
37 #include <wrapper/poll.h>
38 #include <wrapper/file.h>
39 #include <wrapper/kref.h>
40 #include <lttng-string-utils.h>
41 #include <lttng-abi.h>
42 #include <lttng-abi-old.h>
43 #include <lttng-events.h>
44 #include <lttng-tracer.h>
45 #include <lttng-tp-mempool.h>
46 #include <lib/ringbuffer/frontend_types.h>
47
48 /*
49 * This is LTTng's own personal way to create a system call as an external
50 * module. We use ioctl() on /proc/lttng.
51 */
52
53 static struct proc_dir_entry *lttng_proc_dentry;
54
55 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
56 static const struct proc_ops lttng_proc_ops;
57 #else
58 static const struct file_operations lttng_proc_ops;
59 #endif
60
61 static const struct file_operations lttng_session_fops;
62 static const struct file_operations lttng_channel_fops;
63 static const struct file_operations lttng_metadata_fops;
64 static const struct file_operations lttng_event_fops;
65 static struct file_operations lttng_stream_ring_buffer_file_operations;
66
67 static int put_u64(uint64_t val, unsigned long arg);
68 static int put_u32(uint32_t val, unsigned long arg);
69
70 /*
71 * Teardown management: opened file descriptors keep a refcount on the module,
72 * so it can only exit when all file descriptors are closed.
73 */
74
75 static
76 int lttng_abi_create_session(void)
77 {
78 struct lttng_session *session;
79 struct file *session_file;
80 int session_fd, ret;
81
82 session = lttng_session_create();
83 if (!session)
84 return -ENOMEM;
85 session_fd = lttng_get_unused_fd();
86 if (session_fd < 0) {
87 ret = session_fd;
88 goto fd_error;
89 }
90 session_file = anon_inode_getfile("[lttng_session]",
91 &lttng_session_fops,
92 session, O_RDWR);
93 if (IS_ERR(session_file)) {
94 ret = PTR_ERR(session_file);
95 goto file_error;
96 }
97 session->file = session_file;
98 fd_install(session_fd, session_file);
99 return session_fd;
100
101 file_error:
102 put_unused_fd(session_fd);
103 fd_error:
104 lttng_session_destroy(session);
105 return ret;
106 }
107
108 static
109 int lttng_abi_tracepoint_list(void)
110 {
111 struct file *tracepoint_list_file;
112 int file_fd, ret;
113
114 file_fd = lttng_get_unused_fd();
115 if (file_fd < 0) {
116 ret = file_fd;
117 goto fd_error;
118 }
119
120 tracepoint_list_file = anon_inode_getfile("[lttng_tracepoint_list]",
121 &lttng_tracepoint_list_fops,
122 NULL, O_RDWR);
123 if (IS_ERR(tracepoint_list_file)) {
124 ret = PTR_ERR(tracepoint_list_file);
125 goto file_error;
126 }
127 ret = lttng_tracepoint_list_fops.open(NULL, tracepoint_list_file);
128 if (ret < 0)
129 goto open_error;
130 fd_install(file_fd, tracepoint_list_file);
131 return file_fd;
132
133 open_error:
134 fput(tracepoint_list_file);
135 file_error:
136 put_unused_fd(file_fd);
137 fd_error:
138 return ret;
139 }
140
141 #ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
142 static inline
143 int lttng_abi_syscall_list(void)
144 {
145 return -ENOSYS;
146 }
147 #else
148 static
149 int lttng_abi_syscall_list(void)
150 {
151 struct file *syscall_list_file;
152 int file_fd, ret;
153
154 file_fd = lttng_get_unused_fd();
155 if (file_fd < 0) {
156 ret = file_fd;
157 goto fd_error;
158 }
159
160 syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
161 &lttng_syscall_list_fops,
162 NULL, O_RDWR);
163 if (IS_ERR(syscall_list_file)) {
164 ret = PTR_ERR(syscall_list_file);
165 goto file_error;
166 }
167 ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
168 if (ret < 0)
169 goto open_error;
170 fd_install(file_fd, syscall_list_file);
171 return file_fd;
172
173 open_error:
174 fput(syscall_list_file);
175 file_error:
176 put_unused_fd(file_fd);
177 fd_error:
178 return ret;
179 }
180 #endif
181
182 static
183 void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v)
184 {
185 v->major = LTTNG_MODULES_MAJOR_VERSION;
186 v->minor = LTTNG_MODULES_MINOR_VERSION;
187 v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
188 }
189
190 static
191 void lttng_abi_tracer_abi_version(struct lttng_kernel_tracer_abi_version *v)
192 {
193 v->major = LTTNG_MODULES_ABI_MAJOR_VERSION;
194 v->minor = LTTNG_MODULES_ABI_MINOR_VERSION;
195 }
196
197 static
198 long lttng_abi_add_context(struct file *file,
199 struct lttng_kernel_context *context_param,
200 struct lttng_ctx **ctx, struct lttng_session *session)
201 {
202
203 if (session->been_active)
204 return -EPERM;
205
206 switch (context_param->ctx) {
207 case LTTNG_KERNEL_CONTEXT_PID:
208 return lttng_add_pid_to_ctx(ctx);
209 case LTTNG_KERNEL_CONTEXT_PRIO:
210 return lttng_add_prio_to_ctx(ctx);
211 case LTTNG_KERNEL_CONTEXT_NICE:
212 return lttng_add_nice_to_ctx(ctx);
213 case LTTNG_KERNEL_CONTEXT_VPID:
214 return lttng_add_vpid_to_ctx(ctx);
215 case LTTNG_KERNEL_CONTEXT_TID:
216 return lttng_add_tid_to_ctx(ctx);
217 case LTTNG_KERNEL_CONTEXT_VTID:
218 return lttng_add_vtid_to_ctx(ctx);
219 case LTTNG_KERNEL_CONTEXT_PPID:
220 return lttng_add_ppid_to_ctx(ctx);
221 case LTTNG_KERNEL_CONTEXT_VPPID:
222 return lttng_add_vppid_to_ctx(ctx);
223 case LTTNG_KERNEL_CONTEXT_PERF_COUNTER:
224 context_param->u.perf_counter.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
225 return lttng_add_perf_counter_to_ctx(context_param->u.perf_counter.type,
226 context_param->u.perf_counter.config,
227 context_param->u.perf_counter.name,
228 ctx);
229 case LTTNG_KERNEL_CONTEXT_PROCNAME:
230 return lttng_add_procname_to_ctx(ctx);
231 case LTTNG_KERNEL_CONTEXT_HOSTNAME:
232 return lttng_add_hostname_to_ctx(ctx);
233 case LTTNG_KERNEL_CONTEXT_CPU_ID:
234 return lttng_add_cpu_id_to_ctx(ctx);
235 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE:
236 return lttng_add_interruptible_to_ctx(ctx);
237 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE:
238 return lttng_add_need_reschedule_to_ctx(ctx);
239 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE:
240 return lttng_add_preemptible_to_ctx(ctx);
241 case LTTNG_KERNEL_CONTEXT_MIGRATABLE:
242 return lttng_add_migratable_to_ctx(ctx);
243 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL:
244 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER:
245 return lttng_add_callstack_to_ctx(ctx, context_param->ctx);
246 case LTTNG_KERNEL_CONTEXT_CGROUP_NS:
247 return lttng_add_cgroup_ns_to_ctx(ctx);
248 case LTTNG_KERNEL_CONTEXT_IPC_NS:
249 return lttng_add_ipc_ns_to_ctx(ctx);
250 case LTTNG_KERNEL_CONTEXT_MNT_NS:
251 return lttng_add_mnt_ns_to_ctx(ctx);
252 case LTTNG_KERNEL_CONTEXT_NET_NS:
253 return lttng_add_net_ns_to_ctx(ctx);
254 case LTTNG_KERNEL_CONTEXT_PID_NS:
255 return lttng_add_pid_ns_to_ctx(ctx);
256 case LTTNG_KERNEL_CONTEXT_USER_NS:
257 return lttng_add_user_ns_to_ctx(ctx);
258 case LTTNG_KERNEL_CONTEXT_UTS_NS:
259 return lttng_add_uts_ns_to_ctx(ctx);
260 case LTTNG_KERNEL_CONTEXT_UID:
261 return lttng_add_uid_to_ctx(ctx);
262 case LTTNG_KERNEL_CONTEXT_EUID:
263 return lttng_add_euid_to_ctx(ctx);
264 case LTTNG_KERNEL_CONTEXT_SUID:
265 return lttng_add_suid_to_ctx(ctx);
266 case LTTNG_KERNEL_CONTEXT_GID:
267 return lttng_add_gid_to_ctx(ctx);
268 case LTTNG_KERNEL_CONTEXT_EGID:
269 return lttng_add_egid_to_ctx(ctx);
270 case LTTNG_KERNEL_CONTEXT_SGID:
271 return lttng_add_sgid_to_ctx(ctx);
272 case LTTNG_KERNEL_CONTEXT_VUID:
273 return lttng_add_vuid_to_ctx(ctx);
274 case LTTNG_KERNEL_CONTEXT_VEUID:
275 return lttng_add_veuid_to_ctx(ctx);
276 case LTTNG_KERNEL_CONTEXT_VSUID:
277 return lttng_add_vsuid_to_ctx(ctx);
278 case LTTNG_KERNEL_CONTEXT_VGID:
279 return lttng_add_vgid_to_ctx(ctx);
280 case LTTNG_KERNEL_CONTEXT_VEGID:
281 return lttng_add_vegid_to_ctx(ctx);
282 case LTTNG_KERNEL_CONTEXT_VSGID:
283 return lttng_add_vsgid_to_ctx(ctx);
284 default:
285 return -EINVAL;
286 }
287 }
288
289 /**
290 * lttng_ioctl - lttng syscall through ioctl
291 *
292 * @file: the file
293 * @cmd: the command
294 * @arg: command arg
295 *
296 * This ioctl implements lttng commands:
297 * LTTNG_KERNEL_SESSION
298 * Returns a LTTng trace session file descriptor
299 * LTTNG_KERNEL_TRACER_VERSION
300 * Returns the LTTng kernel tracer version
301 * LTTNG_KERNEL_TRACEPOINT_LIST
302 * Returns a file descriptor listing available tracepoints
303 * LTTNG_KERNEL_WAIT_QUIESCENT
304 * Returns after all previously running probes have completed
305 * LTTNG_KERNEL_TRACER_ABI_VERSION
306 * Returns the LTTng kernel tracer ABI version
307 *
308 * The returned session will be deleted when its file descriptor is closed.
309 */
310 static
311 long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
312 {
313 switch (cmd) {
314 case LTTNG_KERNEL_OLD_SESSION:
315 case LTTNG_KERNEL_SESSION:
316 return lttng_abi_create_session();
317 case LTTNG_KERNEL_OLD_TRACER_VERSION:
318 {
319 struct lttng_kernel_tracer_version v;
320 struct lttng_kernel_old_tracer_version oldv;
321 struct lttng_kernel_old_tracer_version *uversion =
322 (struct lttng_kernel_old_tracer_version __user *) arg;
323
324 lttng_abi_tracer_version(&v);
325 oldv.major = v.major;
326 oldv.minor = v.minor;
327 oldv.patchlevel = v.patchlevel;
328
329 if (copy_to_user(uversion, &oldv, sizeof(oldv)))
330 return -EFAULT;
331 return 0;
332 }
333 case LTTNG_KERNEL_TRACER_VERSION:
334 {
335 struct lttng_kernel_tracer_version version;
336 struct lttng_kernel_tracer_version *uversion =
337 (struct lttng_kernel_tracer_version __user *) arg;
338
339 lttng_abi_tracer_version(&version);
340
341 if (copy_to_user(uversion, &version, sizeof(version)))
342 return -EFAULT;
343 return 0;
344 }
345 case LTTNG_KERNEL_TRACER_ABI_VERSION:
346 {
347 struct lttng_kernel_tracer_abi_version version;
348 struct lttng_kernel_tracer_abi_version *uversion =
349 (struct lttng_kernel_tracer_abi_version __user *) arg;
350
351 lttng_abi_tracer_abi_version(&version);
352
353 if (copy_to_user(uversion, &version, sizeof(version)))
354 return -EFAULT;
355 return 0;
356 }
357 case LTTNG_KERNEL_OLD_TRACEPOINT_LIST:
358 case LTTNG_KERNEL_TRACEPOINT_LIST:
359 return lttng_abi_tracepoint_list();
360 case LTTNG_KERNEL_SYSCALL_LIST:
361 return lttng_abi_syscall_list();
362 case LTTNG_KERNEL_OLD_WAIT_QUIESCENT:
363 case LTTNG_KERNEL_WAIT_QUIESCENT:
364 synchronize_trace();
365 return 0;
366 case LTTNG_KERNEL_OLD_CALIBRATE:
367 {
368 struct lttng_kernel_old_calibrate __user *ucalibrate =
369 (struct lttng_kernel_old_calibrate __user *) arg;
370 struct lttng_kernel_old_calibrate old_calibrate;
371 struct lttng_kernel_calibrate calibrate;
372 int ret;
373
374 if (copy_from_user(&old_calibrate, ucalibrate, sizeof(old_calibrate)))
375 return -EFAULT;
376 calibrate.type = old_calibrate.type;
377 ret = lttng_calibrate(&calibrate);
378 if (copy_to_user(ucalibrate, &old_calibrate, sizeof(old_calibrate)))
379 return -EFAULT;
380 return ret;
381 }
382 case LTTNG_KERNEL_CALIBRATE:
383 {
384 struct lttng_kernel_calibrate __user *ucalibrate =
385 (struct lttng_kernel_calibrate __user *) arg;
386 struct lttng_kernel_calibrate calibrate;
387 int ret;
388
389 if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate)))
390 return -EFAULT;
391 ret = lttng_calibrate(&calibrate);
392 if (copy_to_user(ucalibrate, &calibrate, sizeof(calibrate)))
393 return -EFAULT;
394 return ret;
395 }
396 default:
397 return -ENOIOCTLCMD;
398 }
399 }
400
401 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
402 static const struct proc_ops lttng_proc_ops = {
403 .proc_ioctl = lttng_ioctl,
404 #ifdef CONFIG_COMPAT
405 .proc_compat_ioctl = lttng_ioctl,
406 #endif /* CONFIG_COMPAT */
407 };
408 #else
409 static const struct file_operations lttng_proc_ops = {
410 .owner = THIS_MODULE,
411 .unlocked_ioctl = lttng_ioctl,
412 #ifdef CONFIG_COMPAT
413 .compat_ioctl = lttng_ioctl,
414 #endif /* CONFIG_COMPAT */
415 };
416 #endif
417
418 static
419 int lttng_abi_create_channel(struct file *session_file,
420 struct lttng_kernel_channel *chan_param,
421 enum channel_type channel_type)
422 {
423 struct lttng_session *session = session_file->private_data;
424 const struct file_operations *fops = NULL;
425 const char *transport_name;
426 struct lttng_channel *chan;
427 struct file *chan_file;
428 int chan_fd;
429 int ret = 0;
430
431 chan_fd = lttng_get_unused_fd();
432 if (chan_fd < 0) {
433 ret = chan_fd;
434 goto fd_error;
435 }
436 switch (channel_type) {
437 case PER_CPU_CHANNEL:
438 fops = &lttng_channel_fops;
439 break;
440 case METADATA_CHANNEL:
441 fops = &lttng_metadata_fops;
442 break;
443 }
444
445 chan_file = anon_inode_getfile("[lttng_channel]",
446 fops,
447 NULL, O_RDWR);
448 if (IS_ERR(chan_file)) {
449 ret = PTR_ERR(chan_file);
450 goto file_error;
451 }
452 switch (channel_type) {
453 case PER_CPU_CHANNEL:
454 if (chan_param->output == LTTNG_KERNEL_SPLICE) {
455 transport_name = chan_param->overwrite ?
456 "relay-overwrite" : "relay-discard";
457 } else if (chan_param->output == LTTNG_KERNEL_MMAP) {
458 transport_name = chan_param->overwrite ?
459 "relay-overwrite-mmap" : "relay-discard-mmap";
460 } else {
461 return -EINVAL;
462 }
463 break;
464 case METADATA_CHANNEL:
465 if (chan_param->output == LTTNG_KERNEL_SPLICE)
466 transport_name = "relay-metadata";
467 else if (chan_param->output == LTTNG_KERNEL_MMAP)
468 transport_name = "relay-metadata-mmap";
469 else
470 return -EINVAL;
471 break;
472 default:
473 transport_name = "<unknown>";
474 break;
475 }
476 if (!atomic_long_add_unless(&session_file->f_count, 1, LONG_MAX)) {
477 ret = -EOVERFLOW;
478 goto refcount_error;
479 }
480 /*
481 * We tolerate no failure path after channel creation. It will stay
482 * invariant for the rest of the session.
483 */
484 chan = lttng_channel_create(session, transport_name, NULL,
485 chan_param->subbuf_size,
486 chan_param->num_subbuf,
487 chan_param->switch_timer_interval,
488 chan_param->read_timer_interval,
489 channel_type);
490 if (!chan) {
491 ret = -EINVAL;
492 goto chan_error;
493 }
494 chan->file = chan_file;
495 chan_file->private_data = chan;
496 fd_install(chan_fd, chan_file);
497
498 return chan_fd;
499
500 chan_error:
501 atomic_long_dec(&session_file->f_count);
502 refcount_error:
503 fput(chan_file);
504 file_error:
505 put_unused_fd(chan_fd);
506 fd_error:
507 return ret;
508 }
509
510 static
511 int lttng_abi_session_set_name(struct lttng_session *session,
512 struct lttng_kernel_session_name *name)
513 {
514 size_t len;
515
516 len = strnlen(name->name, LTTNG_KERNEL_SESSION_NAME_LEN);
517
518 if (len == LTTNG_KERNEL_SESSION_NAME_LEN) {
519 /* Name is too long/malformed */
520 return -EINVAL;
521 }
522
523 strcpy(session->name, name->name);
524 return 0;
525 }
526
527 static
528 int lttng_abi_session_set_creation_time(struct lttng_session *session,
529 struct lttng_kernel_session_creation_time *time)
530 {
531 size_t len;
532
533 len = strnlen(time->iso8601, LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN);
534
535 if (len == LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN) {
536 /* Time is too long/malformed */
537 return -EINVAL;
538 }
539
540 strcpy(session->creation_time, time->iso8601);
541 return 0;
542 }
543
544 static
545 enum tracker_type get_tracker_type(struct lttng_kernel_tracker_args *tracker)
546 {
547 switch (tracker->type) {
548 case LTTNG_KERNEL_TRACKER_PID:
549 return TRACKER_PID;
550 case LTTNG_KERNEL_TRACKER_VPID:
551 return TRACKER_VPID;
552 case LTTNG_KERNEL_TRACKER_UID:
553 return TRACKER_UID;
554 case LTTNG_KERNEL_TRACKER_VUID:
555 return TRACKER_VUID;
556 case LTTNG_KERNEL_TRACKER_GID:
557 return TRACKER_GID;
558 case LTTNG_KERNEL_TRACKER_VGID:
559 return TRACKER_VGID;
560 default:
561 return TRACKER_UNKNOWN;
562 }
563 }
564
565 /**
566 * lttng_session_ioctl - lttng session fd ioctl
567 *
568 * @file: the file
569 * @cmd: the command
570 * @arg: command arg
571 *
572 * This ioctl implements lttng commands:
573 * LTTNG_KERNEL_CHANNEL
574 * Returns a LTTng channel file descriptor
575 * LTTNG_KERNEL_ENABLE
576 * Enables tracing for a session (weak enable)
577 * LTTNG_KERNEL_DISABLE
578 * Disables tracing for a session (strong disable)
579 * LTTNG_KERNEL_METADATA
580 * Returns a LTTng metadata file descriptor
581 * LTTNG_KERNEL_SESSION_TRACK_PID
582 * Add PID to session PID tracker
583 * LTTNG_KERNEL_SESSION_UNTRACK_PID
584 * Remove PID from session PID tracker
585 * LTTNG_KERNEL_SESSION_TRACK_ID
586 * Add ID to tracker
587 * LTTNG_KERNEL_SESSION_UNTRACK_ID
588 * Remove ID from tracker
589 *
590 * The returned channel will be deleted when its file descriptor is closed.
591 */
592 static
593 long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
594 {
595 struct lttng_session *session = file->private_data;
596 struct lttng_kernel_channel chan_param;
597 struct lttng_kernel_old_channel old_chan_param;
598
599 switch (cmd) {
600 case LTTNG_KERNEL_OLD_CHANNEL:
601 {
602 if (copy_from_user(&old_chan_param,
603 (struct lttng_kernel_old_channel __user *) arg,
604 sizeof(struct lttng_kernel_old_channel)))
605 return -EFAULT;
606 chan_param.overwrite = old_chan_param.overwrite;
607 chan_param.subbuf_size = old_chan_param.subbuf_size;
608 chan_param.num_subbuf = old_chan_param.num_subbuf;
609 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
610 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
611 chan_param.output = old_chan_param.output;
612
613 return lttng_abi_create_channel(file, &chan_param,
614 PER_CPU_CHANNEL);
615 }
616 case LTTNG_KERNEL_CHANNEL:
617 {
618 if (copy_from_user(&chan_param,
619 (struct lttng_kernel_channel __user *) arg,
620 sizeof(struct lttng_kernel_channel)))
621 return -EFAULT;
622 return lttng_abi_create_channel(file, &chan_param,
623 PER_CPU_CHANNEL);
624 }
625 case LTTNG_KERNEL_OLD_SESSION_START:
626 case LTTNG_KERNEL_OLD_ENABLE:
627 case LTTNG_KERNEL_SESSION_START:
628 case LTTNG_KERNEL_ENABLE:
629 return lttng_session_enable(session);
630 case LTTNG_KERNEL_OLD_SESSION_STOP:
631 case LTTNG_KERNEL_OLD_DISABLE:
632 case LTTNG_KERNEL_SESSION_STOP:
633 case LTTNG_KERNEL_DISABLE:
634 return lttng_session_disable(session);
635 case LTTNG_KERNEL_OLD_METADATA:
636 {
637 if (copy_from_user(&old_chan_param,
638 (struct lttng_kernel_old_channel __user *) arg,
639 sizeof(struct lttng_kernel_old_channel)))
640 return -EFAULT;
641 chan_param.overwrite = old_chan_param.overwrite;
642 chan_param.subbuf_size = old_chan_param.subbuf_size;
643 chan_param.num_subbuf = old_chan_param.num_subbuf;
644 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
645 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
646 chan_param.output = old_chan_param.output;
647
648 return lttng_abi_create_channel(file, &chan_param,
649 METADATA_CHANNEL);
650 }
651 case LTTNG_KERNEL_METADATA:
652 {
653 if (copy_from_user(&chan_param,
654 (struct lttng_kernel_channel __user *) arg,
655 sizeof(struct lttng_kernel_channel)))
656 return -EFAULT;
657 return lttng_abi_create_channel(file, &chan_param,
658 METADATA_CHANNEL);
659 }
660 case LTTNG_KERNEL_SESSION_TRACK_PID:
661 return lttng_session_track_id(session, TRACKER_PID, (int) arg);
662 case LTTNG_KERNEL_SESSION_UNTRACK_PID:
663 return lttng_session_untrack_id(session, TRACKER_PID, (int) arg);
664 case LTTNG_KERNEL_SESSION_TRACK_ID:
665 {
666 struct lttng_kernel_tracker_args tracker;
667 enum tracker_type tracker_type;
668
669 if (copy_from_user(&tracker,
670 (struct lttng_kernel_tracker_args __user *) arg,
671 sizeof(struct lttng_kernel_tracker_args)))
672 return -EFAULT;
673 tracker_type = get_tracker_type(&tracker);
674 if (tracker_type == TRACKER_UNKNOWN)
675 return -EINVAL;
676 return lttng_session_track_id(session, tracker_type, tracker.id);
677 }
678 case LTTNG_KERNEL_SESSION_UNTRACK_ID:
679 {
680 struct lttng_kernel_tracker_args tracker;
681 enum tracker_type tracker_type;
682
683 if (copy_from_user(&tracker,
684 (struct lttng_kernel_tracker_args __user *) arg,
685 sizeof(struct lttng_kernel_tracker_args)))
686 return -EFAULT;
687 tracker_type = get_tracker_type(&tracker);
688 if (tracker_type == TRACKER_UNKNOWN)
689 return -EINVAL;
690 return lttng_session_untrack_id(session, tracker_type,
691 tracker.id);
692 }
693 case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS:
694 return lttng_session_list_tracker_ids(session, TRACKER_PID);
695 case LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS:
696 {
697 struct lttng_kernel_tracker_args tracker;
698 enum tracker_type tracker_type;
699
700 if (copy_from_user(&tracker,
701 (struct lttng_kernel_tracker_args __user *) arg,
702 sizeof(struct lttng_kernel_tracker_args)))
703 return -EFAULT;
704 tracker_type = get_tracker_type(&tracker);
705 if (tracker_type == TRACKER_UNKNOWN)
706 return -EINVAL;
707 return lttng_session_list_tracker_ids(session, tracker_type);
708 }
709 case LTTNG_KERNEL_SESSION_METADATA_REGEN:
710 return lttng_session_metadata_regenerate(session);
711 case LTTNG_KERNEL_SESSION_STATEDUMP:
712 return lttng_session_statedump(session);
713 case LTTNG_KERNEL_SESSION_SET_NAME:
714 {
715 struct lttng_kernel_session_name name;
716
717 if (copy_from_user(&name,
718 (struct lttng_kernel_session_name __user *) arg,
719 sizeof(struct lttng_kernel_session_name)))
720 return -EFAULT;
721 return lttng_abi_session_set_name(session, &name);
722 }
723 case LTTNG_KERNEL_SESSION_SET_CREATION_TIME:
724 {
725 struct lttng_kernel_session_creation_time time;
726
727 if (copy_from_user(&time,
728 (struct lttng_kernel_session_creation_time __user *) arg,
729 sizeof(struct lttng_kernel_session_creation_time)))
730 return -EFAULT;
731 return lttng_abi_session_set_creation_time(session, &time);
732 }
733 default:
734 return -ENOIOCTLCMD;
735 }
736 }
737
738 /*
739 * Called when the last file reference is dropped.
740 *
741 * Big fat note: channels and events are invariant for the whole session after
742 * their creation. So this session destruction also destroys all channel and
743 * event structures specific to this session (they are not destroyed when their
744 * individual file is released).
745 */
746 static
747 int lttng_session_release(struct inode *inode, struct file *file)
748 {
749 struct lttng_session *session = file->private_data;
750
751 if (session)
752 lttng_session_destroy(session);
753 return 0;
754 }
755
756 static const struct file_operations lttng_session_fops = {
757 .owner = THIS_MODULE,
758 .release = lttng_session_release,
759 .unlocked_ioctl = lttng_session_ioctl,
760 #ifdef CONFIG_COMPAT
761 .compat_ioctl = lttng_session_ioctl,
762 #endif
763 };
764
765 /**
766 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
767 * @filp: the file
768 * @wait: poll table
769 *
770 * Handles the poll operations for the metadata channels.
771 */
772 static
773 unsigned int lttng_metadata_ring_buffer_poll(struct file *filp,
774 poll_table *wait)
775 {
776 struct lttng_metadata_stream *stream = filp->private_data;
777 struct lib_ring_buffer *buf = stream->priv;
778 int finalized;
779 unsigned int mask = 0;
780
781 if (filp->f_mode & FMODE_READ) {
782 poll_wait_set_exclusive(wait);
783 poll_wait(filp, &stream->read_wait, wait);
784
785 finalized = stream->finalized;
786
787 /*
788 * lib_ring_buffer_is_finalized() contains a smp_rmb()
789 * ordering finalized load before offsets loads.
790 */
791 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
792
793 if (finalized)
794 mask |= POLLHUP;
795
796 mutex_lock(&stream->metadata_cache->lock);
797 if (stream->metadata_cache->metadata_written >
798 stream->metadata_out)
799 mask |= POLLIN;
800 mutex_unlock(&stream->metadata_cache->lock);
801 }
802
803 return mask;
804 }
805
806 static
807 void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file *filp,
808 unsigned int cmd, unsigned long arg)
809 {
810 struct lttng_metadata_stream *stream = filp->private_data;
811
812 stream->metadata_out = stream->metadata_in;
813 }
814
815 /*
816 * Reset the counter of how much metadata has been consumed to 0. That way,
817 * the consumer receives the content of the metadata cache unchanged. This is
818 * different from the metadata_regenerate where the offset from epoch is
819 * resampled, here we want the exact same content as the last time the metadata
820 * was generated. This command is only possible if all the metadata written
821 * in the cache has been output to the metadata stream to avoid corrupting the
822 * metadata file.
823 *
824 * Return 0 on success, a negative value on error.
825 */
826 static
827 int lttng_metadata_cache_dump(struct lttng_metadata_stream *stream)
828 {
829 int ret;
830 struct lttng_metadata_cache *cache = stream->metadata_cache;
831
832 mutex_lock(&cache->lock);
833 if (stream->metadata_out != cache->metadata_written) {
834 ret = -EBUSY;
835 goto end;
836 }
837 stream->metadata_out = 0;
838 stream->metadata_in = 0;
839 wake_up_interruptible(&stream->read_wait);
840 ret = 0;
841
842 end:
843 mutex_unlock(&cache->lock);
844 return ret;
845 }
846
847 static
848 long lttng_metadata_ring_buffer_ioctl(struct file *filp,
849 unsigned int cmd, unsigned long arg)
850 {
851 int ret;
852 struct lttng_metadata_stream *stream = filp->private_data;
853 struct lib_ring_buffer *buf = stream->priv;
854 unsigned int rb_cmd;
855 bool coherent;
856
857 if (cmd == RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
858 rb_cmd = RING_BUFFER_GET_NEXT_SUBBUF;
859 else
860 rb_cmd = cmd;
861
862 switch (cmd) {
863 case RING_BUFFER_GET_NEXT_SUBBUF:
864 {
865 struct lttng_metadata_stream *stream = filp->private_data;
866 struct lib_ring_buffer *buf = stream->priv;
867 struct channel *chan = buf->backend.chan;
868
869 ret = lttng_metadata_output_channel(stream, chan, NULL);
870 if (ret > 0) {
871 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
872 ret = 0;
873 } else if (ret < 0)
874 goto err;
875 break;
876 }
877 case RING_BUFFER_GET_SUBBUF:
878 {
879 /*
880 * Random access is not allowed for metadata channel.
881 */
882 return -ENOSYS;
883 }
884 case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
885 case RING_BUFFER_FLUSH:
886 {
887 struct lttng_metadata_stream *stream = filp->private_data;
888 struct lib_ring_buffer *buf = stream->priv;
889 struct channel *chan = buf->backend.chan;
890
891 /*
892 * Before doing the actual ring buffer flush, write up to one
893 * packet of metadata in the ring buffer.
894 */
895 ret = lttng_metadata_output_channel(stream, chan, NULL);
896 if (ret < 0)
897 goto err;
898 break;
899 }
900 case RING_BUFFER_GET_METADATA_VERSION:
901 {
902 struct lttng_metadata_stream *stream = filp->private_data;
903
904 return put_u64(stream->version, arg);
905 }
906 case RING_BUFFER_METADATA_CACHE_DUMP:
907 {
908 struct lttng_metadata_stream *stream = filp->private_data;
909
910 return lttng_metadata_cache_dump(stream);
911 }
912 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
913 {
914 struct lttng_metadata_stream *stream = filp->private_data;
915 struct lib_ring_buffer *buf = stream->priv;
916 struct channel *chan = buf->backend.chan;
917
918 ret = lttng_metadata_output_channel(stream, chan, &coherent);
919 if (ret > 0) {
920 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
921 ret = 0;
922 } else if (ret < 0) {
923 goto err;
924 }
925 break;
926 }
927 default:
928 break;
929 }
930 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
931
932 /* Performing lib ring buffer ioctl after our own. */
933 ret = lib_ring_buffer_ioctl(filp, rb_cmd, arg, buf);
934 if (ret < 0)
935 goto err;
936
937 switch (cmd) {
938 case RING_BUFFER_PUT_NEXT_SUBBUF:
939 {
940 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
941 cmd, arg);
942 break;
943 }
944 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
945 {
946 return put_u32(coherent, arg);
947 }
948 default:
949 break;
950 }
951 err:
952 return ret;
953 }
954
955 #ifdef CONFIG_COMPAT
956 static
957 long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp,
958 unsigned int cmd, unsigned long arg)
959 {
960 int ret;
961 struct lttng_metadata_stream *stream = filp->private_data;
962 struct lib_ring_buffer *buf = stream->priv;
963 unsigned int rb_cmd;
964 bool coherent;
965
966 if (cmd == RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
967 rb_cmd = RING_BUFFER_GET_NEXT_SUBBUF;
968 else
969 rb_cmd = cmd;
970
971 switch (cmd) {
972 case RING_BUFFER_GET_NEXT_SUBBUF:
973 {
974 struct lttng_metadata_stream *stream = filp->private_data;
975 struct lib_ring_buffer *buf = stream->priv;
976 struct channel *chan = buf->backend.chan;
977
978 ret = lttng_metadata_output_channel(stream, chan, NULL);
979 if (ret > 0) {
980 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
981 ret = 0;
982 } else if (ret < 0)
983 goto err;
984 break;
985 }
986 case RING_BUFFER_GET_SUBBUF:
987 {
988 /*
989 * Random access is not allowed for metadata channel.
990 */
991 return -ENOSYS;
992 }
993 case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
994 case RING_BUFFER_FLUSH:
995 {
996 struct lttng_metadata_stream *stream = filp->private_data;
997 struct lib_ring_buffer *buf = stream->priv;
998 struct channel *chan = buf->backend.chan;
999
1000 /*
1001 * Before doing the actual ring buffer flush, write up to one
1002 * packet of metadata in the ring buffer.
1003 */
1004 ret = lttng_metadata_output_channel(stream, chan, NULL);
1005 if (ret < 0)
1006 goto err;
1007 break;
1008 }
1009 case RING_BUFFER_GET_METADATA_VERSION:
1010 {
1011 struct lttng_metadata_stream *stream = filp->private_data;
1012
1013 return put_u64(stream->version, arg);
1014 }
1015 case RING_BUFFER_METADATA_CACHE_DUMP:
1016 {
1017 struct lttng_metadata_stream *stream = filp->private_data;
1018
1019 return lttng_metadata_cache_dump(stream);
1020 }
1021 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
1022 {
1023 struct lttng_metadata_stream *stream = filp->private_data;
1024 struct lib_ring_buffer *buf = stream->priv;
1025 struct channel *chan = buf->backend.chan;
1026
1027 ret = lttng_metadata_output_channel(stream, chan, &coherent);
1028 if (ret > 0) {
1029 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
1030 ret = 0;
1031 } else if (ret < 0) {
1032 goto err;
1033 }
1034 break;
1035 }
1036 default:
1037 break;
1038 }
1039 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
1040
1041 /* Performing lib ring buffer ioctl after our own. */
1042 ret = lib_ring_buffer_compat_ioctl(filp, rb_cmd, arg, buf);
1043 if (ret < 0)
1044 goto err;
1045
1046 switch (cmd) {
1047 case RING_BUFFER_PUT_NEXT_SUBBUF:
1048 {
1049 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
1050 cmd, arg);
1051 break;
1052 }
1053 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
1054 {
1055 return put_u32(coherent, arg);
1056 }
1057 default:
1058 break;
1059 }
1060 err:
1061 return ret;
1062 }
1063 #endif
1064
1065 /*
1066 * This is not used by anonymous file descriptors. This code is left
1067 * there if we ever want to implement an inode with open() operation.
1068 */
1069 static
1070 int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file)
1071 {
1072 struct lttng_metadata_stream *stream = inode->i_private;
1073 struct lib_ring_buffer *buf = stream->priv;
1074
1075 file->private_data = buf;
1076 /*
1077 * Since life-time of metadata cache differs from that of
1078 * session, we need to keep our own reference on the transport.
1079 */
1080 if (!try_module_get(stream->transport->owner)) {
1081 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
1082 return -EBUSY;
1083 }
1084 return lib_ring_buffer_open(inode, file, buf);
1085 }
1086
1087 static
1088 int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file)
1089 {
1090 struct lttng_metadata_stream *stream = file->private_data;
1091 struct lib_ring_buffer *buf = stream->priv;
1092
1093 mutex_lock(&stream->metadata_cache->lock);
1094 list_del(&stream->list);
1095 mutex_unlock(&stream->metadata_cache->lock);
1096 kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
1097 module_put(stream->transport->owner);
1098 kfree(stream);
1099 return lib_ring_buffer_release(inode, file, buf);
1100 }
1101
1102 static
1103 ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
1104 struct pipe_inode_info *pipe, size_t len,
1105 unsigned int flags)
1106 {
1107 struct lttng_metadata_stream *stream = in->private_data;
1108 struct lib_ring_buffer *buf = stream->priv;
1109
1110 return lib_ring_buffer_splice_read(in, ppos, pipe, len,
1111 flags, buf);
1112 }
1113
1114 static
1115 int lttng_metadata_ring_buffer_mmap(struct file *filp,
1116 struct vm_area_struct *vma)
1117 {
1118 struct lttng_metadata_stream *stream = filp->private_data;
1119 struct lib_ring_buffer *buf = stream->priv;
1120
1121 return lib_ring_buffer_mmap(filp, vma, buf);
1122 }
1123
1124 static
1125 const struct file_operations lttng_metadata_ring_buffer_file_operations = {
1126 .owner = THIS_MODULE,
1127 .open = lttng_metadata_ring_buffer_open,
1128 .release = lttng_metadata_ring_buffer_release,
1129 .poll = lttng_metadata_ring_buffer_poll,
1130 .splice_read = lttng_metadata_ring_buffer_splice_read,
1131 .mmap = lttng_metadata_ring_buffer_mmap,
1132 .unlocked_ioctl = lttng_metadata_ring_buffer_ioctl,
1133 .llseek = vfs_lib_ring_buffer_no_llseek,
1134 #ifdef CONFIG_COMPAT
1135 .compat_ioctl = lttng_metadata_ring_buffer_compat_ioctl,
1136 #endif
1137 };
1138
1139 static
1140 int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
1141 const struct file_operations *fops)
1142 {
1143 int stream_fd, ret;
1144 struct file *stream_file;
1145
1146 stream_fd = lttng_get_unused_fd();
1147 if (stream_fd < 0) {
1148 ret = stream_fd;
1149 goto fd_error;
1150 }
1151 stream_file = anon_inode_getfile("[lttng_stream]", fops,
1152 stream_priv, O_RDWR);
1153 if (IS_ERR(stream_file)) {
1154 ret = PTR_ERR(stream_file);
1155 goto file_error;
1156 }
1157 /*
1158 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
1159 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
1160 * file descriptor, so we set FMODE_PREAD here.
1161 */
1162 stream_file->f_mode |= FMODE_PREAD;
1163 fd_install(stream_fd, stream_file);
1164 /*
1165 * The stream holds a reference to the channel within the generic ring
1166 * buffer library, so no need to hold a refcount on the channel and
1167 * session files here.
1168 */
1169 return stream_fd;
1170
1171 file_error:
1172 put_unused_fd(stream_fd);
1173 fd_error:
1174 return ret;
1175 }
1176
1177 static
1178 int lttng_abi_open_stream(struct file *channel_file)
1179 {
1180 struct lttng_channel *channel = channel_file->private_data;
1181 struct lib_ring_buffer *buf;
1182 int ret;
1183 void *stream_priv;
1184
1185 buf = channel->ops->buffer_read_open(channel->chan);
1186 if (!buf)
1187 return -ENOENT;
1188
1189 stream_priv = buf;
1190 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
1191 &lttng_stream_ring_buffer_file_operations);
1192 if (ret < 0)
1193 goto fd_error;
1194
1195 return ret;
1196
1197 fd_error:
1198 channel->ops->buffer_read_close(buf);
1199 return ret;
1200 }
1201
1202 static
1203 int lttng_abi_open_metadata_stream(struct file *channel_file)
1204 {
1205 struct lttng_channel *channel = channel_file->private_data;
1206 struct lttng_session *session = channel->session;
1207 struct lib_ring_buffer *buf;
1208 int ret;
1209 struct lttng_metadata_stream *metadata_stream;
1210 void *stream_priv;
1211
1212 buf = channel->ops->buffer_read_open(channel->chan);
1213 if (!buf)
1214 return -ENOENT;
1215
1216 metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
1217 GFP_KERNEL);
1218 if (!metadata_stream) {
1219 ret = -ENOMEM;
1220 goto nomem;
1221 }
1222 metadata_stream->metadata_cache = session->metadata_cache;
1223 init_waitqueue_head(&metadata_stream->read_wait);
1224 metadata_stream->priv = buf;
1225 stream_priv = metadata_stream;
1226 metadata_stream->transport = channel->transport;
1227 /* Initial state is an empty metadata, considered as incoherent. */
1228 metadata_stream->coherent = false;
1229
1230 /*
1231 * Since life-time of metadata cache differs from that of
1232 * session, we need to keep our own reference on the transport.
1233 */
1234 if (!try_module_get(metadata_stream->transport->owner)) {
1235 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
1236 ret = -EINVAL;
1237 goto notransport;
1238 }
1239
1240 if (!lttng_kref_get(&session->metadata_cache->refcount)) {
1241 ret = -EOVERFLOW;
1242 goto kref_error;
1243 }
1244
1245 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
1246 &lttng_metadata_ring_buffer_file_operations);
1247 if (ret < 0)
1248 goto fd_error;
1249
1250 mutex_lock(&session->metadata_cache->lock);
1251 list_add(&metadata_stream->list,
1252 &session->metadata_cache->metadata_stream);
1253 mutex_unlock(&session->metadata_cache->lock);
1254 return ret;
1255
1256 fd_error:
1257 kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
1258 kref_error:
1259 module_put(metadata_stream->transport->owner);
1260 notransport:
1261 kfree(metadata_stream);
1262 nomem:
1263 channel->ops->buffer_read_close(buf);
1264 return ret;
1265 }
1266
1267 static
1268 int lttng_abi_create_event(struct file *channel_file,
1269 struct lttng_kernel_event *event_param)
1270 {
1271 struct lttng_channel *channel = channel_file->private_data;
1272 int event_fd, ret;
1273 struct file *event_file;
1274 void *priv;
1275
1276 event_param->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
1277 switch (event_param->instrumentation) {
1278 case LTTNG_KERNEL_KRETPROBE:
1279 event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
1280 break;
1281 case LTTNG_KERNEL_KPROBE:
1282 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
1283 break;
1284 case LTTNG_KERNEL_FUNCTION:
1285 WARN_ON_ONCE(1);
1286 /* Not implemented. */
1287 break;
1288 default:
1289 break;
1290 }
1291 event_fd = lttng_get_unused_fd();
1292 if (event_fd < 0) {
1293 ret = event_fd;
1294 goto fd_error;
1295 }
1296 event_file = anon_inode_getfile("[lttng_event]",
1297 &lttng_event_fops,
1298 NULL, O_RDWR);
1299 if (IS_ERR(event_file)) {
1300 ret = PTR_ERR(event_file);
1301 goto file_error;
1302 }
1303 /* The event holds a reference on the channel */
1304 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
1305 ret = -EOVERFLOW;
1306 goto refcount_error;
1307 }
1308 if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
1309 || event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
1310 struct lttng_enabler *enabler;
1311
1312 if (strutils_is_star_glob_pattern(event_param->name)) {
1313 /*
1314 * If the event name is a star globbing pattern,
1315 * we create the special star globbing enabler.
1316 */
1317 enabler = lttng_enabler_create(LTTNG_ENABLER_STAR_GLOB,
1318 event_param, channel);
1319 } else {
1320 enabler = lttng_enabler_create(LTTNG_ENABLER_NAME,
1321 event_param, channel);
1322 }
1323 priv = enabler;
1324 } else {
1325 struct lttng_event *event;
1326
1327 /*
1328 * We tolerate no failure path after event creation. It
1329 * will stay invariant for the rest of the session.
1330 */
1331 event = lttng_event_create(channel, event_param,
1332 NULL, NULL,
1333 event_param->instrumentation);
1334 WARN_ON_ONCE(!event);
1335 if (IS_ERR(event)) {
1336 ret = PTR_ERR(event);
1337 goto event_error;
1338 }
1339 priv = event;
1340 }
1341 event_file->private_data = priv;
1342 fd_install(event_fd, event_file);
1343 return event_fd;
1344
1345 event_error:
1346 atomic_long_dec(&channel_file->f_count);
1347 refcount_error:
1348 fput(event_file);
1349 file_error:
1350 put_unused_fd(event_fd);
1351 fd_error:
1352 return ret;
1353 }
1354
1355 /**
1356 * lttng_channel_ioctl - lttng syscall through ioctl
1357 *
1358 * @file: the file
1359 * @cmd: the command
1360 * @arg: command arg
1361 *
1362 * This ioctl implements lttng commands:
1363 * LTTNG_KERNEL_STREAM
1364 * Returns an event stream file descriptor or failure.
1365 * (typically, one event stream records events from one CPU)
1366 * LTTNG_KERNEL_EVENT
1367 * Returns an event file descriptor or failure.
1368 * LTTNG_KERNEL_CONTEXT
1369 * Prepend a context field to each event in the channel
1370 * LTTNG_KERNEL_ENABLE
1371 * Enable recording for events in this channel (weak enable)
1372 * LTTNG_KERNEL_DISABLE
1373 * Disable recording for events in this channel (strong disable)
1374 *
1375 * Channel and event file descriptors also hold a reference on the session.
1376 */
1377 static
1378 long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1379 {
1380 struct lttng_channel *channel = file->private_data;
1381
1382 switch (cmd) {
1383 case LTTNG_KERNEL_OLD_STREAM:
1384 case LTTNG_KERNEL_STREAM:
1385 return lttng_abi_open_stream(file);
1386 case LTTNG_KERNEL_OLD_EVENT:
1387 {
1388 struct lttng_kernel_event *uevent_param;
1389 struct lttng_kernel_old_event *old_uevent_param;
1390 int ret;
1391
1392 uevent_param = kmalloc(sizeof(struct lttng_kernel_event),
1393 GFP_KERNEL);
1394 if (!uevent_param) {
1395 ret = -ENOMEM;
1396 goto old_event_end;
1397 }
1398 old_uevent_param = kmalloc(
1399 sizeof(struct lttng_kernel_old_event),
1400 GFP_KERNEL);
1401 if (!old_uevent_param) {
1402 ret = -ENOMEM;
1403 goto old_event_error_free_param;
1404 }
1405 if (copy_from_user(old_uevent_param,
1406 (struct lttng_kernel_old_event __user *) arg,
1407 sizeof(struct lttng_kernel_old_event))) {
1408 ret = -EFAULT;
1409 goto old_event_error_free_old_param;
1410 }
1411
1412 memcpy(uevent_param->name, old_uevent_param->name,
1413 sizeof(uevent_param->name));
1414 uevent_param->instrumentation =
1415 old_uevent_param->instrumentation;
1416
1417 switch (old_uevent_param->instrumentation) {
1418 case LTTNG_KERNEL_KPROBE:
1419 uevent_param->u.kprobe.addr =
1420 old_uevent_param->u.kprobe.addr;
1421 uevent_param->u.kprobe.offset =
1422 old_uevent_param->u.kprobe.offset;
1423 memcpy(uevent_param->u.kprobe.symbol_name,
1424 old_uevent_param->u.kprobe.symbol_name,
1425 sizeof(uevent_param->u.kprobe.symbol_name));
1426 break;
1427 case LTTNG_KERNEL_KRETPROBE:
1428 uevent_param->u.kretprobe.addr =
1429 old_uevent_param->u.kretprobe.addr;
1430 uevent_param->u.kretprobe.offset =
1431 old_uevent_param->u.kretprobe.offset;
1432 memcpy(uevent_param->u.kretprobe.symbol_name,
1433 old_uevent_param->u.kretprobe.symbol_name,
1434 sizeof(uevent_param->u.kretprobe.symbol_name));
1435 break;
1436 case LTTNG_KERNEL_FUNCTION:
1437 WARN_ON_ONCE(1);
1438 /* Not implemented. */
1439 break;
1440 default:
1441 break;
1442 }
1443 ret = lttng_abi_create_event(file, uevent_param);
1444
1445 old_event_error_free_old_param:
1446 kfree(old_uevent_param);
1447 old_event_error_free_param:
1448 kfree(uevent_param);
1449 old_event_end:
1450 return ret;
1451 }
1452 case LTTNG_KERNEL_EVENT:
1453 {
1454 struct lttng_kernel_event uevent_param;
1455
1456 if (copy_from_user(&uevent_param,
1457 (struct lttng_kernel_event __user *) arg,
1458 sizeof(uevent_param)))
1459 return -EFAULT;
1460 return lttng_abi_create_event(file, &uevent_param);
1461 }
1462 case LTTNG_KERNEL_OLD_CONTEXT:
1463 {
1464 struct lttng_kernel_context *ucontext_param;
1465 struct lttng_kernel_old_context *old_ucontext_param;
1466 int ret;
1467
1468 ucontext_param = kmalloc(sizeof(struct lttng_kernel_context),
1469 GFP_KERNEL);
1470 if (!ucontext_param) {
1471 ret = -ENOMEM;
1472 goto old_ctx_end;
1473 }
1474 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_old_context),
1475 GFP_KERNEL);
1476 if (!old_ucontext_param) {
1477 ret = -ENOMEM;
1478 goto old_ctx_error_free_param;
1479 }
1480
1481 if (copy_from_user(old_ucontext_param,
1482 (struct lttng_kernel_old_context __user *) arg,
1483 sizeof(struct lttng_kernel_old_context))) {
1484 ret = -EFAULT;
1485 goto old_ctx_error_free_old_param;
1486 }
1487 ucontext_param->ctx = old_ucontext_param->ctx;
1488 memcpy(ucontext_param->padding, old_ucontext_param->padding,
1489 sizeof(ucontext_param->padding));
1490 /* only type that uses the union */
1491 if (old_ucontext_param->ctx == LTTNG_KERNEL_CONTEXT_PERF_COUNTER) {
1492 ucontext_param->u.perf_counter.type =
1493 old_ucontext_param->u.perf_counter.type;
1494 ucontext_param->u.perf_counter.config =
1495 old_ucontext_param->u.perf_counter.config;
1496 memcpy(ucontext_param->u.perf_counter.name,
1497 old_ucontext_param->u.perf_counter.name,
1498 sizeof(ucontext_param->u.perf_counter.name));
1499 }
1500
1501 ret = lttng_abi_add_context(file,
1502 ucontext_param,
1503 &channel->ctx, channel->session);
1504
1505 old_ctx_error_free_old_param:
1506 kfree(old_ucontext_param);
1507 old_ctx_error_free_param:
1508 kfree(ucontext_param);
1509 old_ctx_end:
1510 return ret;
1511 }
1512 case LTTNG_KERNEL_CONTEXT:
1513 {
1514 struct lttng_kernel_context ucontext_param;
1515
1516 if (copy_from_user(&ucontext_param,
1517 (struct lttng_kernel_context __user *) arg,
1518 sizeof(ucontext_param)))
1519 return -EFAULT;
1520 return lttng_abi_add_context(file,
1521 &ucontext_param,
1522 &channel->ctx, channel->session);
1523 }
1524 case LTTNG_KERNEL_OLD_ENABLE:
1525 case LTTNG_KERNEL_ENABLE:
1526 return lttng_channel_enable(channel);
1527 case LTTNG_KERNEL_OLD_DISABLE:
1528 case LTTNG_KERNEL_DISABLE:
1529 return lttng_channel_disable(channel);
1530 case LTTNG_KERNEL_SYSCALL_MASK:
1531 return lttng_channel_syscall_mask(channel,
1532 (struct lttng_kernel_syscall_mask __user *) arg);
1533 default:
1534 return -ENOIOCTLCMD;
1535 }
1536 }
1537
1538 /**
1539 * lttng_metadata_ioctl - lttng syscall through ioctl
1540 *
1541 * @file: the file
1542 * @cmd: the command
1543 * @arg: command arg
1544 *
1545 * This ioctl implements lttng commands:
1546 * LTTNG_KERNEL_STREAM
1547 * Returns an event stream file descriptor or failure.
1548 *
1549 * Channel and event file descriptors also hold a reference on the session.
1550 */
1551 static
1552 long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1553 {
1554 switch (cmd) {
1555 case LTTNG_KERNEL_OLD_STREAM:
1556 case LTTNG_KERNEL_STREAM:
1557 return lttng_abi_open_metadata_stream(file);
1558 default:
1559 return -ENOIOCTLCMD;
1560 }
1561 }
1562
1563 /**
1564 * lttng_channel_poll - lttng stream addition/removal monitoring
1565 *
1566 * @file: the file
1567 * @wait: poll table
1568 */
1569 unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
1570 {
1571 struct lttng_channel *channel = file->private_data;
1572 unsigned int mask = 0;
1573
1574 if (file->f_mode & FMODE_READ) {
1575 poll_wait_set_exclusive(wait);
1576 poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan),
1577 wait);
1578
1579 if (channel->ops->is_disabled(channel->chan))
1580 return POLLERR;
1581 if (channel->ops->is_finalized(channel->chan))
1582 return POLLHUP;
1583 if (channel->ops->buffer_has_read_closed_stream(channel->chan))
1584 return POLLIN | POLLRDNORM;
1585 return 0;
1586 }
1587 return mask;
1588
1589 }
1590
1591 static
1592 int lttng_channel_release(struct inode *inode, struct file *file)
1593 {
1594 struct lttng_channel *channel = file->private_data;
1595
1596 if (channel)
1597 fput(channel->session->file);
1598 return 0;
1599 }
1600
1601 static
1602 int lttng_metadata_channel_release(struct inode *inode, struct file *file)
1603 {
1604 struct lttng_channel *channel = file->private_data;
1605
1606 if (channel) {
1607 fput(channel->session->file);
1608 lttng_metadata_channel_destroy(channel);
1609 }
1610
1611 return 0;
1612 }
1613
1614 static const struct file_operations lttng_channel_fops = {
1615 .owner = THIS_MODULE,
1616 .release = lttng_channel_release,
1617 .poll = lttng_channel_poll,
1618 .unlocked_ioctl = lttng_channel_ioctl,
1619 #ifdef CONFIG_COMPAT
1620 .compat_ioctl = lttng_channel_ioctl,
1621 #endif
1622 };
1623
1624 static const struct file_operations lttng_metadata_fops = {
1625 .owner = THIS_MODULE,
1626 .release = lttng_metadata_channel_release,
1627 .unlocked_ioctl = lttng_metadata_ioctl,
1628 #ifdef CONFIG_COMPAT
1629 .compat_ioctl = lttng_metadata_ioctl,
1630 #endif
1631 };
1632
1633 /**
1634 * lttng_event_ioctl - lttng syscall through ioctl
1635 *
1636 * @file: the file
1637 * @cmd: the command
1638 * @arg: command arg
1639 *
1640 * This ioctl implements lttng commands:
1641 * LTTNG_KERNEL_CONTEXT
1642 * Prepend a context field to each record of this event
1643 * LTTNG_KERNEL_ENABLE
1644 * Enable recording for this event (weak enable)
1645 * LTTNG_KERNEL_DISABLE
1646 * Disable recording for this event (strong disable)
1647 */
1648 static
1649 long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1650 {
1651 struct lttng_event *event;
1652 struct lttng_enabler *enabler;
1653 enum lttng_event_type *evtype = file->private_data;
1654
1655 switch (cmd) {
1656 case LTTNG_KERNEL_OLD_CONTEXT:
1657 {
1658 /* Not implemented */
1659 return -ENOSYS;
1660 }
1661 case LTTNG_KERNEL_CONTEXT:
1662 {
1663 /* Not implemented */
1664 return -ENOSYS;
1665 }
1666 case LTTNG_KERNEL_OLD_ENABLE:
1667 case LTTNG_KERNEL_ENABLE:
1668 switch (*evtype) {
1669 case LTTNG_TYPE_EVENT:
1670 event = file->private_data;
1671 return lttng_event_enable(event);
1672 case LTTNG_TYPE_ENABLER:
1673 enabler = file->private_data;
1674 return lttng_enabler_enable(enabler);
1675 default:
1676 WARN_ON_ONCE(1);
1677 return -ENOSYS;
1678 }
1679 case LTTNG_KERNEL_OLD_DISABLE:
1680 case LTTNG_KERNEL_DISABLE:
1681 switch (*evtype) {
1682 case LTTNG_TYPE_EVENT:
1683 event = file->private_data;
1684 return lttng_event_disable(event);
1685 case LTTNG_TYPE_ENABLER:
1686 enabler = file->private_data;
1687 return lttng_enabler_disable(enabler);
1688 default:
1689 WARN_ON_ONCE(1);
1690 return -ENOSYS;
1691 }
1692 case LTTNG_KERNEL_FILTER:
1693 switch (*evtype) {
1694 case LTTNG_TYPE_EVENT:
1695 return -EINVAL;
1696 case LTTNG_TYPE_ENABLER:
1697 {
1698 enabler = file->private_data;
1699 return lttng_enabler_attach_bytecode(enabler,
1700 (struct lttng_kernel_filter_bytecode __user *) arg);
1701 }
1702 default:
1703 WARN_ON_ONCE(1);
1704 return -ENOSYS;
1705 }
1706 case LTTNG_KERNEL_ADD_CALLSITE:
1707 switch (*evtype) {
1708 case LTTNG_TYPE_EVENT:
1709 event = file->private_data;
1710 return lttng_event_add_callsite(event,
1711 (struct lttng_kernel_event_callsite __user *) arg);
1712 case LTTNG_TYPE_ENABLER:
1713 return -EINVAL;
1714 default:
1715 WARN_ON_ONCE(1);
1716 return -ENOSYS;
1717 }
1718 default:
1719 return -ENOIOCTLCMD;
1720 }
1721 }
1722
1723 static
1724 int lttng_event_release(struct inode *inode, struct file *file)
1725 {
1726 struct lttng_event *event;
1727 struct lttng_enabler *enabler;
1728 enum lttng_event_type *evtype = file->private_data;
1729
1730 if (!evtype)
1731 return 0;
1732
1733 switch (*evtype) {
1734 case LTTNG_TYPE_EVENT:
1735 event = file->private_data;
1736 if (event)
1737 fput(event->chan->file);
1738 break;
1739 case LTTNG_TYPE_ENABLER:
1740 enabler = file->private_data;
1741 if (enabler)
1742 fput(enabler->chan->file);
1743 break;
1744 default:
1745 WARN_ON_ONCE(1);
1746 break;
1747 }
1748
1749 return 0;
1750 }
1751
1752 /* TODO: filter control ioctl */
1753 static const struct file_operations lttng_event_fops = {
1754 .owner = THIS_MODULE,
1755 .release = lttng_event_release,
1756 .unlocked_ioctl = lttng_event_ioctl,
1757 #ifdef CONFIG_COMPAT
1758 .compat_ioctl = lttng_event_ioctl,
1759 #endif
1760 };
1761
1762 static int put_u64(uint64_t val, unsigned long arg)
1763 {
1764 return put_user(val, (uint64_t __user *) arg);
1765 }
1766
1767 static int put_u32(uint32_t val, unsigned long arg)
1768 {
1769 return put_user(val, (uint32_t __user *) arg);
1770 }
1771
1772 static long lttng_stream_ring_buffer_ioctl(struct file *filp,
1773 unsigned int cmd, unsigned long arg)
1774 {
1775 struct lib_ring_buffer *buf = filp->private_data;
1776 struct channel *chan = buf->backend.chan;
1777 const struct lib_ring_buffer_config *config = &chan->backend.config;
1778 const struct lttng_channel_ops *ops = chan->backend.priv_ops;
1779 int ret;
1780
1781 if (atomic_read(&chan->record_disabled))
1782 return -EIO;
1783
1784 switch (cmd) {
1785 case LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN:
1786 {
1787 uint64_t ts;
1788
1789 ret = ops->timestamp_begin(config, buf, &ts);
1790 if (ret < 0)
1791 goto error;
1792 return put_u64(ts, arg);
1793 }
1794 case LTTNG_RING_BUFFER_GET_TIMESTAMP_END:
1795 {
1796 uint64_t ts;
1797
1798 ret = ops->timestamp_end(config, buf, &ts);
1799 if (ret < 0)
1800 goto error;
1801 return put_u64(ts, arg);
1802 }
1803 case LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED:
1804 {
1805 uint64_t ed;
1806
1807 ret = ops->events_discarded(config, buf, &ed);
1808 if (ret < 0)
1809 goto error;
1810 return put_u64(ed, arg);
1811 }
1812 case LTTNG_RING_BUFFER_GET_CONTENT_SIZE:
1813 {
1814 uint64_t cs;
1815
1816 ret = ops->content_size(config, buf, &cs);
1817 if (ret < 0)
1818 goto error;
1819 return put_u64(cs, arg);
1820 }
1821 case LTTNG_RING_BUFFER_GET_PACKET_SIZE:
1822 {
1823 uint64_t ps;
1824
1825 ret = ops->packet_size(config, buf, &ps);
1826 if (ret < 0)
1827 goto error;
1828 return put_u64(ps, arg);
1829 }
1830 case LTTNG_RING_BUFFER_GET_STREAM_ID:
1831 {
1832 uint64_t si;
1833
1834 ret = ops->stream_id(config, buf, &si);
1835 if (ret < 0)
1836 goto error;
1837 return put_u64(si, arg);
1838 }
1839 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
1840 {
1841 uint64_t ts;
1842
1843 ret = ops->current_timestamp(config, buf, &ts);
1844 if (ret < 0)
1845 goto error;
1846 return put_u64(ts, arg);
1847 }
1848 case LTTNG_RING_BUFFER_GET_SEQ_NUM:
1849 {
1850 uint64_t seq;
1851
1852 ret = ops->sequence_number(config, buf, &seq);
1853 if (ret < 0)
1854 goto error;
1855 return put_u64(seq, arg);
1856 }
1857 case LTTNG_RING_BUFFER_INSTANCE_ID:
1858 {
1859 uint64_t id;
1860
1861 ret = ops->instance_id(config, buf, &id);
1862 if (ret < 0)
1863 goto error;
1864 return put_u64(id, arg);
1865 }
1866 default:
1867 return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
1868 cmd, arg);
1869 }
1870
1871 error:
1872 return -ENOSYS;
1873 }
1874
1875 #ifdef CONFIG_COMPAT
1876 static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp,
1877 unsigned int cmd, unsigned long arg)
1878 {
1879 struct lib_ring_buffer *buf = filp->private_data;
1880 struct channel *chan = buf->backend.chan;
1881 const struct lib_ring_buffer_config *config = &chan->backend.config;
1882 const struct lttng_channel_ops *ops = chan->backend.priv_ops;
1883 int ret;
1884
1885 if (atomic_read(&chan->record_disabled))
1886 return -EIO;
1887
1888 switch (cmd) {
1889 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN:
1890 {
1891 uint64_t ts;
1892
1893 ret = ops->timestamp_begin(config, buf, &ts);
1894 if (ret < 0)
1895 goto error;
1896 return put_u64(ts, arg);
1897 }
1898 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END:
1899 {
1900 uint64_t ts;
1901
1902 ret = ops->timestamp_end(config, buf, &ts);
1903 if (ret < 0)
1904 goto error;
1905 return put_u64(ts, arg);
1906 }
1907 case LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED:
1908 {
1909 uint64_t ed;
1910
1911 ret = ops->events_discarded(config, buf, &ed);
1912 if (ret < 0)
1913 goto error;
1914 return put_u64(ed, arg);
1915 }
1916 case LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE:
1917 {
1918 uint64_t cs;
1919
1920 ret = ops->content_size(config, buf, &cs);
1921 if (ret < 0)
1922 goto error;
1923 return put_u64(cs, arg);
1924 }
1925 case LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE:
1926 {
1927 uint64_t ps;
1928
1929 ret = ops->packet_size(config, buf, &ps);
1930 if (ret < 0)
1931 goto error;
1932 return put_u64(ps, arg);
1933 }
1934 case LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID:
1935 {
1936 uint64_t si;
1937
1938 ret = ops->stream_id(config, buf, &si);
1939 if (ret < 0)
1940 goto error;
1941 return put_u64(si, arg);
1942 }
1943 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
1944 {
1945 uint64_t ts;
1946
1947 ret = ops->current_timestamp(config, buf, &ts);
1948 if (ret < 0)
1949 goto error;
1950 return put_u64(ts, arg);
1951 }
1952 case LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM:
1953 {
1954 uint64_t seq;
1955
1956 ret = ops->sequence_number(config, buf, &seq);
1957 if (ret < 0)
1958 goto error;
1959 return put_u64(seq, arg);
1960 }
1961 case LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID:
1962 {
1963 uint64_t id;
1964
1965 ret = ops->instance_id(config, buf, &id);
1966 if (ret < 0)
1967 goto error;
1968 return put_u64(id, arg);
1969 }
1970 default:
1971 return lib_ring_buffer_file_operations.compat_ioctl(filp,
1972 cmd, arg);
1973 }
1974
1975 error:
1976 return -ENOSYS;
1977 }
1978 #endif /* CONFIG_COMPAT */
1979
1980 static void lttng_stream_override_ring_buffer_fops(void)
1981 {
1982 lttng_stream_ring_buffer_file_operations.owner = THIS_MODULE;
1983 lttng_stream_ring_buffer_file_operations.open =
1984 lib_ring_buffer_file_operations.open;
1985 lttng_stream_ring_buffer_file_operations.release =
1986 lib_ring_buffer_file_operations.release;
1987 lttng_stream_ring_buffer_file_operations.poll =
1988 lib_ring_buffer_file_operations.poll;
1989 lttng_stream_ring_buffer_file_operations.splice_read =
1990 lib_ring_buffer_file_operations.splice_read;
1991 lttng_stream_ring_buffer_file_operations.mmap =
1992 lib_ring_buffer_file_operations.mmap;
1993 lttng_stream_ring_buffer_file_operations.unlocked_ioctl =
1994 lttng_stream_ring_buffer_ioctl;
1995 lttng_stream_ring_buffer_file_operations.llseek =
1996 lib_ring_buffer_file_operations.llseek;
1997 #ifdef CONFIG_COMPAT
1998 lttng_stream_ring_buffer_file_operations.compat_ioctl =
1999 lttng_stream_ring_buffer_compat_ioctl;
2000 #endif
2001 }
2002
2003 int __init lttng_abi_init(void)
2004 {
2005 int ret = 0;
2006
2007 wrapper_vmalloc_sync_mappings();
2008 lttng_clock_ref();
2009
2010 ret = lttng_tp_mempool_init();
2011 if (ret) {
2012 goto error;
2013 }
2014
2015 lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
2016 &lttng_proc_ops, NULL);
2017
2018 if (!lttng_proc_dentry) {
2019 printk(KERN_ERR "Error creating LTTng control file\n");
2020 ret = -ENOMEM;
2021 goto error;
2022 }
2023 lttng_stream_override_ring_buffer_fops();
2024 return 0;
2025
2026 error:
2027 lttng_tp_mempool_destroy();
2028 lttng_clock_unref();
2029 return ret;
2030 }
2031
2032 /* No __exit annotation because used by init error path too. */
2033 void lttng_abi_exit(void)
2034 {
2035 lttng_tp_mempool_destroy();
2036 lttng_clock_unref();
2037 if (lttng_proc_dentry)
2038 remove_proc_entry("lttng", NULL);
2039 }
LTTng 2.0/0.x modules
This page took 0.067109 seconds and 3 git commands to generate.