projects / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: Implement RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK
[lttng-modules.git] / src / lttng-abi.c
CommitLineData
b7cdc182 1/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
9f36eaed 2 *
e8951e63 3 * lttng-abi.c
baf20995 4 *
e8951e63 5 * LTTng ABI
baf20995 6 *
886d51a3
MD		 7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 *
baf20995
MD		 9 * Mimic system calls for:
10 * - session creation, returns a file descriptor or failure.
ad1c05e1
MD		 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.
baf20995
MD		 24 */
25
11b5a3c2 26#include <linux/module.h>
e6a17f26 27#include <linux/proc_fs.h>
11b5a3c2
MD		 28#include <linux/anon_inodes.h>
29#include <linux/file.h>
30#include <linux/uaccess.h>
31#include <linux/slab.h>
abc0446a 32#include <linux/err.h>
263b6c88 33#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
24591303
MD		 34#include <ringbuffer/vfs.h>
35#include <ringbuffer/backend.h>
36#include <ringbuffer/frontend.h>
241ae9a8
MD		 37#include <wrapper/poll.h>
38#include <wrapper/file.h>
39#include <wrapper/kref.h>
2df37e95
MD		 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>
24591303 46#include <ringbuffer/frontend_types.h>
baf20995
MD		 47
48/*
49 * This is LTTng's own personal way to create a system call as an external
80996790 50 * module. We use ioctl() on /proc/lttng.
baf20995
MD		 51 */
52
e6a17f26 53static struct proc_dir_entry *lttng_proc_dentry;
059de147
MJ		 54
55#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
56static const struct proc_ops lttng_proc_ops;
57#else
58static const struct file_operations lttng_proc_ops;
59#endif
60
ad1c05e1
MD		 61static const struct file_operations lttng_session_fops;
62static const struct file_operations lttng_channel_fops;
5dbbdb43 63static const struct file_operations lttng_metadata_fops;
305d3e42 64static const struct file_operations lttng_event_fops;
ed8d02d6 65static struct file_operations lttng_stream_ring_buffer_file_operations;
baf20995 66
9616f0bf 67static int put_u64(uint64_t val, unsigned long arg);
8b97fd42 68static int put_u32(uint32_t val, unsigned long arg);
9616f0bf 69
a33c9927
MD		 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
ad1c05e1 75static
baf20995
MD		 76int lttng_abi_create_session(void)
77{
a90917c3 78 struct lttng_session *session;
c0e31d2e 79 struct file *session_file;
11b5a3c2 80 int session_fd, ret;
baf20995 81
a90917c3 82 session = lttng_session_create();
baf20995
MD		 83 if (!session)
84 return -ENOMEM;
4ac10b76 85 session_fd = lttng_get_unused_fd();
baf20995
MD		 86 if (session_fd < 0) {
87 ret = session_fd;
88 goto fd_error;
89 }
c0e31d2e 90 session_file = anon_inode_getfile("[lttng_session]",
ad1c05e1 91 &lttng_session_fops,
baf20995 92 session, O_RDWR);
c0e31d2e
MD		 93 if (IS_ERR(session_file)) {
94 ret = PTR_ERR(session_file);
baf20995
MD		 95 goto file_error;
96 }
c0e31d2e
MD		 97 session->file = session_file;
98 fd_install(session_fd, session_file);
baf20995
MD		 99 return session_fd;
100
101file_error:
102 put_unused_fd(session_fd);
103fd_error:
a90917c3 104 lttng_session_destroy(session);
baf20995
MD		 105 return ret;
106}
107
271b6681
MD		 108static
109int lttng_abi_tracepoint_list(void)
110{
111 struct file *tracepoint_list_file;
112 int file_fd, ret;
113
4ac10b76 114 file_fd = lttng_get_unused_fd();
271b6681
MD		 115 if (file_fd < 0) {
116 ret = file_fd;
117 goto fd_error;
118 }
30f18bf0 119
8ee099b6 120 tracepoint_list_file = anon_inode_getfile("[lttng_tracepoint_list]",
271b6681
MD		 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 }
30f18bf0
MD		 127 ret = lttng_tracepoint_list_fops.open(NULL, tracepoint_list_file);
128 if (ret < 0)
129 goto open_error;
271b6681
MD		 130 fd_install(file_fd, tracepoint_list_file);
131 return file_fd;
132
30f18bf0
MD		 133open_error:
134 fput(tracepoint_list_file);
271b6681
MD		 135file_error:
136 put_unused_fd(file_fd);
137fd_error:
138 return ret;
139}
140
f127e61e
MD		 141#ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
142static inline
143int lttng_abi_syscall_list(void)
144{
145 return -ENOSYS;
146}
147#else
148static
149int 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);
f127e61e
MD		 171 return file_fd;
172
173open_error:
174 fput(syscall_list_file);
175file_error:
176 put_unused_fd(file_fd);
177fd_error:
178 return ret;
179}
180#endif
181
80c16bcf 182static
6dccd6c1 183void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v)
80c16bcf 184{
6dccd6c1
JD		 185 v->major = LTTNG_MODULES_MAJOR_VERSION;
186 v->minor = LTTNG_MODULES_MINOR_VERSION;
187 v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
80c16bcf
MD		 188}
189
42cabb80
MD		 190static
191void 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
8070f5c0
MD		 197static
198long lttng_abi_add_context(struct file *file,
6dccd6c1 199 struct lttng_kernel_context *context_param,
a90917c3 200 struct lttng_ctx **ctx, struct lttng_session *session)
8070f5c0 201{
8070f5c0
MD		 202
203 if (session->been_active)
204 return -EPERM;
205
6dccd6c1 206 switch (context_param->ctx) {
12a313a5 207 case LTTNG_KERNEL_CONTEXT_PID:
8070f5c0 208 return lttng_add_pid_to_ctx(ctx);
a8ad3613
MD		 209 case LTTNG_KERNEL_CONTEXT_PRIO:
210 return lttng_add_prio_to_ctx(ctx);
53f1f0ca
MD		 211 case LTTNG_KERNEL_CONTEXT_NICE:
212 return lttng_add_nice_to_ctx(ctx);
b64bc438
MD		 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);
12a313a5 223 case LTTNG_KERNEL_CONTEXT_PERF_COUNTER:
6dccd6c1
JD		 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,
c24a0d71 228 ctx);
a2563e83
MD		 229 case LTTNG_KERNEL_CONTEXT_PROCNAME:
230 return lttng_add_procname_to_ctx(ctx);
975da2c0
JD		 231 case LTTNG_KERNEL_CONTEXT_HOSTNAME:
232 return lttng_add_hostname_to_ctx(ctx);
b3699d90
MD		 233 case LTTNG_KERNEL_CONTEXT_CPU_ID:
234 return lttng_add_cpu_id_to_ctx(ctx);
79150a49
JD		 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);
2fa2d39a
FG		 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);
a6cf40a4
MJ		 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);
dc923e75
MJ		 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);
8070f5c0
MD		 284 default:
285 return -EINVAL;
286 }
287}
288
ad1c05e1
MD		 289/**
290 * lttng_ioctl - lttng syscall through ioctl
291 *
c0e31d2e 292 * @file: the file
ad1c05e1
MD		 293 * @cmd: the command
294 * @arg: command arg
295 *
296 * This ioctl implements lttng commands:
38d024ae 297 * LTTNG_KERNEL_SESSION
ad1c05e1 298 * Returns a LTTng trace session file descriptor
271b6681
MD		 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
360f38ea
MD		 303 * LTTNG_KERNEL_WAIT_QUIESCENT
304 * Returns after all previously running probes have completed
42cabb80
MD		 305 * LTTNG_KERNEL_TRACER_ABI_VERSION
306 * Returns the LTTng kernel tracer ABI version
ad1c05e1
MD		 307 *
308 * The returned session will be deleted when its file descriptor is closed.
309 */
310static
c0e31d2e 311long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
ad1c05e1
MD		 312{
313 switch (cmd) {
6dccd6c1 314 case LTTNG_KERNEL_OLD_SESSION:
38d024ae 315 case LTTNG_KERNEL_SESSION:
ad1c05e1 316 return lttng_abi_create_session();
6dccd6c1
JD		 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 }
80c16bcf 333 case LTTNG_KERNEL_TRACER_VERSION:
6dccd6c1
JD		 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);
42cabb80
MD		 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
6dccd6c1
JD		 353 if (copy_to_user(uversion, &version, sizeof(version)))
354 return -EFAULT;
355 return 0;
356 }
357 case LTTNG_KERNEL_OLD_TRACEPOINT_LIST:
271b6681
MD		 358 case LTTNG_KERNEL_TRACEPOINT_LIST:
359 return lttng_abi_tracepoint_list();
2d2464bd
MD		 360 case LTTNG_KERNEL_SYSCALL_LIST:
361 return lttng_abi_syscall_list();
6dccd6c1 362 case LTTNG_KERNEL_OLD_WAIT_QUIESCENT:
5f7f9078
MD		 363 case LTTNG_KERNEL_WAIT_QUIESCENT:
364 synchronize_trace();
365 return 0;
6dccd6c1
JD		 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 }
57105fc2
MD		 382 case LTTNG_KERNEL_CALIBRATE:
383 {
3db41b2c
MD		 384 struct lttng_kernel_calibrate __user *ucalibrate =
385 (struct lttng_kernel_calibrate __user *) arg;
386 struct lttng_kernel_calibrate calibrate;
57105fc2
MD		 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 }
ad1c05e1
MD		 396 default:
397 return -ENOIOCTLCMD;
398 }
399}
400
059de147
MJ		 401#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
402static 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
409static const struct file_operations lttng_proc_ops = {
a33c9927 410 .owner = THIS_MODULE,
ad1c05e1
MD		 411 .unlocked_ioctl = lttng_ioctl,
412#ifdef CONFIG_COMPAT
03037b98 413 .compat_ioctl = lttng_ioctl,
059de147 414#endif /* CONFIG_COMPAT */
11b5a3c2 415};
059de147 416#endif
ad1c05e1 417
5dbbdb43 418static
c0e31d2e 419int lttng_abi_create_channel(struct file *session_file,
6dccd6c1 420 struct lttng_kernel_channel *chan_param,
5dbbdb43 421 enum channel_type channel_type)
baf20995 422{
a90917c3 423 struct lttng_session *session = session_file->private_data;
88dfd899 424 const struct file_operations *fops = NULL;
5dbbdb43 425 const char *transport_name;
a90917c3 426 struct lttng_channel *chan;
c0e31d2e 427 struct file *chan_file;
baf20995 428 int chan_fd;
ad1c05e1 429 int ret = 0;
baf20995 430
4ac10b76 431 chan_fd = lttng_get_unused_fd();
baf20995
MD		 432 if (chan_fd < 0) {
433 ret = chan_fd;
434 goto fd_error;
435 }
88dfd899
MD		 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 }
2470a237 444
c0e31d2e 445 chan_file = anon_inode_getfile("[lttng_channel]",
88dfd899 446 fops,
03037b98 447 NULL, O_RDWR);
c0e31d2e
MD		 448 if (IS_ERR(chan_file)) {
449 ret = PTR_ERR(chan_file);
baf20995
MD		 450 goto file_error;
451 }
5dbbdb43
MD		 452 switch (channel_type) {
453 case PER_CPU_CHANNEL:
6dccd6c1
JD		 454 if (chan_param->output == LTTNG_KERNEL_SPLICE) {
455 transport_name = chan_param->overwrite ?
96ba7208 456 "relay-overwrite" : "relay-discard";
6dccd6c1
JD		 457 } else if (chan_param->output == LTTNG_KERNEL_MMAP) {
458 transport_name = chan_param->overwrite ?
96ba7208
JD		 459 "relay-overwrite-mmap" : "relay-discard-mmap";
460 } else {
461 return -EINVAL;
462 }
5dbbdb43 463 break;
5dbbdb43 464 case METADATA_CHANNEL:
6dccd6c1 465 if (chan_param->output == LTTNG_KERNEL_SPLICE)
96ba7208 466 transport_name = "relay-metadata";
6dccd6c1 467 else if (chan_param->output == LTTNG_KERNEL_MMAP)
96ba7208
JD		 468 transport_name = "relay-metadata-mmap";
469 else
470 return -EINVAL;
5dbbdb43
MD		 471 break;
472 default:
473 transport_name = "<unknown>";
474 break;
475 }
98d7281c
MJ		 476 if (!atomic_long_add_unless(&session_file->f_count, 1, LONG_MAX)) {
477 ret = -EOVERFLOW;
9c1f4643
MD		 478 goto refcount_error;
479 }
03037b98
MD		 480 /*
481 * We tolerate no failure path after channel creation. It will stay
482 * invariant for the rest of the session.
483 */
a90917c3 484 chan = lttng_channel_create(session, transport_name, NULL,
6dccd6c1
JD		 485 chan_param->subbuf_size,
486 chan_param->num_subbuf,
487 chan_param->switch_timer_interval,
d83004aa
JD		 488 chan_param->read_timer_interval,
489 channel_type);
03037b98 490 if (!chan) {
f3d01b96 491 ret = -EINVAL;
03037b98
MD		 492 goto chan_error;
493 }
11b5a3c2 494 chan->file = chan_file;
c0e31d2e
MD		 495 chan_file->private_data = chan;
496 fd_install(chan_fd, chan_file);
ad1c05e1 497
baf20995
MD		 498 return chan_fd;
499
03037b98 500chan_error:
9c1f4643
MD		 501 atomic_long_dec(&session_file->f_count);
502refcount_error:
c0e31d2e 503 fput(chan_file);
baf20995
MD		 504file_error:
505 put_unused_fd(chan_fd);
506fd_error:
baf20995
MD		 507 return ret;
508}
509
7f859fbf
JR		 510static
511int 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
1c88f269
JR		 527static
528int 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
d1f652f8
MD		 544static
545enum 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
baf20995 565/**
ad1c05e1 566 * lttng_session_ioctl - lttng session fd ioctl
baf20995 567 *
c0e31d2e 568 * @file: the file
baf20995
MD		 569 * @cmd: the command
570 * @arg: command arg
571 *
572 * This ioctl implements lttng commands:
38d024ae 573 * LTTNG_KERNEL_CHANNEL
baf20995 574 * Returns a LTTng channel file descriptor
e64957da
MD		 575 * LTTNG_KERNEL_ENABLE
576 * Enables tracing for a session (weak enable)
577 * LTTNG_KERNEL_DISABLE
578 * Disables tracing for a session (strong disable)
8070f5c0
MD		 579 * LTTNG_KERNEL_METADATA
580 * Returns a LTTng metadata file descriptor
e0130fab 581 * LTTNG_KERNEL_SESSION_TRACK_PID
d1f652f8 582 * Add PID to session PID tracker
e0130fab 583 * LTTNG_KERNEL_SESSION_UNTRACK_PID
d1f652f8
MD		 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
ad1c05e1
MD		 589 *
590 * The returned channel will be deleted when its file descriptor is closed.
591 */
592static
c0e31d2e 593long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
ad1c05e1 594{
a90917c3 595 struct lttng_session *session = file->private_data;
2d4c4d15
MD		 596 struct lttng_kernel_channel chan_param;
597 struct lttng_kernel_old_channel old_chan_param;
c0e31d2e 598
ad1c05e1 599 switch (cmd) {
6dccd6c1
JD		 600 case LTTNG_KERNEL_OLD_CHANNEL:
601 {
6dccd6c1
JD		 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 }
38d024ae 616 case LTTNG_KERNEL_CHANNEL:
6dccd6c1 617 {
6dccd6c1 618 if (copy_from_user(&chan_param,
38d024ae 619 (struct lttng_kernel_channel __user *) arg,
6dccd6c1
JD		 620 sizeof(struct lttng_kernel_channel)))
621 return -EFAULT;
622 return lttng_abi_create_channel(file, &chan_param,
5dbbdb43 623 PER_CPU_CHANNEL);
6dccd6c1
JD		 624 }
625 case LTTNG_KERNEL_OLD_SESSION_START:
626 case LTTNG_KERNEL_OLD_ENABLE:
38d024ae 627 case LTTNG_KERNEL_SESSION_START:
e64957da 628 case LTTNG_KERNEL_ENABLE:
a90917c3 629 return lttng_session_enable(session);
6dccd6c1
JD		 630 case LTTNG_KERNEL_OLD_SESSION_STOP:
631 case LTTNG_KERNEL_OLD_DISABLE:
38d024ae 632 case LTTNG_KERNEL_SESSION_STOP:
e64957da 633 case LTTNG_KERNEL_DISABLE:
a90917c3 634 return lttng_session_disable(session);
6dccd6c1
JD		 635 case LTTNG_KERNEL_OLD_METADATA:
636 {
6dccd6c1
JD		 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 }
38d024ae 651 case LTTNG_KERNEL_METADATA:
6dccd6c1 652 {
6dccd6c1
JD		 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,
5dbbdb43 658 METADATA_CHANNEL);
6dccd6c1 659 }
e0130fab 660 case LTTNG_KERNEL_SESSION_TRACK_PID:
d1f652f8 661 return lttng_session_track_id(session, TRACKER_PID, (int) arg);
e0130fab 662 case LTTNG_KERNEL_SESSION_UNTRACK_PID:
d1f652f8
MD		 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 }
7e6f9ef6 693 case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS:
d1f652f8
MD		 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 }
9616f0bf
JD		 709 case LTTNG_KERNEL_SESSION_METADATA_REGEN:
710 return lttng_session_metadata_regenerate(session);
601252cf
MD		 711 case LTTNG_KERNEL_SESSION_STATEDUMP:
712 return lttng_session_statedump(session);
7f859fbf
JR		 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 }
1c88f269
JR		 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 }
ad1c05e1
MD		 733 default:
734 return -ENOIOCTLCMD;
735 }
736}
737
03037b98
MD		 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 */
ad1c05e1 746static
03037b98 747int lttng_session_release(struct inode *inode, struct file *file)
ad1c05e1 748{
a90917c3 749 struct lttng_session *session = file->private_data;
c269fff4
MD		 750
751 if (session)
a90917c3 752 lttng_session_destroy(session);
11b5a3c2 753 return 0;
ad1c05e1 754}
ad1c05e1
MD		 755
756static const struct file_operations lttng_session_fops = {
a33c9927 757 .owner = THIS_MODULE,
03037b98 758 .release = lttng_session_release,
ad1c05e1
MD		 759 .unlocked_ioctl = lttng_session_ioctl,
760#ifdef CONFIG_COMPAT
03037b98 761 .compat_ioctl = lttng_session_ioctl,
ad1c05e1 762#endif
11b5a3c2 763};
ad1c05e1 764
d83004aa
JD		 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 */
ad1c05e1 772static
d83004aa
JD		 773unsigned 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
92d9f5e6 796 mutex_lock(&stream->metadata_cache->lock);
d83004aa 797 if (stream->metadata_cache->metadata_written >
f613e3e6 798 stream->metadata_out)
d83004aa 799 mask |= POLLIN;
92d9f5e6 800 mutex_unlock(&stream->metadata_cache->lock);
d83004aa
JD		 801 }
802
803 return mask;
804}
805
f613e3e6
MD		 806static
807void 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
d1344afa
JD		 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 */
826static
827int 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
842end:
843 mutex_unlock(&cache->lock);
844 return ret;
845}
846
d83004aa
JD		 847static
848long 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;
8b97fd42
MD		 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;
d83004aa
JD		 861
862 switch (cmd) {
d83004aa
JD		 863 case RING_BUFFER_GET_NEXT_SUBBUF:
864 {
35097f36
JD		 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
8b97fd42 869 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 870 if (ret > 0) {
871 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
872 ret = 0;
873 } else if (ret < 0)
d83004aa
JD		 874 goto err;
875 break;
876 }
f613e3e6
MD		 877 case RING_BUFFER_GET_SUBBUF:
878 {
879 /*
880 * Random access is not allowed for metadata channel.
881 */
882 return -ENOSYS;
883 }
c6f05468 884 case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
35097f36
JD		 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 */
8b97fd42 895 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 896 if (ret < 0)
897 goto err;
898 break;
899 }
9616f0bf
JD		 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 }
d1344afa
JD		 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 }
8b97fd42
MD		 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 }
d83004aa
JD		 927 default:
928 break;
929 }
f613e3e6
MD		 930 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
931
d83004aa 932 /* Performing lib ring buffer ioctl after our own. */
8b97fd42 933 ret = lib_ring_buffer_ioctl(filp, rb_cmd, arg, buf);
f613e3e6
MD		 934 if (ret < 0)
935 goto err;
d83004aa 936
f613e3e6
MD		 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 }
8b97fd42
MD		 944 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
945 {
946 return put_u32(coherent, arg);
947 }
f613e3e6
MD		 948 default:
949 break;
950 }
d83004aa
JD		 951err:
952 return ret;
953}
954
aeb9064d 955#ifdef CONFIG_COMPAT
d83004aa
JD		 956static
957long 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;
8b97fd42
MD		 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;
d83004aa
JD		 970
971 switch (cmd) {
d83004aa
JD		 972 case RING_BUFFER_GET_NEXT_SUBBUF:
973 {
35097f36
JD		 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
8b97fd42 978 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 979 if (ret > 0) {
980 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
981 ret = 0;
982 } else if (ret < 0)
d83004aa
JD		 983 goto err;
984 break;
985 }
f613e3e6
MD		 986 case RING_BUFFER_GET_SUBBUF:
987 {
988 /*
989 * Random access is not allowed for metadata channel.
990 */
991 return -ENOSYS;
992 }
c6f05468 993 case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
96c55c2f
MD		 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 */
8b97fd42 1004 ret = lttng_metadata_output_channel(stream, chan, NULL);
96c55c2f
MD		 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 }
d1344afa
JD		 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 }
8b97fd42
MD		 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 }
d83004aa
JD		 1036 default:
1037 break;
1038 }
f613e3e6
MD		 1039 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
1040
d83004aa 1041 /* Performing lib ring buffer ioctl after our own. */
8b97fd42 1042 ret = lib_ring_buffer_compat_ioctl(filp, rb_cmd, arg, buf);
f613e3e6
MD		 1043 if (ret < 0)
1044 goto err;
d83004aa 1045
f613e3e6
MD		 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 }
8b97fd42
MD		 1053 case RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
1054 {
1055 return put_u32(coherent, arg);
1056 }
f613e3e6
MD		 1057 default:
1058 break;
1059 }
d83004aa
JD		 1060err:
1061 return ret;
1062}
aeb9064d 1063#endif
d83004aa 1064
b3b8072b
MD		 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 */
d83004aa
JD		 1069static
1070int 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;
b3b8072b
MD		 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 }
d83004aa
JD		 1084 return lib_ring_buffer_open(inode, file, buf);
1085}
1086
1087static
1088int 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 kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
b3b8072b 1094 module_put(stream->transport->owner);
d83004aa
JD		 1095 return lib_ring_buffer_release(inode, file, buf);
1096}
1097
1098static
1099ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
1100 struct pipe_inode_info *pipe, size_t len,
1101 unsigned int flags)
1102{
1103 struct lttng_metadata_stream *stream = in->private_data;
1104 struct lib_ring_buffer *buf = stream->priv;
1105
1106 return lib_ring_buffer_splice_read(in, ppos, pipe, len,
1107 flags, buf);
1108}
1109
1110static
1111int lttng_metadata_ring_buffer_mmap(struct file *filp,
1112 struct vm_area_struct *vma)
1113{
1114 struct lttng_metadata_stream *stream = filp->private_data;
1115 struct lib_ring_buffer *buf = stream->priv;
1116
1117 return lib_ring_buffer_mmap(filp, vma, buf);
1118}
1119
1120static
1121const struct file_operations lttng_metadata_ring_buffer_file_operations = {
1122 .owner = THIS_MODULE,
1123 .open = lttng_metadata_ring_buffer_open,
1124 .release = lttng_metadata_ring_buffer_release,
1125 .poll = lttng_metadata_ring_buffer_poll,
1126 .splice_read = lttng_metadata_ring_buffer_splice_read,
1127 .mmap = lttng_metadata_ring_buffer_mmap,
1128 .unlocked_ioctl = lttng_metadata_ring_buffer_ioctl,
1129 .llseek = vfs_lib_ring_buffer_no_llseek,
1130#ifdef CONFIG_COMPAT
1131 .compat_ioctl = lttng_metadata_ring_buffer_compat_ioctl,
1132#endif
1133};
1134
1135static
1136int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
1137 const struct file_operations *fops)
ad1c05e1 1138{
ad1c05e1 1139 int stream_fd, ret;
11b5a3c2 1140 struct file *stream_file;
ad1c05e1 1141
4ac10b76 1142 stream_fd = lttng_get_unused_fd();
ad1c05e1
MD		 1143 if (stream_fd < 0) {
1144 ret = stream_fd;
1145 goto fd_error;
1146 }
d83004aa
JD		 1147 stream_file = anon_inode_getfile("[lttng_stream]", fops,
1148 stream_priv, O_RDWR);
c0e31d2e
MD		 1149 if (IS_ERR(stream_file)) {
1150 ret = PTR_ERR(stream_file);
ad1c05e1
MD		 1151 goto file_error;
1152 }
409453cb
MD		 1153 /*
1154 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
1155 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
1156 * file descriptor, so we set FMODE_PREAD here.
1157 */
d7b6f197 1158 stream_file->f_mode |= FMODE_PREAD;
c0e31d2e 1159 fd_install(stream_fd, stream_file);
dda6a249
MD		 1160 /*
1161 * The stream holds a reference to the channel within the generic ring
1162 * buffer library, so no need to hold a refcount on the channel and
1163 * session files here.
1164 */
ad1c05e1
MD		 1165 return stream_fd;
1166
1167file_error:
1168 put_unused_fd(stream_fd);
d83004aa
JD		 1169fd_error:
1170 return ret;
1171}
1172
1173static
1174int lttng_abi_open_stream(struct file *channel_file)
1175{
1176 struct lttng_channel *channel = channel_file->private_data;
1177 struct lib_ring_buffer *buf;
1178 int ret;
1179 void *stream_priv;
1180
1181 buf = channel->ops->buffer_read_open(channel->chan);
1182 if (!buf)
1183 return -ENOENT;
1184
1185 stream_priv = buf;
1186 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
ed8d02d6 1187 &lttng_stream_ring_buffer_file_operations);
d83004aa
JD		 1188 if (ret < 0)
1189 goto fd_error;
1190
1191 return ret;
1192
1193fd_error:
1194 channel->ops->buffer_read_close(buf);
1195 return ret;
1196}
1197
1198static
1199int lttng_abi_open_metadata_stream(struct file *channel_file)
1200{
1201 struct lttng_channel *channel = channel_file->private_data;
1202 struct lttng_session *session = channel->session;
1203 struct lib_ring_buffer *buf;
1204 int ret;
1205 struct lttng_metadata_stream *metadata_stream;
1206 void *stream_priv;
1207
1208 buf = channel->ops->buffer_read_open(channel->chan);
1209 if (!buf)
1210 return -ENOENT;
1211
1212 metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
1213 GFP_KERNEL);
b3b8072b
MD		 1214 if (!metadata_stream) {
1215 ret = -ENOMEM;
1216 goto nomem;
1217 }
d83004aa
JD		 1218 metadata_stream->metadata_cache = session->metadata_cache;
1219 init_waitqueue_head(&metadata_stream->read_wait);
1220 metadata_stream->priv = buf;
1221 stream_priv = metadata_stream;
b3b8072b 1222 metadata_stream->transport = channel->transport;
8b97fd42
MD		 1223 /* Initial state is an empty metadata, considered as incoherent. */
1224 metadata_stream->coherent = false;
b3b8072b
MD		 1225
1226 /*
1227 * Since life-time of metadata cache differs from that of
1228 * session, we need to keep our own reference on the transport.
1229 */
1230 if (!try_module_get(metadata_stream->transport->owner)) {
1231 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
1232 ret = -EINVAL;
1233 goto notransport;
1234 }
1235
901aaa5f
FD		 1236 if (!lttng_kref_get(&session->metadata_cache->refcount)) {
1237 ret = -EOVERFLOW;
9c1f4643 1238 goto kref_error;
901aaa5f
FD		 1239 }
1240
d83004aa
JD		 1241 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
1242 &lttng_metadata_ring_buffer_file_operations);
1243 if (ret < 0)
1244 goto fd_error;
1245
d83004aa
JD		 1246 list_add(&metadata_stream->list,
1247 &session->metadata_cache->metadata_stream);
1248 return ret;
1249
ad1c05e1 1250fd_error:
9c1f4643
MD		 1251 kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
1252kref_error:
b3b8072b
MD		 1253 module_put(metadata_stream->transport->owner);
1254notransport:
1255 kfree(metadata_stream);
1256nomem:
11b5a3c2 1257 channel->ops->buffer_read_close(buf);
ad1c05e1
MD		 1258 return ret;
1259}
1260
653fe716 1261static
c0e31d2e 1262int lttng_abi_create_event(struct file *channel_file,
6dccd6c1 1263 struct lttng_kernel_event *event_param)
653fe716 1264{
a90917c3 1265 struct lttng_channel *channel = channel_file->private_data;
653fe716 1266 int event_fd, ret;
11b5a3c2 1267 struct file *event_file;
3c997079 1268 void *priv;
653fe716 1269
6dccd6c1
JD		 1270 event_param->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
1271 switch (event_param->instrumentation) {
7371f44c 1272 case LTTNG_KERNEL_KRETPROBE:
6dccd6c1 1273 event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
7371f44c 1274 break;
ab2277d6 1275 case LTTNG_KERNEL_KPROBE:
6dccd6c1 1276 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
e0a7a7c4 1277 break;
ab2277d6 1278 case LTTNG_KERNEL_FUNCTION:
e884017c
MD		 1279 WARN_ON_ONCE(1);
1280 /* Not implemented. */
e0a7a7c4
MD		 1281 break;
1282 default:
1283 break;
1284 }
33a39a3c
MD		 1285 event_fd = lttng_get_unused_fd();
1286 if (event_fd < 0) {
1287 ret = event_fd;
1288 goto fd_error;
1289 }
1290 event_file = anon_inode_getfile("[lttng_event]",
1291 &lttng_event_fops,
1292 NULL, O_RDWR);
1293 if (IS_ERR(event_file)) {
1294 ret = PTR_ERR(event_file);
1295 goto file_error;
1296 }
9c1f4643 1297 /* The event holds a reference on the channel */
98d7281c 1298 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
0d2c717f 1299 ret = -EOVERFLOW;
9c1f4643
MD		 1300 goto refcount_error;
1301 }
33a39a3c
MD		 1302 if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
1303 || event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
1304 struct lttng_enabler *enabler;
1305
4993071a
PP		 1306 if (strutils_is_star_glob_pattern(event_param->name)) {
1307 /*
1308 * If the event name is a star globbing pattern,
1309 * we create the special star globbing enabler.
1310 */
1311 enabler = lttng_enabler_create(LTTNG_ENABLER_STAR_GLOB,
33a39a3c 1312 event_param, channel);
3c997079 1313 } else {
33a39a3c
MD		 1314 enabler = lttng_enabler_create(LTTNG_ENABLER_NAME,
1315 event_param, channel);
1ec65de1 1316 }
33a39a3c
MD		 1317 priv = enabler;
1318 } else {
1319 struct lttng_event *event;
4ee2453d 1320
33a39a3c
MD		 1321 /*
1322 * We tolerate no failure path after event creation. It
1323 * will stay invariant for the rest of the session.
1324 */
1325 event = lttng_event_create(channel, event_param,
1326 NULL, NULL,
1327 event_param->instrumentation);
1328 WARN_ON_ONCE(!event);
1329 if (IS_ERR(event)) {
1330 ret = PTR_ERR(event);
1331 goto event_error;
80f87dd2 1332 }
33a39a3c 1333 priv = event;
03037b98 1334 }
33a39a3c
MD		 1335 event_file->private_data = priv;
1336 fd_install(event_fd, event_file);
653fe716
MD		 1337 return event_fd;
1338
03037b98 1339event_error:
9c1f4643
MD		 1340 atomic_long_dec(&channel_file->f_count);
1341refcount_error:
c0e31d2e 1342 fput(event_file);
653fe716
MD		 1343file_error:
1344 put_unused_fd(event_fd);
1345fd_error:
653fe716
MD		 1346 return ret;
1347}
ad1c05e1
MD		 1348
1349/**
1350 * lttng_channel_ioctl - lttng syscall through ioctl
1351 *
c0e31d2e 1352 * @file: the file
ad1c05e1
MD		 1353 * @cmd: the command
1354 * @arg: command arg
1355 *
1356 * This ioctl implements lttng commands:
38d024ae 1357 * LTTNG_KERNEL_STREAM
ad1c05e1
MD		 1358 * Returns an event stream file descriptor or failure.
1359 * (typically, one event stream records events from one CPU)
38d024ae 1360 * LTTNG_KERNEL_EVENT
ad1c05e1 1361 * Returns an event file descriptor or failure.
8070f5c0
MD		 1362 * LTTNG_KERNEL_CONTEXT
1363 * Prepend a context field to each event in the channel
e64957da
MD		 1364 * LTTNG_KERNEL_ENABLE
1365 * Enable recording for events in this channel (weak enable)
1366 * LTTNG_KERNEL_DISABLE
1367 * Disable recording for events in this channel (strong disable)
baf20995 1368 *
baf20995
MD		 1369 * Channel and event file descriptors also hold a reference on the session.
1370 */
ad1c05e1 1371static
c0e31d2e 1372long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
baf20995 1373{
a90917c3 1374 struct lttng_channel *channel = file->private_data;
8070f5c0 1375
baf20995 1376 switch (cmd) {
6dccd6c1 1377 case LTTNG_KERNEL_OLD_STREAM:
38d024ae 1378 case LTTNG_KERNEL_STREAM:
c0e31d2e 1379 return lttng_abi_open_stream(file);
6dccd6c1
JD		 1380 case LTTNG_KERNEL_OLD_EVENT:
1381 {
1382 struct lttng_kernel_event *uevent_param;
1383 struct lttng_kernel_old_event *old_uevent_param;
1384 int ret;
1385
1386 uevent_param = kmalloc(sizeof(struct lttng_kernel_event),
1387 GFP_KERNEL);
1388 if (!uevent_param) {
1389 ret = -ENOMEM;
1390 goto old_event_end;
1391 }
1392 old_uevent_param = kmalloc(
1393 sizeof(struct lttng_kernel_old_event),
1394 GFP_KERNEL);
1395 if (!old_uevent_param) {
1396 ret = -ENOMEM;
1397 goto old_event_error_free_param;
1398 }
1399 if (copy_from_user(old_uevent_param,
1400 (struct lttng_kernel_old_event __user *) arg,
1401 sizeof(struct lttng_kernel_old_event))) {
1402 ret = -EFAULT;
1403 goto old_event_error_free_old_param;
1404 }
1405
1406 memcpy(uevent_param->name, old_uevent_param->name,
1407 sizeof(uevent_param->name));
1408 uevent_param->instrumentation =
1409 old_uevent_param->instrumentation;
1410
1411 switch (old_uevent_param->instrumentation) {
1412 case LTTNG_KERNEL_KPROBE:
1413 uevent_param->u.kprobe.addr =
1414 old_uevent_param->u.kprobe.addr;
1415 uevent_param->u.kprobe.offset =
1416 old_uevent_param->u.kprobe.offset;
1417 memcpy(uevent_param->u.kprobe.symbol_name,
1418 old_uevent_param->u.kprobe.symbol_name,
1419 sizeof(uevent_param->u.kprobe.symbol_name));
1420 break;
1421 case LTTNG_KERNEL_KRETPROBE:
1422 uevent_param->u.kretprobe.addr =
1423 old_uevent_param->u.kretprobe.addr;
1424 uevent_param->u.kretprobe.offset =
1425 old_uevent_param->u.kretprobe.offset;
1426 memcpy(uevent_param->u.kretprobe.symbol_name,
1427 old_uevent_param->u.kretprobe.symbol_name,
1428 sizeof(uevent_param->u.kretprobe.symbol_name));
1429 break;
1430 case LTTNG_KERNEL_FUNCTION:
e884017c
MD		 1431 WARN_ON_ONCE(1);
1432 /* Not implemented. */
6dccd6c1
JD		 1433 break;
1434 default:
1435 break;
1436 }
1437 ret = lttng_abi_create_event(file, uevent_param);
1438
1439old_event_error_free_old_param:
1440 kfree(old_uevent_param);
1441old_event_error_free_param:
1442 kfree(uevent_param);
1443old_event_end:
1444 return ret;
1445 }
38d024ae 1446 case LTTNG_KERNEL_EVENT:
6dccd6c1
JD		 1447 {
1448 struct lttng_kernel_event uevent_param;
1449
1450 if (copy_from_user(&uevent_param,
1451 (struct lttng_kernel_event __user *) arg,
1452 sizeof(uevent_param)))
1453 return -EFAULT;
1454 return lttng_abi_create_event(file, &uevent_param);
1455 }
1456 case LTTNG_KERNEL_OLD_CONTEXT:
1457 {
1458 struct lttng_kernel_context *ucontext_param;
1459 struct lttng_kernel_old_context *old_ucontext_param;
1460 int ret;
1461
1462 ucontext_param = kmalloc(sizeof(struct lttng_kernel_context),
1463 GFP_KERNEL);
1464 if (!ucontext_param) {
1465 ret = -ENOMEM;
1466 goto old_ctx_end;
1467 }
1468 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_old_context),
1469 GFP_KERNEL);
1470 if (!old_ucontext_param) {
1471 ret = -ENOMEM;
1472 goto old_ctx_error_free_param;
1473 }
1474
1475 if (copy_from_user(old_ucontext_param,
1476 (struct lttng_kernel_old_context __user *) arg,
1477 sizeof(struct lttng_kernel_old_context))) {
1478 ret = -EFAULT;
1479 goto old_ctx_error_free_old_param;
1480 }
1481 ucontext_param->ctx = old_ucontext_param->ctx;
1482 memcpy(ucontext_param->padding, old_ucontext_param->padding,
1483 sizeof(ucontext_param->padding));
1484 /* only type that uses the union */
1485 if (old_ucontext_param->ctx == LTTNG_KERNEL_CONTEXT_PERF_COUNTER) {
1486 ucontext_param->u.perf_counter.type =
1487 old_ucontext_param->u.perf_counter.type;
1488 ucontext_param->u.perf_counter.config =
1489 old_ucontext_param->u.perf_counter.config;
1490 memcpy(ucontext_param->u.perf_counter.name,
1491 old_ucontext_param->u.perf_counter.name,
1492 sizeof(ucontext_param->u.perf_counter.name));
1493 }
1494
1495 ret = lttng_abi_add_context(file,
1496 ucontext_param,
1497 &channel->ctx, channel->session);
1498
1499old_ctx_error_free_old_param:
1500 kfree(old_ucontext_param);
1501old_ctx_error_free_param:
1502 kfree(ucontext_param);
1503old_ctx_end:
1504 return ret;
1505 }
8070f5c0 1506 case LTTNG_KERNEL_CONTEXT:
6dccd6c1
JD		 1507 {
1508 struct lttng_kernel_context ucontext_param;
1509
1510 if (copy_from_user(&ucontext_param,
8070f5c0 1511 (struct lttng_kernel_context __user *) arg,
6dccd6c1
JD		 1512 sizeof(ucontext_param)))
1513 return -EFAULT;
1514 return lttng_abi_add_context(file,
1515 &ucontext_param,
8070f5c0 1516 &channel->ctx, channel->session);
6dccd6c1
JD		 1517 }
1518 case LTTNG_KERNEL_OLD_ENABLE:
e64957da 1519 case LTTNG_KERNEL_ENABLE:
a90917c3 1520 return lttng_channel_enable(channel);
6dccd6c1 1521 case LTTNG_KERNEL_OLD_DISABLE:
e64957da 1522 case LTTNG_KERNEL_DISABLE:
a90917c3 1523 return lttng_channel_disable(channel);
12e579db
MD		 1524 case LTTNG_KERNEL_SYSCALL_MASK:
1525 return lttng_channel_syscall_mask(channel,
1526 (struct lttng_kernel_syscall_mask __user *) arg);
baf20995
MD		 1527 default:
1528 return -ENOIOCTLCMD;
1529 }
1530}
1531
5dbbdb43
MD		 1532/**
1533 * lttng_metadata_ioctl - lttng syscall through ioctl
1534 *
1535 * @file: the file
1536 * @cmd: the command
1537 * @arg: command arg
1538 *
1539 * This ioctl implements lttng commands:
38d024ae 1540 * LTTNG_KERNEL_STREAM
5dbbdb43
MD		 1541 * Returns an event stream file descriptor or failure.
1542 *
1543 * Channel and event file descriptors also hold a reference on the session.
1544 */
1545static
1546long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1547{
1548 switch (cmd) {
6dccd6c1 1549 case LTTNG_KERNEL_OLD_STREAM:
38d024ae 1550 case LTTNG_KERNEL_STREAM:
d83004aa 1551 return lttng_abi_open_metadata_stream(file);
5dbbdb43
MD		 1552 default:
1553 return -ENOIOCTLCMD;
1554 }
1555}
1556
653fe716
MD		 1557/**
1558 * lttng_channel_poll - lttng stream addition/removal monitoring
1559 *
c0e31d2e 1560 * @file: the file
653fe716
MD		 1561 * @wait: poll table
1562 */
c0e31d2e 1563unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
653fe716 1564{
a90917c3 1565 struct lttng_channel *channel = file->private_data;
653fe716
MD		 1566 unsigned int mask = 0;
1567
c0e31d2e 1568 if (file->f_mode & FMODE_READ) {
a33e44a6 1569 poll_wait_set_exclusive(wait);
24cedcfe
MD		 1570 poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan),
1571 wait);
653fe716 1572
254ec7bc
MD		 1573 if (channel->ops->is_disabled(channel->chan))
1574 return POLLERR;
24cedcfe 1575 if (channel->ops->is_finalized(channel->chan))
653fe716 1576 return POLLHUP;
f71ecafa 1577 if (channel->ops->buffer_has_read_closed_stream(channel->chan))
653fe716 1578 return POLLIN | POLLRDNORM;
f71ecafa 1579 return 0;
653fe716
MD		 1580 }
1581 return mask;
1582
1583}
1584
0a84a57f
MD		 1585static
1586int lttng_channel_release(struct inode *inode, struct file *file)
1587{
a90917c3 1588 struct lttng_channel *channel = file->private_data;
c269fff4
MD		 1589
1590 if (channel)
1591 fput(channel->session->file);
0a84a57f
MD		 1592 return 0;
1593}
1594
d83004aa
JD		 1595static
1596int lttng_metadata_channel_release(struct inode *inode, struct file *file)
1597{
1598 struct lttng_channel *channel = file->private_data;
1599
1600 if (channel) {
d83004aa 1601 fput(channel->session->file);
a3381417 1602 lttng_metadata_channel_destroy(channel);
d83004aa
JD		 1603 }
1604
1605 return 0;
1606}
1607
ad1c05e1 1608static const struct file_operations lttng_channel_fops = {
a33c9927 1609 .owner = THIS_MODULE,
03037b98 1610 .release = lttng_channel_release,
653fe716 1611 .poll = lttng_channel_poll,
ad1c05e1 1612 .unlocked_ioctl = lttng_channel_ioctl,
baf20995 1613#ifdef CONFIG_COMPAT
03037b98 1614 .compat_ioctl = lttng_channel_ioctl,
baf20995 1615#endif
11b5a3c2 1616};
baf20995 1617
5dbbdb43 1618static const struct file_operations lttng_metadata_fops = {
a33c9927 1619 .owner = THIS_MODULE,
d83004aa 1620 .release = lttng_metadata_channel_release,
5dbbdb43
MD		 1621 .unlocked_ioctl = lttng_metadata_ioctl,
1622#ifdef CONFIG_COMPAT
1623 .compat_ioctl = lttng_metadata_ioctl,
1624#endif
1625};
1626
8070f5c0
MD		 1627/**
1628 * lttng_event_ioctl - lttng syscall through ioctl
1629 *
1630 * @file: the file
1631 * @cmd: the command
1632 * @arg: command arg
1633 *
1634 * This ioctl implements lttng commands:
8070f5c0
MD		 1635 * LTTNG_KERNEL_CONTEXT
1636 * Prepend a context field to each record of this event
e64957da
MD		 1637 * LTTNG_KERNEL_ENABLE
1638 * Enable recording for this event (weak enable)
1639 * LTTNG_KERNEL_DISABLE
1640 * Disable recording for this event (strong disable)
8070f5c0
MD		 1641 */
1642static
1643long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1644{
3c997079
MD		 1645 struct lttng_event *event;
1646 struct lttng_enabler *enabler;
1647 enum lttng_event_type *evtype = file->private_data;
8070f5c0
MD		 1648
1649 switch (cmd) {
6dccd6c1
JD		 1650 case LTTNG_KERNEL_OLD_CONTEXT:
1651 {
3c997079
MD		 1652 /* Not implemented */
1653 return -ENOSYS;
6dccd6c1 1654 }
8070f5c0 1655 case LTTNG_KERNEL_CONTEXT:
6dccd6c1 1656 {
3c997079
MD		 1657 /* Not implemented */
1658 return -ENOSYS;
6dccd6c1
JD		 1659 }
1660 case LTTNG_KERNEL_OLD_ENABLE:
e64957da 1661 case LTTNG_KERNEL_ENABLE:
3c997079
MD		 1662 switch (*evtype) {
1663 case LTTNG_TYPE_EVENT:
1664 event = file->private_data;
1665 return lttng_event_enable(event);
1666 case LTTNG_TYPE_ENABLER:
1667 enabler = file->private_data;
1668 return lttng_enabler_enable(enabler);
1669 default:
1670 WARN_ON_ONCE(1);
1671 return -ENOSYS;
1672 }
6dccd6c1 1673 case LTTNG_KERNEL_OLD_DISABLE:
e64957da 1674 case LTTNG_KERNEL_DISABLE:
3c997079
MD		 1675 switch (*evtype) {
1676 case LTTNG_TYPE_EVENT:
1677 event = file->private_data;
1678 return lttng_event_disable(event);
1679 case LTTNG_TYPE_ENABLER:
1680 enabler = file->private_data;
1681 return lttng_enabler_disable(enabler);
1682 default:
1683 WARN_ON_ONCE(1);
1684 return -ENOSYS;
1685 }
07dfc1d0
MD		 1686 case LTTNG_KERNEL_FILTER:
1687 switch (*evtype) {
1688 case LTTNG_TYPE_EVENT:
1689 return -EINVAL;
1690 case LTTNG_TYPE_ENABLER:
1691 {
1692 enabler = file->private_data;
1693 return lttng_enabler_attach_bytecode(enabler,
1694 (struct lttng_kernel_filter_bytecode __user *) arg);
1695 }
0586316f
MD		 1696 default:
1697 WARN_ON_ONCE(1);
1698 return -ENOSYS;
07dfc1d0 1699 }
3aed4dca
FD		 1700 case LTTNG_KERNEL_ADD_CALLSITE:
1701 switch (*evtype) {
1702 case LTTNG_TYPE_EVENT:
1703 event = file->private_data;
1704 return lttng_event_add_callsite(event,
1705 (struct lttng_kernel_event_callsite __user *) arg);
1706 case LTTNG_TYPE_ENABLER:
1707 return -EINVAL;
64c147c0
MD		 1708 default:
1709 WARN_ON_ONCE(1);
1710 return -ENOSYS;
3aed4dca 1711 }
8070f5c0
MD		 1712 default:
1713 return -ENOIOCTLCMD;
1714 }
1715}
1716
0a84a57f
MD		 1717static
1718int lttng_event_release(struct inode *inode, struct file *file)
1719{
3c997079
MD		 1720 struct lttng_event *event;
1721 struct lttng_enabler *enabler;
1722 enum lttng_event_type *evtype = file->private_data;
1723
1724 if (!evtype)
1725 return 0;
1726
1727 switch (*evtype) {
1728 case LTTNG_TYPE_EVENT:
1729 event = file->private_data;
1730 if (event)
1731 fput(event->chan->file);
1732 break;
1733 case LTTNG_TYPE_ENABLER:
1734 enabler = file->private_data;
1735 if (enabler)
1736 fput(enabler->chan->file);
1737 break;
1738 default:
1739 WARN_ON_ONCE(1);
1740 break;
1741 }
c269fff4 1742
0a84a57f
MD		 1743 return 0;
1744}
1745
3b923e5b 1746/* TODO: filter control ioctl */
0a84a57f 1747static const struct file_operations lttng_event_fops = {
a33c9927 1748 .owner = THIS_MODULE,
0a84a57f 1749 .release = lttng_event_release,
8070f5c0
MD		 1750 .unlocked_ioctl = lttng_event_ioctl,
1751#ifdef CONFIG_COMPAT
1752 .compat_ioctl = lttng_event_ioctl,
1753#endif
11b5a3c2 1754};
0a84a57f 1755
3b731ab1
JD		 1756static int put_u64(uint64_t val, unsigned long arg)
1757{
1758 return put_user(val, (uint64_t __user *) arg);
1759}
1760
8b97fd42
MD		 1761static int put_u32(uint32_t val, unsigned long arg)
1762{
1763 return put_user(val, (uint32_t __user *) arg);
1764}
1765
ed8d02d6
JD		 1766static long lttng_stream_ring_buffer_ioctl(struct file *filp,
1767 unsigned int cmd, unsigned long arg)
1768{
3b731ab1
JD		 1769 struct lib_ring_buffer *buf = filp->private_data;
1770 struct channel *chan = buf->backend.chan;
1771 const struct lib_ring_buffer_config *config = &chan->backend.config;
dd5a0db3 1772 const struct lttng_channel_ops *ops = chan->backend.priv_ops;
3b731ab1
JD		 1773 int ret;
1774
1775 if (atomic_read(&chan->record_disabled))
1776 return -EIO;
1777
ed8d02d6 1778 switch (cmd) {
3b731ab1
JD		 1779 case LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN:
1780 {
1781 uint64_t ts;
1782
dd5a0db3 1783 ret = ops->timestamp_begin(config, buf, &ts);
3b731ab1
JD		 1784 if (ret < 0)
1785 goto error;
1786 return put_u64(ts, arg);
1787 }
1788 case LTTNG_RING_BUFFER_GET_TIMESTAMP_END:
1789 {
1790 uint64_t ts;
1791
dd5a0db3 1792 ret = ops->timestamp_end(config, buf, &ts);
3b731ab1
JD		 1793 if (ret < 0)
1794 goto error;
1795 return put_u64(ts, arg);
1796 }
1797 case LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED:
1798 {
1799 uint64_t ed;
1800
dd5a0db3 1801 ret = ops->events_discarded(config, buf, &ed);
3b731ab1
JD		 1802 if (ret < 0)
1803 goto error;
1804 return put_u64(ed, arg);
1805 }
1806 case LTTNG_RING_BUFFER_GET_CONTENT_SIZE:
1807 {
1808 uint64_t cs;
1809
dd5a0db3 1810 ret = ops->content_size(config, buf, &cs);
3b731ab1
JD		 1811 if (ret < 0)
1812 goto error;
1813 return put_u64(cs, arg);
1814 }
1815 case LTTNG_RING_BUFFER_GET_PACKET_SIZE:
1816 {
1817 uint64_t ps;
1818
dd5a0db3 1819 ret = ops->packet_size(config, buf, &ps);
3b731ab1
JD		 1820 if (ret < 0)
1821 goto error;
1822 return put_u64(ps, arg);
1823 }
1824 case LTTNG_RING_BUFFER_GET_STREAM_ID:
1825 {
1826 uint64_t si;
1827
dd5a0db3 1828 ret = ops->stream_id(config, buf, &si);
3b731ab1
JD		 1829 if (ret < 0)
1830 goto error;
1831 return put_u64(si, arg);
1832 }
2348ca17
JD		 1833 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
1834 {
1835 uint64_t ts;
1836
dd5a0db3 1837 ret = ops->current_timestamp(config, buf, &ts);
2348ca17
JD		 1838 if (ret < 0)
1839 goto error;
1840 return put_u64(ts, arg);
1841 }
5b3cf4f9
JD		 1842 case LTTNG_RING_BUFFER_GET_SEQ_NUM:
1843 {
1844 uint64_t seq;
1845
1846 ret = ops->sequence_number(config, buf, &seq);
1847 if (ret < 0)
1848 goto error;
1849 return put_u64(seq, arg);
1850 }
5594698f
JD		 1851 case LTTNG_RING_BUFFER_INSTANCE_ID:
1852 {
1853 uint64_t id;
1854
1855 ret = ops->instance_id(config, buf, &id);
1856 if (ret < 0)
1857 goto error;
1858 return put_u64(id, arg);
1859 }
3b731ab1
JD		 1860 default:
1861 return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
1862 cmd, arg);
ed8d02d6 1863 }
3b731ab1
JD		 1864
1865error:
1866 return -ENOSYS;
ed8d02d6
JD		 1867}
1868
1869#ifdef CONFIG_COMPAT
1870static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp,
1871 unsigned int cmd, unsigned long arg)
1872{
3b731ab1
JD		 1873 struct lib_ring_buffer *buf = filp->private_data;
1874 struct channel *chan = buf->backend.chan;
1875 const struct lib_ring_buffer_config *config = &chan->backend.config;
dd5a0db3 1876 const struct lttng_channel_ops *ops = chan->backend.priv_ops;
3b731ab1
JD		 1877 int ret;
1878
1879 if (atomic_read(&chan->record_disabled))
1880 return -EIO;
1881
ed8d02d6 1882 switch (cmd) {
3b731ab1
JD		 1883 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN:
1884 {
1885 uint64_t ts;
1886
dd5a0db3 1887 ret = ops->timestamp_begin(config, buf, &ts);
3b731ab1
JD		 1888 if (ret < 0)
1889 goto error;
1890 return put_u64(ts, arg);
1891 }
1892 case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END:
1893 {
1894 uint64_t ts;
1895
dd5a0db3 1896 ret = ops->timestamp_end(config, buf, &ts);
3b731ab1
JD		 1897 if (ret < 0)
1898 goto error;
1899 return put_u64(ts, arg);
1900 }
1901 case LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED:
1902 {
1903 uint64_t ed;
1904
dd5a0db3 1905 ret = ops->events_discarded(config, buf, &ed);
3b731ab1
JD		 1906 if (ret < 0)
1907 goto error;
1908 return put_u64(ed, arg);
ed8d02d6 1909 }
3b731ab1
JD		 1910 case LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE:
1911 {
1912 uint64_t cs;
1913
dd5a0db3 1914 ret = ops->content_size(config, buf, &cs);
3b731ab1
JD		 1915 if (ret < 0)
1916 goto error;
1917 return put_u64(cs, arg);
1918 }
1919 case LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE:
1920 {
1921 uint64_t ps;
1922
dd5a0db3 1923 ret = ops->packet_size(config, buf, &ps);
3b731ab1
JD		 1924 if (ret < 0)
1925 goto error;
1926 return put_u64(ps, arg);
1927 }
1928 case LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID:
1929 {
1930 uint64_t si;
1931
dd5a0db3 1932 ret = ops->stream_id(config, buf, &si);
3b731ab1
JD		 1933 if (ret < 0)
1934 goto error;
1935 return put_u64(si, arg);
1936 }
2348ca17
JD		 1937 case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
1938 {
1939 uint64_t ts;
1940
dd5a0db3 1941 ret = ops->current_timestamp(config, buf, &ts);
2348ca17
JD		 1942 if (ret < 0)
1943 goto error;
1944 return put_u64(ts, arg);
1945 }
5b3cf4f9
JD		 1946 case LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM:
1947 {
1948 uint64_t seq;
1949
1950 ret = ops->sequence_number(config, buf, &seq);
1951 if (ret < 0)
1952 goto error;
1953 return put_u64(seq, arg);
1954 }
5594698f
JD		 1955 case LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID:
1956 {
1957 uint64_t id;
1958
1959 ret = ops->instance_id(config, buf, &id);
1960 if (ret < 0)
1961 goto error;
1962 return put_u64(id, arg);
1963 }
3b731ab1
JD		 1964 default:
1965 return lib_ring_buffer_file_operations.compat_ioctl(filp,
1966 cmd, arg);
1967 }
1968
1969error:
1970 return -ENOSYS;
ed8d02d6
JD		 1971}
1972#endif /* CONFIG_COMPAT */
1973
1974static void lttng_stream_override_ring_buffer_fops(void)
1975{
1976 lttng_stream_ring_buffer_file_operations.owner = THIS_MODULE;
1977 lttng_stream_ring_buffer_file_operations.open =
1978 lib_ring_buffer_file_operations.open;
1979 lttng_stream_ring_buffer_file_operations.release =
1980 lib_ring_buffer_file_operations.release;
1981 lttng_stream_ring_buffer_file_operations.poll =
1982 lib_ring_buffer_file_operations.poll;
1983 lttng_stream_ring_buffer_file_operations.splice_read =
1984 lib_ring_buffer_file_operations.splice_read;
1985 lttng_stream_ring_buffer_file_operations.mmap =
1986 lib_ring_buffer_file_operations.mmap;
1987 lttng_stream_ring_buffer_file_operations.unlocked_ioctl =
1988 lttng_stream_ring_buffer_ioctl;
1989 lttng_stream_ring_buffer_file_operations.llseek =
1990 lib_ring_buffer_file_operations.llseek;
1991#ifdef CONFIG_COMPAT
1992 lttng_stream_ring_buffer_file_operations.compat_ioctl =
1993 lttng_stream_ring_buffer_compat_ioctl;
1994#endif
1995}
1996
80996790 1997int __init lttng_abi_init(void)
baf20995
MD		 1998{
1999 int ret = 0;
2000
263b6c88 2001 wrapper_vmalloc_sync_mappings();
2754583e 2002 lttng_clock_ref();
f771eda6
JD		 2003
2004 ret = lttng_tp_mempool_init();
2005 if (ret) {
2006 goto error;
2007 }
2008
d29348f7 2009 lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
059de147 2010 &lttng_proc_ops, NULL);
2470a237 2011
255e52a4 2012 if (!lttng_proc_dentry) {
baf20995
MD		 2013 printk(KERN_ERR "Error creating LTTng control file\n");
2014 ret = -ENOMEM;
2015 goto error;
2016 }
ed8d02d6 2017 lttng_stream_override_ring_buffer_fops();
2754583e 2018 return 0;
ed8d02d6 2019
baf20995 2020error:
f771eda6 2021 lttng_tp_mempool_destroy();
2754583e 2022 lttng_clock_unref();
baf20995
MD		 2023 return ret;
2024}
2025
e6e65fcd
MD		 2026/* No __exit annotation because used by init error path too. */
2027void lttng_abi_exit(void)
baf20995 2028{
f771eda6 2029 lttng_tp_mempool_destroy();
2754583e 2030 lttng_clock_unref();
e6a17f26
MD		 2031 if (lttng_proc_dentry)
2032 remove_proc_entry("lttng", NULL);
baf20995 2033}
LTTng 2.0/0.x modules
This page took 0.141361 seconds and 4 git commands to generate.