projects / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: scsi: sd: Atomic write support added in 6.11-rc1
[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
a27c8df7 26#include <asm/barrier.h>
11b5a3c2 27#include <linux/module.h>
e6a17f26 28#include <linux/proc_fs.h>
11b5a3c2
MD		 29#include <linux/anon_inodes.h>
30#include <linux/file.h>
31#include <linux/uaccess.h>
32#include <linux/slab.h>
abc0446a 33#include <linux/err.h>
263b6c88 34#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
24591303
MD		 35#include <ringbuffer/vfs.h>
36#include <ringbuffer/backend.h>
37#include <ringbuffer/frontend.h>
c190d76e 38#include <wrapper/compiler_attributes.h>
241ae9a8 39#include <wrapper/poll.h>
241ae9a8 40#include <wrapper/kref.h>
6ef1e2f5 41#include <wrapper/uaccess.h>
2df37e95
MD		 42#include <lttng/string-utils.h>
43#include <lttng/abi.h>
44#include <lttng/abi-old.h>
45#include <lttng/events.h>
92bc1e23 46#include <lttng/events-internal.h>
2df37e95
MD		 47#include <lttng/tracer.h>
48#include <lttng/tp-mempool.h>
24591303 49#include <ringbuffer/frontend_types.h>
db2511b4 50#include <ringbuffer/iterator.h>
baf20995
MD		 51
52/*
53 * This is LTTng's own personal way to create a system call as an external
80996790 54 * module. We use ioctl() on /proc/lttng.
baf20995
MD		 55 */
56
e6a17f26 57static struct proc_dir_entry *lttng_proc_dentry;
059de147 58
5f4c791e 59#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
059de147
MJ		 60static const struct proc_ops lttng_proc_ops;
61#else
62static const struct file_operations lttng_proc_ops;
63#endif
64
ad1c05e1 65static const struct file_operations lttng_session_fops;
750b05f2 66static const struct file_operations lttng_event_notifier_group_fops;
ad1c05e1 67static const struct file_operations lttng_channel_fops;
5dbbdb43 68static const struct file_operations lttng_metadata_fops;
1437a010
MD		 69static const struct file_operations lttng_event_session_fops;
70static const struct file_operations lttng_event_session_enabler_fops;
ed8d02d6 71static struct file_operations lttng_stream_ring_buffer_file_operations;
baf20995 72
9616f0bf 73static int put_u64(uint64_t val, unsigned long arg);
8b97fd42 74static int put_u32(uint32_t val, unsigned long arg);
9616f0bf 75
6ef1e2f5
MD		 76static
77int lttng_abi_create_event_counter_enabler(struct file *channel_file,
7b0f1e69 78 struct lttng_kernel_counter_event *counter_event);
2ff86ce2
MD		 79static
80long lttng_abi_session_create_counter(
81 struct lttng_kernel_session *session,
81ab5b77 82 const struct lttng_kernel_counter_conf *counter_conf);
6ef1e2f5 83
99f52fcc
FD		 84static int validate_zeroed_padding(char *p, size_t len)
85{
86 size_t i;
87
88 for (i = 0; i < len; i++) {
89 if (p[i])
90 return -1;
91 }
92 return 0;
93}
94
a33c9927
MD		 95/*
96 * Teardown management: opened file descriptors keep a refcount on the module,
97 * so it can only exit when all file descriptors are closed.
98 */
99
ad1c05e1 100static
baf20995
MD		 101int lttng_abi_create_session(void)
102{
8cdc1a81 103 struct lttng_kernel_session *session;
c0e31d2e 104 struct file *session_file;
11b5a3c2 105 int session_fd, ret;
baf20995 106
a90917c3 107 session = lttng_session_create();
baf20995
MD		 108 if (!session)
109 return -ENOMEM;
2a059b14 110 session_fd = get_unused_fd_flags(0);
baf20995
MD		 111 if (session_fd < 0) {
112 ret = session_fd;
113 goto fd_error;
114 }
c0e31d2e 115 session_file = anon_inode_getfile("[lttng_session]",
ad1c05e1 116 &lttng_session_fops,
baf20995 117 session, O_RDWR);
c0e31d2e
MD		 118 if (IS_ERR(session_file)) {
119 ret = PTR_ERR(session_file);
baf20995
MD		 120 goto file_error;
121 }
8cdc1a81 122 session->priv->file = session_file;
c0e31d2e 123 fd_install(session_fd, session_file);
baf20995
MD		 124 return session_fd;
125
126file_error:
127 put_unused_fd(session_fd);
128fd_error:
a90917c3 129 lttng_session_destroy(session);
baf20995
MD		 130 return ret;
131}
132
56386a64 133static
21f58fb7
FD		 134void event_notifier_send_notification_work_wakeup(struct irq_work *entry)
135{
136 struct lttng_event_notifier_group *event_notifier_group =
137 container_of(entry, struct lttng_event_notifier_group,
138 wakeup_pending);
139 wake_up_interruptible(&event_notifier_group->read_wait);
140}
141
750b05f2
FD		 142static
143int lttng_abi_create_event_notifier_group(void)
144{
145 struct lttng_event_notifier_group *event_notifier_group;
146 struct file *event_notifier_group_file;
147 int event_notifier_group_fd, ret;
148
149 event_notifier_group = lttng_event_notifier_group_create();
150 if (!event_notifier_group)
151 return -ENOMEM;
152
2a059b14 153 event_notifier_group_fd = get_unused_fd_flags(0);
750b05f2
FD		 154 if (event_notifier_group_fd < 0) {
155 ret = event_notifier_group_fd;
156 goto fd_error;
157 }
158 event_notifier_group_file = anon_inode_getfile("[lttng_event_notifier_group]",
159 &lttng_event_notifier_group_fops,
160 event_notifier_group, O_RDWR);
161 if (IS_ERR(event_notifier_group_file)) {
162 ret = PTR_ERR(event_notifier_group_file);
163 goto file_error;
164 }
165
166 event_notifier_group->file = event_notifier_group_file;
21f58fb7
FD		 167 init_waitqueue_head(&event_notifier_group->read_wait);
168 init_irq_work(&event_notifier_group->wakeup_pending,
169 event_notifier_send_notification_work_wakeup);
750b05f2
FD		 170 fd_install(event_notifier_group_fd, event_notifier_group_file);
171 return event_notifier_group_fd;
172
173file_error:
174 put_unused_fd(event_notifier_group_fd);
175fd_error:
176 lttng_event_notifier_group_destroy(event_notifier_group);
177 return ret;
178}
179
271b6681
MD		 180static
181int lttng_abi_tracepoint_list(void)
182{
183 struct file *tracepoint_list_file;
184 int file_fd, ret;
185
2a059b14 186 file_fd = get_unused_fd_flags(0);
271b6681
MD		 187 if (file_fd < 0) {
188 ret = file_fd;
189 goto fd_error;
190 }
30f18bf0 191
8ee099b6 192 tracepoint_list_file = anon_inode_getfile("[lttng_tracepoint_list]",
271b6681
MD		 193 &lttng_tracepoint_list_fops,
194 NULL, O_RDWR);
195 if (IS_ERR(tracepoint_list_file)) {
196 ret = PTR_ERR(tracepoint_list_file);
197 goto file_error;
198 }
30f18bf0
MD		 199 ret = lttng_tracepoint_list_fops.open(NULL, tracepoint_list_file);
200 if (ret < 0)
201 goto open_error;
271b6681
MD		 202 fd_install(file_fd, tracepoint_list_file);
203 return file_fd;
204
30f18bf0
MD		 205open_error:
206 fput(tracepoint_list_file);
271b6681
MD		 207file_error:
208 put_unused_fd(file_fd);
209fd_error:
210 return ret;
211}
212
f127e61e
MD		 213#ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
214static inline
215int lttng_abi_syscall_list(void)
216{
217 return -ENOSYS;
218}
219#else
220static
221int lttng_abi_syscall_list(void)
222{
223 struct file *syscall_list_file;
224 int file_fd, ret;
225
2a059b14 226 file_fd = get_unused_fd_flags(0);
f127e61e
MD		 227 if (file_fd < 0) {
228 ret = file_fd;
229 goto fd_error;
230 }
231
232 syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
233 &lttng_syscall_list_fops,
234 NULL, O_RDWR);
235 if (IS_ERR(syscall_list_file)) {
236 ret = PTR_ERR(syscall_list_file);
237 goto file_error;
238 }
239 ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
240 if (ret < 0)
241 goto open_error;
242 fd_install(file_fd, syscall_list_file);
f127e61e
MD		 243 return file_fd;
244
245open_error:
246 fput(syscall_list_file);
247file_error:
248 put_unused_fd(file_fd);
249fd_error:
250 return ret;
251}
252#endif
253
80c16bcf 254static
606828e4 255void lttng_abi_tracer_version(struct lttng_kernel_abi_tracer_version *v)
80c16bcf 256{
6dccd6c1
JD		 257 v->major = LTTNG_MODULES_MAJOR_VERSION;
258 v->minor = LTTNG_MODULES_MINOR_VERSION;
259 v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
80c16bcf
MD		 260}
261
42cabb80 262static
606828e4 263void lttng_abi_tracer_abi_version(struct lttng_kernel_abi_tracer_abi_version *v)
42cabb80 264{
606828e4
MD		 265 v->major = LTTNG_KERNEL_ABI_MAJOR_VERSION;
266 v->minor = LTTNG_KERNEL_ABI_MINOR_VERSION;
42cabb80
MD		 267}
268
8070f5c0
MD		 269static
270long lttng_abi_add_context(struct file *file,
606828e4 271 struct lttng_kernel_abi_context *context_param,
8cdc1a81 272 struct lttng_kernel_ctx **ctx, struct lttng_kernel_session *session)
8070f5c0 273{
8070f5c0 274
8cdc1a81 275 if (session->priv->been_active)
8070f5c0
MD		 276 return -EPERM;
277
6dccd6c1 278 switch (context_param->ctx) {
606828e4 279 case LTTNG_KERNEL_ABI_CONTEXT_PID:
8070f5c0 280 return lttng_add_pid_to_ctx(ctx);
606828e4 281 case LTTNG_KERNEL_ABI_CONTEXT_PRIO:
a8ad3613 282 return lttng_add_prio_to_ctx(ctx);
606828e4 283 case LTTNG_KERNEL_ABI_CONTEXT_NICE:
53f1f0ca 284 return lttng_add_nice_to_ctx(ctx);
606828e4 285 case LTTNG_KERNEL_ABI_CONTEXT_VPID:
b64bc438 286 return lttng_add_vpid_to_ctx(ctx);
606828e4 287 case LTTNG_KERNEL_ABI_CONTEXT_TID:
b64bc438 288 return lttng_add_tid_to_ctx(ctx);
606828e4 289 case LTTNG_KERNEL_ABI_CONTEXT_VTID:
b64bc438 290 return lttng_add_vtid_to_ctx(ctx);
606828e4 291 case LTTNG_KERNEL_ABI_CONTEXT_PPID:
b64bc438 292 return lttng_add_ppid_to_ctx(ctx);
606828e4 293 case LTTNG_KERNEL_ABI_CONTEXT_VPPID:
b64bc438 294 return lttng_add_vppid_to_ctx(ctx);
606828e4
MD		 295 case LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER:
296 context_param->u.perf_counter.name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
6dccd6c1
JD		 297 return lttng_add_perf_counter_to_ctx(context_param->u.perf_counter.type,
298 context_param->u.perf_counter.config,
299 context_param->u.perf_counter.name,
c24a0d71 300 ctx);
606828e4 301 case LTTNG_KERNEL_ABI_CONTEXT_PROCNAME:
a2563e83 302 return lttng_add_procname_to_ctx(ctx);
606828e4 303 case LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME:
975da2c0 304 return lttng_add_hostname_to_ctx(ctx);
606828e4 305 case LTTNG_KERNEL_ABI_CONTEXT_CPU_ID:
b3699d90 306 return lttng_add_cpu_id_to_ctx(ctx);
606828e4 307 case LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE:
79150a49 308 return lttng_add_interruptible_to_ctx(ctx);
606828e4 309 case LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE:
79150a49 310 return lttng_add_need_reschedule_to_ctx(ctx);
606828e4 311 case LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE:
79150a49 312 return lttng_add_preemptible_to_ctx(ctx);
606828e4 313 case LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE:
79150a49 314 return lttng_add_migratable_to_ctx(ctx);
606828e4
MD		 315 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL:
316 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER:
2fa2d39a 317 return lttng_add_callstack_to_ctx(ctx, context_param->ctx);
606828e4 318 case LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS:
a6cf40a4 319 return lttng_add_cgroup_ns_to_ctx(ctx);
606828e4 320 case LTTNG_KERNEL_ABI_CONTEXT_IPC_NS:
a6cf40a4 321 return lttng_add_ipc_ns_to_ctx(ctx);
606828e4 322 case LTTNG_KERNEL_ABI_CONTEXT_MNT_NS:
a6cf40a4 323 return lttng_add_mnt_ns_to_ctx(ctx);
606828e4 324 case LTTNG_KERNEL_ABI_CONTEXT_NET_NS:
a6cf40a4 325 return lttng_add_net_ns_to_ctx(ctx);
606828e4 326 case LTTNG_KERNEL_ABI_CONTEXT_PID_NS:
a6cf40a4 327 return lttng_add_pid_ns_to_ctx(ctx);
606828e4 328 case LTTNG_KERNEL_ABI_CONTEXT_USER_NS:
a6cf40a4 329 return lttng_add_user_ns_to_ctx(ctx);
606828e4 330 case LTTNG_KERNEL_ABI_CONTEXT_UTS_NS:
a6cf40a4 331 return lttng_add_uts_ns_to_ctx(ctx);
606828e4 332 case LTTNG_KERNEL_ABI_CONTEXT_UID:
dc923e75 333 return lttng_add_uid_to_ctx(ctx);
606828e4 334 case LTTNG_KERNEL_ABI_CONTEXT_EUID:
dc923e75 335 return lttng_add_euid_to_ctx(ctx);
606828e4 336 case LTTNG_KERNEL_ABI_CONTEXT_SUID:
dc923e75 337 return lttng_add_suid_to_ctx(ctx);
606828e4 338 case LTTNG_KERNEL_ABI_CONTEXT_GID:
dc923e75 339 return lttng_add_gid_to_ctx(ctx);
606828e4 340 case LTTNG_KERNEL_ABI_CONTEXT_EGID:
dc923e75 341 return lttng_add_egid_to_ctx(ctx);
606828e4 342 case LTTNG_KERNEL_ABI_CONTEXT_SGID:
dc923e75 343 return lttng_add_sgid_to_ctx(ctx);
606828e4 344 case LTTNG_KERNEL_ABI_CONTEXT_VUID:
dc923e75 345 return lttng_add_vuid_to_ctx(ctx);
606828e4 346 case LTTNG_KERNEL_ABI_CONTEXT_VEUID:
dc923e75 347 return lttng_add_veuid_to_ctx(ctx);
606828e4 348 case LTTNG_KERNEL_ABI_CONTEXT_VSUID:
dc923e75 349 return lttng_add_vsuid_to_ctx(ctx);
606828e4 350 case LTTNG_KERNEL_ABI_CONTEXT_VGID:
dc923e75 351 return lttng_add_vgid_to_ctx(ctx);
606828e4 352 case LTTNG_KERNEL_ABI_CONTEXT_VEGID:
dc923e75 353 return lttng_add_vegid_to_ctx(ctx);
606828e4 354 case LTTNG_KERNEL_ABI_CONTEXT_VSGID:
dc923e75 355 return lttng_add_vsgid_to_ctx(ctx);
606828e4 356 case LTTNG_KERNEL_ABI_CONTEXT_TIME_NS:
876e2e92 357 return lttng_add_time_ns_to_ctx(ctx);
8070f5c0
MD		 358 default:
359 return -EINVAL;
360 }
361}
362
ad1c05e1
MD		 363/**
364 * lttng_ioctl - lttng syscall through ioctl
365 *
c0e31d2e 366 * @file: the file
ad1c05e1
MD		 367 * @cmd: the command
368 * @arg: command arg
369 *
370 * This ioctl implements lttng commands:
606828e4 371 * LTTNG_KERNEL_ABI_SESSION
ad1c05e1 372 * Returns a LTTng trace session file descriptor
606828e4 373 * LTTNG_KERNEL_ABI_TRACER_VERSION
271b6681 374 * Returns the LTTng kernel tracer version
606828e4 375 * LTTNG_KERNEL_ABI_TRACEPOINT_LIST
271b6681 376 * Returns a file descriptor listing available tracepoints
606828e4 377 * LTTNG_KERNEL_ABI_WAIT_QUIESCENT
360f38ea 378 * Returns after all previously running probes have completed
606828e4 379 * LTTNG_KERNEL_ABI_TRACER_ABI_VERSION
42cabb80 380 * Returns the LTTng kernel tracer ABI version
606828e4 381 * LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE
750b05f2 382 * Returns a LTTng event notifier group file descriptor
ad1c05e1
MD		 383 *
384 * The returned session will be deleted when its file descriptor is closed.
385 */
386static
c0e31d2e 387long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
ad1c05e1
MD		 388{
389 switch (cmd) {
606828e4
MD		 390 case LTTNG_KERNEL_ABI_OLD_SESSION:
391 case LTTNG_KERNEL_ABI_SESSION:
ad1c05e1 392 return lttng_abi_create_session();
606828e4 393 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_CREATE:
750b05f2 394 return lttng_abi_create_event_notifier_group();
606828e4 395 case LTTNG_KERNEL_ABI_OLD_TRACER_VERSION:
6dccd6c1 396 {
606828e4
MD		 397 struct lttng_kernel_abi_tracer_version v;
398 struct lttng_kernel_abi_old_tracer_version oldv;
399 struct lttng_kernel_abi_old_tracer_version *uversion =
400 (struct lttng_kernel_abi_old_tracer_version __user *) arg;
6dccd6c1
JD		 401
402 lttng_abi_tracer_version(&v);
403 oldv.major = v.major;
404 oldv.minor = v.minor;
405 oldv.patchlevel = v.patchlevel;
406
407 if (copy_to_user(uversion, &oldv, sizeof(oldv)))
408 return -EFAULT;
409 return 0;
410 }
606828e4 411 case LTTNG_KERNEL_ABI_TRACER_VERSION:
6dccd6c1 412 {
606828e4
MD		 413 struct lttng_kernel_abi_tracer_version version;
414 struct lttng_kernel_abi_tracer_version *uversion =
415 (struct lttng_kernel_abi_tracer_version __user *) arg;
6dccd6c1
JD		 416
417 lttng_abi_tracer_version(&version);
42cabb80
MD		 418
419 if (copy_to_user(uversion, &version, sizeof(version)))
420 return -EFAULT;
421 return 0;
422 }
606828e4 423 case LTTNG_KERNEL_ABI_TRACER_ABI_VERSION:
42cabb80 424 {
606828e4
MD		 425 struct lttng_kernel_abi_tracer_abi_version version;
426 struct lttng_kernel_abi_tracer_abi_version *uversion =
427 (struct lttng_kernel_abi_tracer_abi_version __user *) arg;
42cabb80
MD		 428
429 lttng_abi_tracer_abi_version(&version);
430
6dccd6c1
JD		 431 if (copy_to_user(uversion, &version, sizeof(version)))
432 return -EFAULT;
433 return 0;
434 }
606828e4
MD		 435 case LTTNG_KERNEL_ABI_OLD_TRACEPOINT_LIST:
436 case LTTNG_KERNEL_ABI_TRACEPOINT_LIST:
271b6681 437 return lttng_abi_tracepoint_list();
606828e4 438 case LTTNG_KERNEL_ABI_SYSCALL_LIST:
2d2464bd 439 return lttng_abi_syscall_list();
606828e4
MD		 440 case LTTNG_KERNEL_ABI_OLD_WAIT_QUIESCENT:
441 case LTTNG_KERNEL_ABI_WAIT_QUIESCENT:
5f7f9078
MD		 442 synchronize_trace();
443 return 0;
606828e4 444 case LTTNG_KERNEL_ABI_OLD_CALIBRATE:
6dccd6c1 445 {
606828e4
MD		 446 struct lttng_kernel_abi_old_calibrate __user *ucalibrate =
447 (struct lttng_kernel_abi_old_calibrate __user *) arg;
448 struct lttng_kernel_abi_old_calibrate old_calibrate;
449 struct lttng_kernel_abi_calibrate calibrate;
6dccd6c1
JD		 450 int ret;
451
452 if (copy_from_user(&old_calibrate, ucalibrate, sizeof(old_calibrate)))
453 return -EFAULT;
454 calibrate.type = old_calibrate.type;
455 ret = lttng_calibrate(&calibrate);
456 if (copy_to_user(ucalibrate, &old_calibrate, sizeof(old_calibrate)))
457 return -EFAULT;
458 return ret;
459 }
606828e4 460 case LTTNG_KERNEL_ABI_CALIBRATE:
57105fc2 461 {
606828e4
MD		 462 struct lttng_kernel_abi_calibrate __user *ucalibrate =
463 (struct lttng_kernel_abi_calibrate __user *) arg;
464 struct lttng_kernel_abi_calibrate calibrate;
57105fc2
MD		 465 int ret;
466
467 if (copy_from_user(&calibrate, ucalibrate, sizeof(calibrate)))
468 return -EFAULT;
469 ret = lttng_calibrate(&calibrate);
470 if (copy_to_user(ucalibrate, &calibrate, sizeof(calibrate)))
471 return -EFAULT;
472 return ret;
473 }
ad1c05e1
MD		 474 default:
475 return -ENOIOCTLCMD;
476 }
477}
478
5f4c791e 479#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
059de147
MJ		 480static const struct proc_ops lttng_proc_ops = {
481 .proc_ioctl = lttng_ioctl,
482#ifdef CONFIG_COMPAT
483 .proc_compat_ioctl = lttng_ioctl,
484#endif /* CONFIG_COMPAT */
485};
486#else
487static const struct file_operations lttng_proc_ops = {
a33c9927 488 .owner = THIS_MODULE,
ad1c05e1
MD		 489 .unlocked_ioctl = lttng_ioctl,
490#ifdef CONFIG_COMPAT
03037b98 491 .compat_ioctl = lttng_ioctl,
059de147 492#endif /* CONFIG_COMPAT */
11b5a3c2 493};
059de147 494#endif
ad1c05e1 495
5dbbdb43 496static
c0e31d2e 497int lttng_abi_create_channel(struct file *session_file,
606828e4 498 struct lttng_kernel_abi_channel *chan_param,
5dbbdb43 499 enum channel_type channel_type)
baf20995 500{
8cdc1a81 501 struct lttng_kernel_session *session = session_file->private_data;
88dfd899 502 const struct file_operations *fops = NULL;
5dbbdb43 503 const char *transport_name;
f7d06400 504 struct lttng_kernel_channel_buffer *chan;
c0e31d2e 505 struct file *chan_file;
baf20995 506 int chan_fd;
ad1c05e1 507 int ret = 0;
baf20995 508
2a059b14 509 chan_fd = get_unused_fd_flags(0);
baf20995
MD		 510 if (chan_fd < 0) {
511 ret = chan_fd;
512 goto fd_error;
513 }
88dfd899
MD		 514 switch (channel_type) {
515 case PER_CPU_CHANNEL:
516 fops = &lttng_channel_fops;
517 break;
518 case METADATA_CHANNEL:
519 fops = &lttng_metadata_fops;
520 break;
521 }
2470a237 522
c0e31d2e 523 chan_file = anon_inode_getfile("[lttng_channel]",
88dfd899 524 fops,
03037b98 525 NULL, O_RDWR);
c0e31d2e
MD		 526 if (IS_ERR(chan_file)) {
527 ret = PTR_ERR(chan_file);
baf20995
MD		 528 goto file_error;
529 }
5dbbdb43
MD		 530 switch (channel_type) {
531 case PER_CPU_CHANNEL:
606828e4 532 if (chan_param->output == LTTNG_KERNEL_ABI_SPLICE) {
6dccd6c1 533 transport_name = chan_param->overwrite ?
96ba7208 534 "relay-overwrite" : "relay-discard";
606828e4 535 } else if (chan_param->output == LTTNG_KERNEL_ABI_MMAP) {
6dccd6c1 536 transport_name = chan_param->overwrite ?
96ba7208
JD		 537 "relay-overwrite-mmap" : "relay-discard-mmap";
538 } else {
539 return -EINVAL;
540 }
5dbbdb43 541 break;
5dbbdb43 542 case METADATA_CHANNEL:
606828e4 543 if (chan_param->output == LTTNG_KERNEL_ABI_SPLICE)
96ba7208 544 transport_name = "relay-metadata";
606828e4 545 else if (chan_param->output == LTTNG_KERNEL_ABI_MMAP)
96ba7208
JD		 546 transport_name = "relay-metadata-mmap";
547 else
548 return -EINVAL;
5dbbdb43
MD		 549 break;
550 default:
551 transport_name = "<unknown>";
552 break;
553 }
98d7281c
MJ		 554 if (!atomic_long_add_unless(&session_file->f_count, 1, LONG_MAX)) {
555 ret = -EOVERFLOW;
9c1f4643
MD		 556 goto refcount_error;
557 }
03037b98
MD		 558 /*
559 * We tolerate no failure path after channel creation. It will stay
560 * invariant for the rest of the session.
561 */
4e252d1e 562 chan = lttng_channel_buffer_create(session, transport_name, NULL,
6dccd6c1
JD		 563 chan_param->subbuf_size,
564 chan_param->num_subbuf,
565 chan_param->switch_timer_interval,
d83004aa
JD		 566 chan_param->read_timer_interval,
567 channel_type);
03037b98 568 if (!chan) {
f3d01b96 569 ret = -EINVAL;
03037b98
MD		 570 goto chan_error;
571 }
f7d06400 572 chan->priv->parent.file = chan_file;
c0e31d2e
MD		 573 chan_file->private_data = chan;
574 fd_install(chan_fd, chan_file);
ad1c05e1 575
baf20995
MD		 576 return chan_fd;
577
03037b98 578chan_error:
9c1f4643
MD		 579 atomic_long_dec(&session_file->f_count);
580refcount_error:
c0e31d2e 581 fput(chan_file);
baf20995
MD		 582file_error:
583 put_unused_fd(chan_fd);
584fd_error:
baf20995
MD		 585 return ret;
586}
587
7f859fbf 588static
8cdc1a81 589int lttng_abi_session_set_name(struct lttng_kernel_session *session,
606828e4 590 struct lttng_kernel_abi_session_name *name)
7f859fbf
JR		 591{
592 size_t len;
593
606828e4 594 len = strnlen(name->name, LTTNG_KERNEL_ABI_SESSION_NAME_LEN);
7f859fbf 595
606828e4 596 if (len == LTTNG_KERNEL_ABI_SESSION_NAME_LEN) {
7f859fbf
JR		 597 /* Name is too long/malformed */
598 return -EINVAL;
599 }
600
8cdc1a81 601 strcpy(session->priv->name, name->name);
7f859fbf
JR		 602 return 0;
603}
604
1c88f269 605static
8cdc1a81 606int lttng_abi_session_set_creation_time(struct lttng_kernel_session *session,
606828e4 607 struct lttng_kernel_abi_session_creation_time *time)
1c88f269
JR		 608{
609 size_t len;
610
606828e4 611 len = strnlen(time->iso8601, LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN);
1c88f269 612
606828e4 613 if (len == LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN) {
1c88f269
JR		 614 /* Time is too long/malformed */
615 return -EINVAL;
616 }
617
8cdc1a81 618 strcpy(session->priv->creation_time, time->iso8601);
1c88f269
JR		 619 return 0;
620}
621
99f52fcc
FD		 622static
623int lttng_counter_release(struct inode *inode, struct file *file)
624{
76ba9cee 625 struct lttng_kernel_channel_counter *counter = file->private_data;
99f52fcc
FD		 626
627 if (counter) {
628 /*
629 * Do not destroy the counter itself. Wait of the owner
630 * (event_notifier group) to be destroyed.
631 */
76ba9cee 632 fput(counter->priv->owner);
99f52fcc
FD		 633 }
634
635 return 0;
636}
637
3bca4b7a
MD		 638static
639int copy_user_event_param_ext(struct lttng_kernel_abi_event_ext *event_param_ext,
640 struct lttng_kernel_abi_event *event_param)
641{
642 struct lttng_kernel_abi_event_ext __user *uevent_ext =
643 (struct lttng_kernel_abi_event_ext __user *) (unsigned long) event_param->event_ext;
644 uint32_t len;
645 int ret;
646
3bca4b7a
MD		 647 /* Use zeroed defaults if extension parameters are not set. */
648 if (!uevent_ext)
649 return 0;
650 ret = get_user(len, &uevent_ext->len);
651 if (ret)
652 return ret;
bd8af103
MD		 653 if (len > PAGE_SIZE)
654 return -E2BIG;
655 ret = lttng_copy_struct_from_user(event_param_ext, sizeof(*event_param_ext), uevent_ext, len);
656 if (ret)
657 return ret;
3bca4b7a
MD		 658 /* Ensure that len is consistent with the initial get_user(). */
659 event_param_ext->len = len;
bd8af103
MD		 660
661 /* Validate that we know of all flags and enum values used. */
662 switch (event_param_ext->match_check) {
663 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
664 lttng_fallthrough;
665 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
666 lttng_fallthrough;
667 case LTTNG_KERNEL_ABI_MATCH_LAZY:
668 break;
669 default:
670 return -EINVAL;
671 }
3bca4b7a
MD		 672 return 0;
673}
674
675static
676int user_event_param_ext_get_match_check(const struct lttng_kernel_abi_event_ext *event_param_ext,
677 enum lttng_kernel_abi_match_check *_match_check)
678{
679 enum lttng_kernel_abi_match_check match_check = LTTNG_KERNEL_ABI_MATCH_DEFAULT;
680
681 if (event_param_ext->len < offsetofend(struct lttng_kernel_abi_event_ext, match_check))
682 goto end;
683 match_check = event_param_ext->match_check;
3bca4b7a
MD		 684end:
685 *_match_check = match_check;
686 return 0;
687}
688
7b0f1e69 689static
d9a337ba
MD		 690int create_counter_key_from_abi_dimensions(struct lttng_kernel_counter_key **_counter_key,
691 uint32_t nr_dimensions, void __user *ptr)
7b0f1e69 692{
7b0f1e69
MD		 693 struct lttng_kernel_abi_counter_key_dimension __user *udimension;
694 struct lttng_kernel_abi_counter_key_dimension kdimension = {};
d9a337ba
MD		 695 struct lttng_kernel_counter_key *counter_key = NULL;
696 struct lttng_key_token *token_array = NULL;
697 uint32_t i;
7b0f1e69
MD		 698 int ret = 0;
699
7b0f1e69
MD		 700 if (!nr_dimensions || nr_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
701 return -EINVAL;
702 counter_key = kzalloc(sizeof(*counter_key), GFP_KERNEL);
703 if (!counter_key)
704 return -ENOMEM;
705 counter_key->nr_dimensions = nr_dimensions;
d9a337ba
MD		 706 /* Only a single dimension is supported. */
707 if (WARN_ON_ONCE(nr_dimensions != 1)) {
7b0f1e69
MD		 708 ret = -EINVAL;
709 goto error;
710 }
d9a337ba
MD		 711 udimension = (struct lttng_kernel_abi_counter_key_dimension __user *)ptr;
712 ret = lttng_copy_struct_from_user(&kdimension, sizeof(kdimension), udimension, sizeof(*udimension));
7b0f1e69
MD		 713 if (ret)
714 goto error;
d9a337ba 715 if (kdimension.len > PAGE_SIZE) {
7b0f1e69
MD		 716 ret = -E2BIG;
717 goto error;
718 }
d9a337ba
MD		 719 switch (kdimension.key_type) {
720 case LTTNG_KERNEL_ABI_KEY_TYPE_TOKENS:
721 {
722 struct lttng_kernel_abi_counter_key_dimension_tokens kdimension_tokens = {};
723 struct lttng_kernel_abi_counter_key_dimension_tokens __user *udimension_tokens;
724 struct lttng_kernel_abi_key_token __user *utoken;
725 uint32_t nr_tokens;
726
727 udimension_tokens = (struct lttng_kernel_abi_counter_key_dimension_tokens __user *)ptr;
728 ret = lttng_copy_struct_from_user(&kdimension_tokens, sizeof(kdimension_tokens),
729 udimension_tokens, kdimension.len);
7b0f1e69
MD		 730 if (ret)
731 goto error;
d9a337ba
MD		 732 nr_tokens = kdimension_tokens.nr_key_tokens;
733 if (nr_tokens > LTTNG_KERNEL_COUNTER_MAX_TOKENS) {
734 ret = -EINVAL;
735 goto error;
736 }
737 token_array = kzalloc(nr_tokens * sizeof(*token_array), GFP_KERNEL);
738 if (!token_array) {
739 ret = -ENOMEM;
740 goto error;
741 }
742 counter_key->dimension_array[0].token_array = token_array;
743 counter_key->dimension_array[0].nr_key_tokens = nr_tokens;
744 utoken = (struct lttng_kernel_abi_key_token __user *)((unsigned long)ptr + kdimension.len);
745 for (i = 0; i < nr_tokens; i++) {
746 struct lttng_kernel_abi_key_token ktoken = {};
747 struct lttng_key_token *key_token = &token_array[i];
748 uint32_t token_len = 0;
749
750 ret = lttng_copy_struct_from_user(&ktoken, sizeof(ktoken), utoken, sizeof(*utoken));
7b0f1e69
MD		 751 if (ret)
752 goto error;
d9a337ba
MD		 753 token_len += ktoken.len;
754 switch (ktoken.type) {
755 case LTTNG_KERNEL_ABI_KEY_TOKEN_STRING:
756 {
757 struct lttng_kernel_abi_key_token_string __user *utoken_string;
758 struct lttng_kernel_abi_key_token_string *ktoken_string;
759 char __user *string_ptr;
760 size_t string_len;
761
762 utoken_string = (struct lttng_kernel_abi_key_token_string __user *) utoken;
763 ret = lttng_copy_struct_from_user(&ktoken_string, sizeof(ktoken_string),
764 utoken_string, ktoken.len);
765 if (ret)
766 goto error;
767 string_ptr = (char __user *) ((unsigned long)utoken_string + ktoken.len);
768 string_len = ktoken_string->string_len;
769 key_token->type = LTTNG_KEY_TOKEN_STRING;
770 if (!string_len || string_len > PAGE_SIZE) {
771 ret = -EINVAL;
772 goto error;
773 }
774 key_token->str = kzalloc(string_len, GFP_KERNEL);
775 if (!key_token->str) {
776 ret = -ENOMEM;
777 goto error;
778 }
779 ret = copy_from_user(key_token->str, string_ptr, string_len);
780 if (ret)
781 goto error;
782 if (key_token->str[string_len - 1] != '\0') {
783 ret = -EINVAL;
784 goto error;
785 }
786 token_len += string_len;
787 break;
788 }
789 case LTTNG_KERNEL_ABI_KEY_TOKEN_EVENT_NAME:
790 key_token->type = LTTNG_KEY_TOKEN_EVENT_NAME;
791 break;
792
793 case LTTNG_KERNEL_ABI_KEY_TOKEN_PROVIDER_NAME:
794 lttng_fallthrough;
795 default:
7b0f1e69
MD		 796 ret = -EINVAL;
797 goto error;
798 }
d9a337ba 799 utoken = (struct lttng_kernel_abi_key_token __user *)((unsigned long)utoken + token_len);
7b0f1e69 800 }
7b0f1e69 801
d9a337ba
MD		 802 break;
803 }
804 case LTTNG_KERNEL_ABI_KEY_TYPE_INTEGER:
805 default:
806 ret = -EINVAL;
807 goto error;
7b0f1e69
MD		 808 }
809 *_counter_key = counter_key;
810 return 0;
811
812error:
813 destroy_counter_key(counter_key);
814 return ret;
815}
816
817int create_counter_key_from_kernel(struct lttng_kernel_counter_key **_new_key,
818 const struct lttng_kernel_counter_key *src_key)
819{
820 struct lttng_kernel_counter_key *new_key;
821 int i, ret = 0;
822
823 new_key = kzalloc(sizeof(*new_key), GFP_KERNEL);
824 if (!new_key)
825 return -ENOMEM;
826 new_key->nr_dimensions = src_key->nr_dimensions;
827 for (i = 0; i < src_key->nr_dimensions; i++) {
828 struct lttng_kernel_counter_key_dimension *new_dimension = &new_key->dimension_array[i];
829 const struct lttng_kernel_counter_key_dimension *src_dimension = &src_key->dimension_array[i];
830 uint32_t nr_tokens = src_dimension->nr_key_tokens;
831 int j;
832
833 new_dimension->nr_key_tokens = nr_tokens;
834 new_dimension->token_array = kzalloc(nr_tokens * sizeof(*new_dimension->token_array), GFP_KERNEL);
835 if (!new_dimension->token_array) {
836 ret = -ENOMEM;
837 goto error;
838 }
839 for (j = 0; j < nr_tokens; j++) {
840 struct lttng_key_token *new_key_token = &new_dimension->token_array[j];
841 struct lttng_key_token *src_key_token = &src_dimension->token_array[j];
842
843 switch (src_key_token->type) {
844 case LTTNG_KEY_TOKEN_STRING:
845 new_key_token->type = LTTNG_KEY_TOKEN_STRING;
846 new_key_token->str = kstrdup(src_key_token->str, GFP_KERNEL);
847 if (!new_key_token->str) {
848 ret = -ENOMEM;
849 goto error;
850 }
851 break;
852 case LTTNG_KEY_TOKEN_EVENT_NAME:
853 new_key_token->type = LTTNG_KEY_TOKEN_EVENT_NAME;
854 break;
855
856 default:
857 ret = -EINVAL;
858 goto error;
859 }
860 }
861 }
862 *_new_key = new_key;
863 return 0;
864
865error:
866 destroy_counter_key(new_key);
867 return ret;
868}
869
870void destroy_counter_key(struct lttng_kernel_counter_key *counter_key)
871{
872 int i;
873
874 if (!counter_key)
875 return;
876 for (i = 0; i < counter_key->nr_dimensions; i++) {
877 struct lttng_kernel_counter_key_dimension *dimension = &counter_key->dimension_array[i];
878 uint32_t nr_tokens = dimension->nr_key_tokens;
879 int j;
880
881 for (j = 0; j < nr_tokens; j++) {
882 struct lttng_key_token *key_token = &dimension->token_array[j];
883
884 switch (key_token->type) {
885 case LTTNG_KEY_TOKEN_STRING:
886 kfree(key_token->str);
887 break;
888
889 case LTTNG_KEY_TOKEN_EVENT_NAME:
890 lttng_fallthrough;
891 case LTTNG_KEY_TOKEN_UNKNOWN:
892 break;
893
894 default:
895 WARN_ON_ONCE(1);
896 }
897 }
898 kfree(dimension->token_array);
899 }
900 kfree(counter_key);
901}
902
99f52fcc 903static
9005f768
MD		 904long lttng_counter_ioctl_abi_old_counter_read(struct lttng_kernel_channel_counter *counter,
905 unsigned int cmd, unsigned long arg)
99f52fcc 906{
9005f768
MD		 907 size_t indexes[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX] = {};
908 struct lttng_kernel_abi_old_counter_read local_counter_read;
909 struct lttng_kernel_abi_old_counter_read __user *ucounter_read =
910 (struct lttng_kernel_abi_old_counter_read __user *) arg;
911 bool overflow, underflow;
912 int64_t value;
913 int32_t cpu;
914 int ret, i;
915
916 if (copy_from_user(&local_counter_read, ucounter_read,
917 sizeof(local_counter_read)))
918 return -EFAULT;
919 if (validate_zeroed_padding(local_counter_read.padding,
920 sizeof(local_counter_read.padding)))
921 return -EINVAL;
922 if (local_counter_read.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
923 return -EINVAL;
924 /* Cast all indexes into size_t. */
925 for (i = 0; i < local_counter_read.index.number_dimensions; i++)
926 indexes[i] = local_counter_read.index.dimension_indexes[i];
927 cpu = local_counter_read.cpu;
99f52fcc 928
9005f768
MD		 929 ret = lttng_kernel_counter_read(counter, indexes, cpu, &value, &overflow, &underflow);
930 if (ret)
931 return ret;
932 local_counter_read.value.value = value;
933 local_counter_read.value.overflow = overflow;
934 local_counter_read.value.underflow = underflow;
99f52fcc 935
9005f768
MD		 936 if (copy_to_user(&ucounter_read->value, &local_counter_read.value,
937 sizeof(local_counter_read.value)))
938 return -EFAULT;
99f52fcc 939
9005f768
MD		 940 return 0;
941}
99f52fcc 942
9005f768
MD		 943static
944long lttng_counter_ioctl_abi_old_counter_aggregate(struct lttng_kernel_channel_counter *counter,
945 unsigned int cmd, unsigned long arg)
946{
947 size_t indexes[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX] = {};
948 struct lttng_kernel_abi_old_counter_aggregate local_counter_aggregate;
949 struct lttng_kernel_abi_old_counter_aggregate __user *ucounter_aggregate =
950 (struct lttng_kernel_abi_old_counter_aggregate __user *) arg;
951 bool overflow, underflow;
952 int64_t value;
953 int ret, i;
954
955 if (copy_from_user(&local_counter_aggregate, ucounter_aggregate,
956 sizeof(local_counter_aggregate)))
957 return -EFAULT;
958 if (validate_zeroed_padding(local_counter_aggregate.padding,
959 sizeof(local_counter_aggregate.padding)))
960 return -EINVAL;
961 if (local_counter_aggregate.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
962 return -EINVAL;
963 /* Cast all indexes into size_t. */
964 for (i = 0; i < local_counter_aggregate.index.number_dimensions; i++)
965 indexes[i] = local_counter_aggregate.index.dimension_indexes[i];
99f52fcc 966
9005f768
MD		 967 ret = lttng_kernel_counter_aggregate(counter, indexes, &value, &overflow, &underflow);
968 if (ret)
969 return ret;
970 local_counter_aggregate.value.value = value;
971 local_counter_aggregate.value.overflow = overflow;
972 local_counter_aggregate.value.underflow = underflow;
99f52fcc 973
9005f768
MD		 974 if (copy_to_user(&ucounter_aggregate->value, &local_counter_aggregate.value,
975 sizeof(local_counter_aggregate.value)))
976 return -EFAULT;
99f52fcc 977
9005f768
MD		 978 return 0;
979}
99f52fcc 980
9005f768
MD		 981static
982long lttng_counter_ioctl_abi_old_counter_clear(struct lttng_kernel_channel_counter *counter,
983 unsigned int cmd, unsigned long arg)
984{
985 size_t indexes[LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX] = {};
986 struct lttng_kernel_abi_old_counter_clear local_counter_clear;
987 struct lttng_kernel_abi_old_counter_clear __user *ucounter_clear =
988 (struct lttng_kernel_abi_old_counter_clear __user *) arg;
989 int i;
99f52fcc 990
9005f768
MD		 991 if (copy_from_user(&local_counter_clear, ucounter_clear,
992 sizeof(local_counter_clear)))
993 return -EFAULT;
994 if (validate_zeroed_padding(local_counter_clear.padding,
995 sizeof(local_counter_clear.padding)))
996 return -EINVAL;
997 if (local_counter_clear.index.number_dimensions > LTTNG_KERNEL_ABI_OLD_COUNTER_DIMENSION_MAX)
998 return -EINVAL;
999 /* Cast all indexes into size_t. */
1000 for (i = 0; i < local_counter_clear.index.number_dimensions; i++)
1001 indexes[i] = local_counter_clear.index.dimension_indexes[i];
1002 return lttng_kernel_counter_clear(counter, indexes);
1003}
99f52fcc 1004
9005f768
MD		 1005static
1006long lttng_counter_ioctl_abi_counter_read(struct lttng_kernel_channel_counter *counter,
1007 unsigned int cmd, unsigned long arg)
1008{
1009 size_t indexes[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS] = {};
1010 struct lttng_kernel_abi_counter_read kcounter_read = {};
1011 struct lttng_kernel_abi_counter_read __user *ucounter_read =
1012 (struct lttng_kernel_abi_counter_read __user *) arg;
1013 uint32_t len, number_dimensions;
1014 bool overflow, underflow;
1015 int64_t value;
1016 int32_t cpu;
1017 int ret, i;
1018
1019 ret = get_user(len, &ucounter_read->len);
1020 if (ret)
1021 return ret;
1022 if (len > PAGE_SIZE)
1023 return -E2BIG;
1024 if (len < offsetofend(struct lttng_kernel_abi_counter_read, value))
1025 return -EINVAL;
1026 ret = lttng_copy_struct_from_user(&kcounter_read, sizeof(kcounter_read),
1027 ucounter_read, len);
1028 if (ret)
1029 return ret;
1030 number_dimensions = kcounter_read.index.number_dimensions;
1031 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1032 return -EINVAL;
1033 /* Cast all indexes into size_t. */
1034 for (i = 0; i < number_dimensions; i++) {
1035 uint64_t __user *ptr = ((uint64_t __user *)(unsigned long)kcounter_read.index.ptr) + i;
1036 uint64_t index;
a3833790 1037
9005f768 1038 ret = get_user(index, ptr);
a3833790
MD		 1039 if (ret)
1040 return ret;
9005f768
MD		 1041 indexes[i] = index;
1042 }
1043 cpu = kcounter_read.cpu;
1044 ret = lttng_kernel_counter_read(counter, indexes, cpu, &value, &overflow, &underflow);
1045 if (ret)
1046 return ret;
1047 kcounter_read.value.value = value;
1048 kcounter_read.value.flags |= underflow ? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_UNDERFLOW : 0;
1049 kcounter_read.value.flags |= overflow ? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_OVERFLOW : 0;
a3833790 1050
9005f768
MD		 1051 if (copy_to_user(&ucounter_read->value, &kcounter_read.value, sizeof(kcounter_read.value)))
1052 return -EFAULT;
a3833790 1053
9005f768
MD		 1054 return 0;
1055}
a3833790 1056
9005f768
MD		 1057static
1058long lttng_counter_ioctl_abi_counter_aggregate(struct lttng_kernel_channel_counter *counter,
1059 unsigned int cmd, unsigned long arg)
1060{
1061 size_t indexes[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS] = {};
1062 struct lttng_kernel_abi_counter_aggregate kcounter_aggregate = {};
1063 struct lttng_kernel_abi_counter_aggregate __user *ucounter_aggregate =
1064 (struct lttng_kernel_abi_counter_aggregate __user *) arg;
1065 uint32_t len, number_dimensions;
1066 bool overflow, underflow;
1067 int64_t value;
1068 int ret, i;
1069
1070 ret = get_user(len, &ucounter_aggregate->len);
1071 if (ret)
1072 return ret;
1073 if (len > PAGE_SIZE)
1074 return -E2BIG;
1075 if (len < offsetofend(struct lttng_kernel_abi_counter_aggregate, value))
1076 return -EINVAL;
1077 ret = lttng_copy_struct_from_user(&kcounter_aggregate, sizeof(kcounter_aggregate),
1078 ucounter_aggregate, len);
1079 if (ret)
1080 return ret;
1081 number_dimensions = kcounter_aggregate.index.number_dimensions;
1082 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1083 return -EINVAL;
1084 /* Cast all indexes into size_t. */
1085 for (i = 0; i < number_dimensions; i++) {
1086 uint64_t __user *ptr = ((uint64_t __user *)(unsigned long)kcounter_aggregate.index.ptr) + i;
1087 uint64_t index;
a3833790 1088
9005f768 1089 ret = get_user(index, ptr);
a3833790
MD		 1090 if (ret)
1091 return ret;
9005f768
MD		 1092 indexes[i] = index;
1093 }
1094 ret = lttng_kernel_counter_aggregate(counter, indexes, &value, &overflow, &underflow);
1095 if (ret)
1096 return ret;
1097 kcounter_aggregate.value.value = value;
1098 kcounter_aggregate.value.flags |= underflow ? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_UNDERFLOW : 0;
1099 kcounter_aggregate.value.flags |= overflow ? LTTNG_KERNEL_ABI_COUNTER_VALUE_FLAG_OVERFLOW : 0;
a3833790 1100
9005f768
MD		 1101 if (copy_to_user(&ucounter_aggregate->value, &kcounter_aggregate.value, sizeof(kcounter_aggregate.value)))
1102 return -EFAULT;
a3833790 1103
9005f768
MD		 1104 return 0;
1105}
a3833790 1106
9005f768
MD		 1107static
1108long lttng_counter_ioctl_abi_counter_clear(struct lttng_kernel_channel_counter *counter,
1109 unsigned int cmd, unsigned long arg)
1110{
1111 size_t indexes[LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS] = {};
1112 struct lttng_kernel_abi_counter_clear kcounter_clear = {};
1113 struct lttng_kernel_abi_counter_clear __user *ucounter_clear =
1114 (struct lttng_kernel_abi_counter_clear __user *) arg;
1115 uint32_t len, number_dimensions;
1116 int ret, i;
1117
1118 ret = get_user(len, &ucounter_clear->len);
1119 if (ret)
1120 return ret;
1121 if (len > PAGE_SIZE)
1122 return -E2BIG;
1123 if (len < offsetofend(struct lttng_kernel_abi_counter_clear, index))
1124 return -EINVAL;
1125 ret = lttng_copy_struct_from_user(&kcounter_clear, sizeof(kcounter_clear),
1126 ucounter_clear, len);
1127 if (ret)
1128 return ret;
1129 number_dimensions = kcounter_clear.index.number_dimensions;
1130 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1131 return -EINVAL;
1132 /* Cast all indexes into size_t. */
1133 for (i = 0; i < number_dimensions; i++) {
1134 uint64_t __user *ptr = ((uint64_t __user *)(unsigned long)kcounter_clear.index.ptr) + i;
1135 uint64_t index;
a3833790 1136
9005f768 1137 ret = get_user(index, ptr);
a3833790
MD		 1138 if (ret)
1139 return ret;
9005f768
MD		 1140 indexes[i] = index;
1141 }
1142 return lttng_kernel_counter_clear(counter, indexes);
1143}
a3833790 1144
9005f768
MD		 1145static
1146long lttng_counter_ioctl_abi_counter_event(struct file *file,
1147 struct lttng_kernel_channel_counter *counter,
1148 unsigned int cmd, unsigned long arg)
1149{
1150 struct lttng_kernel_abi_counter_event __user *ucounter_event =
1151 (struct lttng_kernel_abi_counter_event __user *) arg;
1152 struct lttng_kernel_abi_counter_event kcounter_event = {};
1153 struct lttng_kernel_counter_event *counter_event;
1154 uint32_t len;
1155 int ret;
1156
1157 ret = get_user(len, &ucounter_event->len);
1158 if (ret)
1159 return ret;
1160 if (len > PAGE_SIZE)
1161 return -E2BIG;
d9a337ba 1162 if (len < offsetofend(struct lttng_kernel_abi_counter_event, number_key_dimensions))
9005f768
MD		 1163 return -EINVAL;
1164 counter_event = kzalloc(sizeof(*counter_event), GFP_KERNEL);
d9a337ba 1165 if (!counter_event)
9005f768 1166 return -ENOMEM;
9005f768
MD		 1167 ret = lttng_copy_struct_from_user(&kcounter_event, sizeof(kcounter_event),
1168 ucounter_event, len);
1169 if (ret)
1170 goto end_counter_event;
1171 memcpy(&counter_event->event_param, &kcounter_event.event, sizeof(counter_event->event_param));
1172 ret = copy_user_event_param_ext(&counter_event->event_param_ext, &kcounter_event.event);
1173 if (ret)
1174 goto end_counter_event;
d9a337ba
MD		 1175 switch (kcounter_event.action) {
1176 case LTTNG_KERNEL_ABI_COUNTER_ACTION_INCREMENT:
1177 /* No specific data for this action. */
1178 break;
1179 default:
1180 ret = -EINVAL;
1181 goto end_counter_event;
1182 }
1183 ret = create_counter_key_from_abi_dimensions(&counter_event->counter_key,
1184 kcounter_event.number_key_dimensions,
1185 (void __user *) arg + len);
9005f768
MD		 1186 if (ret)
1187 goto end_counter_event;
1188 ret = lttng_abi_create_event_counter_enabler(file, counter_event);
1189 destroy_counter_key(counter_event->counter_key);
1190end_counter_event:
1191 kfree(counter_event);
1192 return ret;
1193}
1194
1195static
1196long lttng_counter_ioctl_abi_counter_map_descriptor(struct lttng_kernel_channel_counter *counter,
1197 unsigned int cmd, unsigned long arg)
1198{
1199 struct lttng_kernel_abi_counter_map_descriptor __user *udescriptor =
1200 (struct lttng_kernel_abi_counter_map_descriptor __user *) arg;
9005f768
MD		 1201 struct lttng_kernel_abi_counter_map_descriptor kdescriptor = {};
1202 struct lttng_counter_map_descriptor *descriptor;
1203 char key[LTTNG_KERNEL_COUNTER_KEY_LEN] = {};
d9a337ba 1204 uint64_t array_indexes[1];
9005f768
MD		 1205 size_t key_strlen;
1206 uint32_t len;
1207 int ret;
1208
1209 ret = get_user(len, &udescriptor->len);
1210 if (ret)
1211 return ret;
1212 if (len > PAGE_SIZE)
1213 return -E2BIG;
d9a337ba 1214 if (len < offsetofend(struct lttng_kernel_abi_counter_map_descriptor, array_indexes_len))
9005f768
MD		 1215 return -EINVAL;
1216 ret = lttng_copy_struct_from_user(&kdescriptor, sizeof(kdescriptor), udescriptor, len);
1217 if (ret)
1218 return ret;
9005f768
MD		 1219 mutex_lock(&counter->priv->map.lock);
1220 if (kdescriptor.descriptor_index >= counter->priv->map.nr_descriptors) {
1221 ret = -EOVERFLOW;
1222 goto map_descriptor_error_unlock;
1223 }
d9a337ba
MD		 1224 if (kdescriptor.array_indexes_len < 1) {
1225 ret = -EINVAL;
1226 goto map_descriptor_error_unlock;
1227 }
1228 kdescriptor.array_indexes_len = 1;
9005f768 1229 descriptor = &counter->priv->map.descriptors[kdescriptor.descriptor_index];
d9a337ba 1230 kdescriptor.dimension = 0;
9005f768 1231 kdescriptor.user_token = descriptor->user_token;
9005f768 1232 memcpy(&key, descriptor->key, LTTNG_KERNEL_COUNTER_KEY_LEN);
d9a337ba 1233 array_indexes[0] = descriptor->array_index;
9005f768
MD		 1234 mutex_unlock(&counter->priv->map.lock);
1235
1236 key_strlen = strlen(key) + 1;
d9a337ba
MD		 1237 if (kdescriptor.key_string_len < key_strlen)
1238 return -ENOSPC;
9005f768 1239 kdescriptor.key_string_len = key_strlen;
d9a337ba
MD		 1240 if (copy_to_user((char __user *)(unsigned long)kdescriptor.key_string, key, key_strlen))
1241 return -EFAULT;
1242 if (copy_to_user((uint64_t __user *)(unsigned long)kdescriptor.array_indexes, array_indexes, sizeof(uint64_t)))
1243 return -EFAULT;
9005f768
MD		 1244 if (copy_to_user(udescriptor, &kdescriptor, min(sizeof(kdescriptor), (size_t)len)))
1245 return -EFAULT;
9005f768
MD		 1246 return 0;
1247
1248map_descriptor_error_unlock:
1249 mutex_unlock(&counter->priv->map.lock);
1250 return ret;
1251}
1252
1253static
1254long lttng_counter_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1255{
1256 struct lttng_kernel_channel_counter *counter = file->private_data;
1257
1258 switch (cmd) {
1259 case LTTNG_KERNEL_ABI_OLD_COUNTER_READ:
1260 return lttng_counter_ioctl_abi_old_counter_read(counter, cmd, arg);
1261 case LTTNG_KERNEL_ABI_OLD_COUNTER_AGGREGATE:
1262 return lttng_counter_ioctl_abi_old_counter_aggregate(counter, cmd, arg);
1263 case LTTNG_KERNEL_ABI_OLD_COUNTER_CLEAR:
1264 return lttng_counter_ioctl_abi_old_counter_clear(counter, cmd, arg);
1265 case LTTNG_KERNEL_ABI_COUNTER_READ:
1266 return lttng_counter_ioctl_abi_counter_read(counter, cmd, arg);
1267 case LTTNG_KERNEL_ABI_COUNTER_AGGREGATE:
1268 return lttng_counter_ioctl_abi_counter_aggregate(counter, cmd, arg);
1269 case LTTNG_KERNEL_ABI_COUNTER_CLEAR:
1270 return lttng_counter_ioctl_abi_counter_clear(counter, cmd, arg);
1271 case LTTNG_KERNEL_ABI_COUNTER_EVENT:
1272 return lttng_counter_ioctl_abi_counter_event(file, counter, cmd, arg);
6ef1e2f5
MD		 1273 case LTTNG_KERNEL_ABI_ENABLE:
1274 return lttng_channel_enable(&counter->parent);
1275 case LTTNG_KERNEL_ABI_DISABLE:
1276 return lttng_channel_disable(&counter->parent);
4a6c2fbf
MD		 1277 case LTTNG_KERNEL_ABI_SYSCALL_MASK:
1278 return lttng_syscall_table_get_active_mask(&counter->priv->parent.syscall_table,
1279 (struct lttng_kernel_abi_syscall_mask __user *) arg);
1280 case LTTNG_KERNEL_ABI_COUNTER_MAP_NR_DESCRIPTORS:
1281 {
1282 uint64_t __user *user_nr_descriptors = (uint64_t __user *) arg;
1283 uint64_t nr_descriptors;
1284
1285 mutex_lock(&counter->priv->map.lock);
1286 nr_descriptors = counter->priv->map.nr_descriptors;
1287 mutex_unlock(&counter->priv->map.lock);
1288 return put_user(nr_descriptors, user_nr_descriptors);
1289 }
1290 case LTTNG_KERNEL_ABI_COUNTER_MAP_DESCRIPTOR:
9005f768 1291 return lttng_counter_ioctl_abi_counter_map_descriptor(counter, cmd, arg);
99f52fcc 1292 default:
99f52fcc
FD		 1293 return -ENOSYS;
1294 }
1295}
1296
1297static const struct file_operations lttng_counter_fops = {
1298 .owner = THIS_MODULE,
1299 .release = lttng_counter_release,
1300 .unlocked_ioctl = lttng_counter_ioctl,
1301#ifdef CONFIG_COMPAT
1302 .compat_ioctl = lttng_counter_ioctl,
1303#endif
1304};
1305
1306
d1f652f8 1307static
606828e4 1308enum tracker_type get_tracker_type(struct lttng_kernel_abi_tracker_args *tracker)
d1f652f8
MD		 1309{
1310 switch (tracker->type) {
606828e4 1311 case LTTNG_KERNEL_ABI_TRACKER_PID:
d1f652f8 1312 return TRACKER_PID;
606828e4 1313 case LTTNG_KERNEL_ABI_TRACKER_VPID:
d1f652f8 1314 return TRACKER_VPID;
606828e4 1315 case LTTNG_KERNEL_ABI_TRACKER_UID:
d1f652f8 1316 return TRACKER_UID;
606828e4 1317 case LTTNG_KERNEL_ABI_TRACKER_VUID:
d1f652f8 1318 return TRACKER_VUID;
606828e4 1319 case LTTNG_KERNEL_ABI_TRACKER_GID:
d1f652f8 1320 return TRACKER_GID;
606828e4 1321 case LTTNG_KERNEL_ABI_TRACKER_VGID:
d1f652f8
MD		 1322 return TRACKER_VGID;
1323 default:
1324 return TRACKER_UNKNOWN;
1325 }
1326}
1327
81ab5b77
MD		 1328static
1329int lttng_abi_copy_user_old_counter_conf(struct lttng_kernel_counter_conf *counter_conf,
1330 struct lttng_kernel_abi_old_counter_conf __user *old_ucounter_conf)
1331{
1332 struct lttng_kernel_abi_old_counter_conf old_kcounter_conf;
1333 struct lttng_kernel_counter_dimension *dimension;
1334 int ret;
1335
434e86ee 1336 memset(counter_conf, 0, sizeof(*counter_conf));
81ab5b77
MD		 1337 ret = copy_from_user(&old_kcounter_conf, old_ucounter_conf,
1338 sizeof(old_kcounter_conf));
1339 if (ret)
1340 return ret;
1341 if (!old_kcounter_conf.number_dimensions ||
1342 old_kcounter_conf.number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1343 return -EINVAL;
1344 switch (old_kcounter_conf.arithmetic) {
1345 case LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR:
1346 counter_conf->arithmetic = LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR;
1347 break;
1348 default:
1349 return -EINVAL;
1350 }
1351 switch (old_kcounter_conf.bitness) {
1352 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32:
1353 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_32;
1354 break;
1355 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64:
1356 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_64;
1357 break;
1358 default:
1359 return -EINVAL;
1360 }
1361 counter_conf->global_sum_step = old_kcounter_conf.global_sum_step;
1362 counter_conf->flags |= old_kcounter_conf.coalesce_hits ?
1363 LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS : 0;
1364 dimension = &counter_conf->dimension_array[0];
1365 dimension->flags |= old_kcounter_conf.dimensions[0].has_underflow ?
1366 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_UNDERFLOW : 0;
1367 dimension->flags |= old_kcounter_conf.dimensions[0].has_overflow ?
1368 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_OVERFLOW : 0;
1369 dimension->size = old_kcounter_conf.dimensions[0].size;
1370 dimension->underflow_index = old_kcounter_conf.dimensions[0].underflow_index;
1371 dimension->overflow_index = old_kcounter_conf.dimensions[0].overflow_index;
1372 return 0;
1373}
1374
1375static
1376int lttng_abi_copy_user_counter_conf(struct lttng_kernel_counter_conf *counter_conf,
1377 struct lttng_kernel_abi_counter_conf __user *ucounter_conf)
1378{
1379 uint32_t len, number_dimensions;
1380 struct lttng_kernel_abi_counter_conf kcounter_conf = {};
1381 struct lttng_kernel_counter_dimension *dimension;
1382 struct lttng_kernel_abi_counter_dimension kdimension = {};
1383 struct lttng_kernel_abi_counter_dimension __user *udimension;
1384 int ret;
1385
434e86ee 1386 memset(counter_conf, 0, sizeof(*counter_conf));
81ab5b77
MD		 1387 ret = get_user(len, &ucounter_conf->len);
1388 if (ret)
1389 return ret;
1390 if (len < offsetofend(struct lttng_kernel_abi_counter_conf, dimension_array))
1391 return -EINVAL;
1392 if (len > PAGE_SIZE)
1393 return -EINVAL;
1394
1395 ret = lttng_copy_struct_from_user(&kcounter_conf, sizeof(kcounter_conf), ucounter_conf, len);
1396 if (ret)
1397 return ret;
1398
1399 /* Validate flags and enumerations */
1400 switch (kcounter_conf.arithmetic) {
1401 case LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR:
1402 counter_conf->arithmetic = LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR;
1403 break;
1404 default:
1405 return -EINVAL;
1406 }
1407 switch (kcounter_conf.bitness) {
1408 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_32:
1409 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_32;
1410 break;
1411 case LTTNG_KERNEL_ABI_COUNTER_BITNESS_64:
1412 counter_conf->bitness = LTTNG_KERNEL_COUNTER_BITNESS_64;
1413 break;
1414 default:
1415 return -EINVAL;
1416 }
1417 if (kcounter_conf.flags & ~LTTNG_KERNEL_ABI_COUNTER_CONF_FLAG_COALESCE_HITS)
1418 return -EINVAL;
1419 counter_conf->global_sum_step = kcounter_conf.global_sum_step;
1420 counter_conf->flags |= (kcounter_conf.flags & LTTNG_KERNEL_ABI_COUNTER_CONF_FLAG_COALESCE_HITS) ?
1421 LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS : 0;
1422
1423 number_dimensions = kcounter_conf.dimension_array.number_dimensions;
1424 if (!number_dimensions || number_dimensions > LTTNG_KERNEL_COUNTER_MAX_DIMENSIONS)
1425 return -EINVAL;
1426 dimension = &counter_conf->dimension_array[0];
1427 len = kcounter_conf.dimension_array.elem_len;
1428 if (len > PAGE_SIZE)
1429 return -E2BIG;
1430 if (len < offsetofend(struct lttng_kernel_abi_counter_dimension, overflow_index))
1431 return -EINVAL;
1432 udimension = (struct lttng_kernel_abi_counter_dimension __user *)(unsigned long)kcounter_conf.dimension_array.ptr;
1433 ret = lttng_copy_struct_from_user(&kdimension, sizeof(kdimension), udimension, len);
1434 if (ret)
1435 return ret;
1436
1437 /* Validate flags */
1438 if (kdimension.flags & ~(LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW |
1439 LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW))
1440 return -EINVAL;
1441
1442 dimension->flags |= (kdimension.flags & LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW) ?
1443 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_UNDERFLOW : 0;
1444 dimension->flags |= (kdimension.flags & LTTNG_KERNEL_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW) ?
1445 LTTNG_KERNEL_COUNTER_DIMENSION_FLAG_OVERFLOW : 0;
1446 dimension->size = kdimension.size;
1447 dimension->underflow_index = kdimension.underflow_index;
1448 dimension->overflow_index = kdimension.overflow_index;
1449 return 0;
1450}
1451
baf20995 1452/**
ad1c05e1 1453 * lttng_session_ioctl - lttng session fd ioctl
baf20995 1454 *
c0e31d2e 1455 * @file: the file
baf20995
MD		 1456 * @cmd: the command
1457 * @arg: command arg
1458 *
1459 * This ioctl implements lttng commands:
606828e4 1460 * LTTNG_KERNEL_ABI_CHANNEL
baf20995 1461 * Returns a LTTng channel file descriptor
606828e4 1462 * LTTNG_KERNEL_ABI_ENABLE
e64957da 1463 * Enables tracing for a session (weak enable)
606828e4 1464 * LTTNG_KERNEL_ABI_DISABLE
e64957da 1465 * Disables tracing for a session (strong disable)
606828e4 1466 * LTTNG_KERNEL_ABI_METADATA
8070f5c0 1467 * Returns a LTTng metadata file descriptor
606828e4 1468 * LTTNG_KERNEL_ABI_SESSION_TRACK_PID
d1f652f8 1469 * Add PID to session PID tracker
606828e4 1470 * LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID
d1f652f8 1471 * Remove PID from session PID tracker
606828e4 1472 * LTTNG_KERNEL_ABI_SESSION_TRACK_ID
d1f652f8 1473 * Add ID to tracker
606828e4 1474 * LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID
d1f652f8 1475 * Remove ID from tracker
ad1c05e1
MD		 1476 *
1477 * The returned channel will be deleted when its file descriptor is closed.
1478 */
1479static
c0e31d2e 1480long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
ad1c05e1 1481{
8cdc1a81 1482 struct lttng_kernel_session *session = file->private_data;
606828e4
MD		 1483 struct lttng_kernel_abi_channel chan_param;
1484 struct lttng_kernel_abi_old_channel old_chan_param;
81ab5b77 1485 int ret;
c0e31d2e 1486
8c71721f
MD		 1487 /*
1488 * Handle backward compatibility. OLD commands have wrong
1489 * directions, replace them by the correct direction.
1490 */
1491 switch (cmd) {
1492 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_PID:
1493 cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_PID;
1494 break;
1495 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_PID:
1496 cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID;
1497 break;
1498 case LTTNG_KERNEL_ABI_OLD_SESSION_TRACK_ID:
1499 cmd = LTTNG_KERNEL_ABI_SESSION_TRACK_ID;
1500 break;
1501 case LTTNG_KERNEL_ABI_OLD_SESSION_UNTRACK_ID:
1502 cmd = LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID;
1503 break;
1504 case LTTNG_KERNEL_ABI_OLD_SESSION_LIST_TRACKER_IDS:
1505 cmd = LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS;
1506 break;
1507 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_NAME:
1508 cmd = LTTNG_KERNEL_ABI_SESSION_SET_NAME;
1509 break;
1510 case LTTNG_KERNEL_ABI_OLD_SESSION_SET_CREATION_TIME:
1511 cmd = LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME;
1512 break;
1513 default:
1514 /* Nothing to do. */
1515 break;
1516 }
1517
ad1c05e1 1518 switch (cmd) {
606828e4 1519 case LTTNG_KERNEL_ABI_OLD_CHANNEL:
6dccd6c1 1520 {
6dccd6c1 1521 if (copy_from_user(&old_chan_param,
606828e4
MD		 1522 (struct lttng_kernel_abi_old_channel __user *) arg,
1523 sizeof(struct lttng_kernel_abi_old_channel)))
6dccd6c1
JD		 1524 return -EFAULT;
1525 chan_param.overwrite = old_chan_param.overwrite;
1526 chan_param.subbuf_size = old_chan_param.subbuf_size;
1527 chan_param.num_subbuf = old_chan_param.num_subbuf;
1528 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
1529 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
1530 chan_param.output = old_chan_param.output;
1531
1532 return lttng_abi_create_channel(file, &chan_param,
1533 PER_CPU_CHANNEL);
1534 }
606828e4 1535 case LTTNG_KERNEL_ABI_CHANNEL:
6dccd6c1 1536 {
6dccd6c1 1537 if (copy_from_user(&chan_param,
606828e4
MD		 1538 (struct lttng_kernel_abi_channel __user *) arg,
1539 sizeof(struct lttng_kernel_abi_channel)))
6dccd6c1
JD		 1540 return -EFAULT;
1541 return lttng_abi_create_channel(file, &chan_param,
5dbbdb43 1542 PER_CPU_CHANNEL);
6dccd6c1 1543 }
606828e4
MD		 1544 case LTTNG_KERNEL_ABI_OLD_SESSION_START:
1545 case LTTNG_KERNEL_ABI_OLD_ENABLE:
1546 case LTTNG_KERNEL_ABI_SESSION_START:
1547 case LTTNG_KERNEL_ABI_ENABLE:
a90917c3 1548 return lttng_session_enable(session);
606828e4
MD		 1549 case LTTNG_KERNEL_ABI_OLD_SESSION_STOP:
1550 case LTTNG_KERNEL_ABI_OLD_DISABLE:
1551 case LTTNG_KERNEL_ABI_SESSION_STOP:
1552 case LTTNG_KERNEL_ABI_DISABLE:
a90917c3 1553 return lttng_session_disable(session);
606828e4 1554 case LTTNG_KERNEL_ABI_OLD_METADATA:
6dccd6c1 1555 {
6dccd6c1 1556 if (copy_from_user(&old_chan_param,
606828e4
MD		 1557 (struct lttng_kernel_abi_old_channel __user *) arg,
1558 sizeof(struct lttng_kernel_abi_old_channel)))
6dccd6c1
JD		 1559 return -EFAULT;
1560 chan_param.overwrite = old_chan_param.overwrite;
1561 chan_param.subbuf_size = old_chan_param.subbuf_size;
1562 chan_param.num_subbuf = old_chan_param.num_subbuf;
1563 chan_param.switch_timer_interval = old_chan_param.switch_timer_interval;
1564 chan_param.read_timer_interval = old_chan_param.read_timer_interval;
1565 chan_param.output = old_chan_param.output;
1566
1567 return lttng_abi_create_channel(file, &chan_param,
1568 METADATA_CHANNEL);
1569 }
606828e4 1570 case LTTNG_KERNEL_ABI_METADATA:
6dccd6c1 1571 {
6dccd6c1 1572 if (copy_from_user(&chan_param,
606828e4
MD		 1573 (struct lttng_kernel_abi_channel __user *) arg,
1574 sizeof(struct lttng_kernel_abi_channel)))
6dccd6c1
JD		 1575 return -EFAULT;
1576 return lttng_abi_create_channel(file, &chan_param,
5dbbdb43 1577 METADATA_CHANNEL);
6dccd6c1 1578 }
606828e4 1579 case LTTNG_KERNEL_ABI_SESSION_TRACK_PID:
d1f652f8 1580 return lttng_session_track_id(session, TRACKER_PID, (int) arg);
606828e4 1581 case LTTNG_KERNEL_ABI_SESSION_UNTRACK_PID:
d1f652f8 1582 return lttng_session_untrack_id(session, TRACKER_PID, (int) arg);
606828e4 1583 case LTTNG_KERNEL_ABI_SESSION_TRACK_ID:
d1f652f8 1584 {
606828e4 1585 struct lttng_kernel_abi_tracker_args tracker;
d1f652f8
MD		 1586 enum tracker_type tracker_type;
1587
1588 if (copy_from_user(&tracker,
606828e4
MD		 1589 (struct lttng_kernel_abi_tracker_args __user *) arg,
1590 sizeof(struct lttng_kernel_abi_tracker_args)))
d1f652f8
MD		 1591 return -EFAULT;
1592 tracker_type = get_tracker_type(&tracker);
1593 if (tracker_type == TRACKER_UNKNOWN)
1594 return -EINVAL;
1595 return lttng_session_track_id(session, tracker_type, tracker.id);
1596 }
606828e4 1597 case LTTNG_KERNEL_ABI_SESSION_UNTRACK_ID:
d1f652f8 1598 {
606828e4 1599 struct lttng_kernel_abi_tracker_args tracker;
d1f652f8
MD		 1600 enum tracker_type tracker_type;
1601
1602 if (copy_from_user(&tracker,
606828e4
MD		 1603 (struct lttng_kernel_abi_tracker_args __user *) arg,
1604 sizeof(struct lttng_kernel_abi_tracker_args)))
d1f652f8
MD		 1605 return -EFAULT;
1606 tracker_type = get_tracker_type(&tracker);
1607 if (tracker_type == TRACKER_UNKNOWN)
1608 return -EINVAL;
1609 return lttng_session_untrack_id(session, tracker_type,
1610 tracker.id);
1611 }
606828e4 1612 case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_PIDS:
d1f652f8 1613 return lttng_session_list_tracker_ids(session, TRACKER_PID);
606828e4 1614 case LTTNG_KERNEL_ABI_SESSION_LIST_TRACKER_IDS:
d1f652f8 1615 {
606828e4 1616 struct lttng_kernel_abi_tracker_args tracker;
d1f652f8
MD		 1617 enum tracker_type tracker_type;
1618
1619 if (copy_from_user(&tracker,
606828e4
MD		 1620 (struct lttng_kernel_abi_tracker_args __user *) arg,
1621 sizeof(struct lttng_kernel_abi_tracker_args)))
d1f652f8
MD		 1622 return -EFAULT;
1623 tracker_type = get_tracker_type(&tracker);
1624 if (tracker_type == TRACKER_UNKNOWN)
1625 return -EINVAL;
1626 return lttng_session_list_tracker_ids(session, tracker_type);
1627 }
606828e4 1628 case LTTNG_KERNEL_ABI_SESSION_METADATA_REGEN:
9616f0bf 1629 return lttng_session_metadata_regenerate(session);
606828e4 1630 case LTTNG_KERNEL_ABI_SESSION_STATEDUMP:
601252cf 1631 return lttng_session_statedump(session);
606828e4 1632 case LTTNG_KERNEL_ABI_SESSION_SET_NAME:
7f859fbf 1633 {
606828e4 1634 struct lttng_kernel_abi_session_name name;
7f859fbf
JR		 1635
1636 if (copy_from_user(&name,
606828e4
MD		 1637 (struct lttng_kernel_abi_session_name __user *) arg,
1638 sizeof(struct lttng_kernel_abi_session_name)))
7f859fbf
JR		 1639 return -EFAULT;
1640 return lttng_abi_session_set_name(session, &name);
1641 }
606828e4 1642 case LTTNG_KERNEL_ABI_SESSION_SET_CREATION_TIME:
1c88f269 1643 {
606828e4 1644 struct lttng_kernel_abi_session_creation_time time;
1c88f269
JR		 1645
1646 if (copy_from_user(&time,
606828e4
MD		 1647 (struct lttng_kernel_abi_session_creation_time __user *) arg,
1648 sizeof(struct lttng_kernel_abi_session_creation_time)))
1c88f269
JR		 1649 return -EFAULT;
1650 return lttng_abi_session_set_creation_time(session, &time);
1651 }
81ab5b77 1652 case LTTNG_KERNEL_ABI_COUNTER:
2ff86ce2 1653 {
81ab5b77 1654 struct lttng_kernel_counter_conf counter_conf;
2ff86ce2 1655
81ab5b77
MD		 1656 ret = lttng_abi_copy_user_counter_conf(&counter_conf,
1657 (struct lttng_kernel_abi_counter_conf __user *) arg);
1658 if (ret)
1659 return ret;
2ff86ce2
MD		 1660 return lttng_abi_session_create_counter(session, &counter_conf);
1661 }
ad1c05e1
MD		 1662 default:
1663 return -ENOIOCTLCMD;
1664 }
1665}
1666
03037b98
MD		 1667/*
1668 * Called when the last file reference is dropped.
1669 *
1670 * Big fat note: channels and events are invariant for the whole session after
1671 * their creation. So this session destruction also destroys all channel and
1672 * event structures specific to this session (they are not destroyed when their
1673 * individual file is released).
1674 */
ad1c05e1 1675static
03037b98 1676int lttng_session_release(struct inode *inode, struct file *file)
ad1c05e1 1677{
8cdc1a81 1678 struct lttng_kernel_session *session = file->private_data;
c269fff4
MD		 1679
1680 if (session)
a90917c3 1681 lttng_session_destroy(session);
11b5a3c2 1682 return 0;
ad1c05e1 1683}
ad1c05e1
MD		 1684
1685static const struct file_operations lttng_session_fops = {
a33c9927 1686 .owner = THIS_MODULE,
03037b98 1687 .release = lttng_session_release,
ad1c05e1
MD		 1688 .unlocked_ioctl = lttng_session_ioctl,
1689#ifdef CONFIG_COMPAT
03037b98 1690 .compat_ioctl = lttng_session_ioctl,
ad1c05e1 1691#endif
11b5a3c2 1692};
ad1c05e1 1693
db2511b4
MD		 1694/*
1695 * When encountering empty buffer, flush current sub-buffer if non-empty
1696 * and retry (if new data available to read after flush).
1697 */
1698static
1699ssize_t lttng_event_notifier_group_notif_read(struct file *filp, char __user *user_buf,
1700 size_t count, loff_t *ppos)
1701{
1702 struct lttng_event_notifier_group *event_notifier_group = filp->private_data;
860c213b 1703 struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan;
e20c0fec 1704 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
db2511b4
MD		 1705 ssize_t read_count = 0, len;
1706 size_t read_offset;
1707
1708 might_sleep();
1709 if (!lttng_access_ok(VERIFY_WRITE, user_buf, count))
1710 return -EFAULT;
1711
1712 /* Finish copy of previous record */
1713 if (*ppos != 0) {
08c43e0d 1714 if (count != 0) {
db2511b4
MD		 1715 len = chan->iter.len_left;
1716 read_offset = *ppos;
1717 goto skip_get_next;
1718 }
1719 }
1720
1721 while (read_count < count) {
1722 size_t copy_len, space_left;
1723
1724 len = lib_ring_buffer_get_next_record(chan, buf);
1725len_test:
1726 if (len < 0) {
1727 /*
1728 * Check if buffer is finalized (end of file).
1729 */
1730 if (len == -ENODATA) {
1731 /* A 0 read_count will tell about end of file */
1732 goto nodata;
1733 }
1734 if (filp->f_flags & O_NONBLOCK) {
1735 if (!read_count)
1736 read_count = -EAGAIN;
1737 goto nodata;
1738 } else {
1739 int error;
1740
1741 /*
1742 * No data available at the moment, return what
1743 * we got.
1744 */
1745 if (read_count)
1746 goto nodata;
1747
1748 /*
1749 * Wait for returned len to be >= 0 or -ENODATA.
1750 */
1751 error = wait_event_interruptible(
1752 event_notifier_group->read_wait,
1753 ((len = lib_ring_buffer_get_next_record(
1754 chan, buf)), len != -EAGAIN));
1755 CHAN_WARN_ON(chan, len == -EBUSY);
1756 if (error) {
1757 read_count = error;
1758 goto nodata;
1759 }
1760 CHAN_WARN_ON(chan, len < 0 && len != -ENODATA);
1761 goto len_test;
1762 }
1763 }
1764 read_offset = buf->iter.read_offset;
1765skip_get_next:
1766 space_left = count - read_count;
1767 if (len <= space_left) {
1768 copy_len = len;
1769 chan->iter.len_left = 0;
1770 *ppos = 0;
1771 } else {
1772 copy_len = space_left;
1773 chan->iter.len_left = len - copy_len;
1774 *ppos = read_offset + copy_len;
1775 }
1776 if (__lib_ring_buffer_copy_to_user(&buf->backend, read_offset,
1777 &user_buf[read_count],
1778 copy_len)) {
1779 /*
1780 * Leave the len_left and ppos values at their current
1781 * state, as we currently have a valid event to read.
1782 */
1783 return -EFAULT;
1784 }
1785 read_count += copy_len;
1786 }
31c02fb7 1787 goto put_record;
db2511b4
MD		 1788
1789nodata:
1790 *ppos = 0;
1791 chan->iter.len_left = 0;
31c02fb7
MD		 1792
1793put_record:
08c43e0d
MD		 1794 if (*ppos == 0)
1795 lib_ring_buffer_put_current_record(buf);
db2511b4
MD		 1796 return read_count;
1797}
1798
1799/*
1800 * If the ring buffer is non empty (even just a partial subbuffer), return that
1801 * there is data available. Perform a ring buffer flush if we encounter a
1802 * non-empty ring buffer which does not have any consumeable subbuffer available.
1803 */
1804static
1805unsigned int lttng_event_notifier_group_notif_poll(struct file *filp,
1806 poll_table *wait)
1807{
1808 unsigned int mask = 0;
1809 struct lttng_event_notifier_group *event_notifier_group = filp->private_data;
860c213b 1810 struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan;
e20c0fec
MD		 1811 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
1812 const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
db2511b4
MD		 1813 int finalized, disabled;
1814 unsigned long consumed, offset;
18f12d55 1815 size_t subbuffer_header_size = config->cb.subbuffer_header_size();
db2511b4
MD		 1816
1817 if (filp->f_mode & FMODE_READ) {
1818 poll_wait_set_exclusive(wait);
1819 poll_wait(filp, &event_notifier_group->read_wait, wait);
1820
1821 finalized = lib_ring_buffer_is_finalized(config, buf);
1822 disabled = lib_ring_buffer_channel_is_disabled(chan);
1823
1824 /*
1825 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
1826 * finalized load before offsets loads.
1827 */
1828 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
1829retry:
1830 if (disabled)
1831 return POLLERR;
1832
1833 offset = lib_ring_buffer_get_offset(config, buf);
1834 consumed = lib_ring_buffer_get_consumed(config, buf);
1835
1836 /*
1837 * If there is no buffer available to consume.
1838 */
1839 if (subbuf_trunc(offset, chan) - subbuf_trunc(consumed, chan) == 0) {
1840 /*
1841 * If there is a non-empty subbuffer, flush and try again.
1842 */
18f12d55 1843 if (subbuf_offset(offset, chan) > subbuffer_header_size) {
db2511b4
MD		 1844 lib_ring_buffer_switch_remote(buf);
1845 goto retry;
1846 }
1847
1848 if (finalized)
1849 return POLLHUP;
1850 else {
1851 /*
1852 * The memory barriers
1853 * __wait_event()/wake_up_interruptible() take
1854 * care of "raw_spin_is_locked" memory ordering.
1855 */
1856 if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
1857 goto retry;
1858 else
1859 return 0;
1860 }
1861 } else {
1862 if (subbuf_trunc(offset, chan) - subbuf_trunc(consumed, chan)
1863 >= chan->backend.buf_size)
1864 return POLLPRI | POLLRDBAND;
1865 else
1866 return POLLIN | POLLRDNORM;
1867 }
1868 }
1869
1870 return mask;
1871}
1872
1873/**
1874 * lttng_event_notifier_group_notif_open - event_notifier ring buffer open file operation
1875 * @inode: opened inode
1876 * @file: opened file
1877 *
1878 * Open implementation. Makes sure only one open instance of a buffer is
1879 * done at a given moment.
1880 */
1881static int lttng_event_notifier_group_notif_open(struct inode *inode, struct file *file)
1882{
1883 struct lttng_event_notifier_group *event_notifier_group = inode->i_private;
e20c0fec 1884 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
db2511b4
MD		 1885
1886 file->private_data = event_notifier_group;
1887 return lib_ring_buffer_open(inode, file, buf);
1888}
1889
1890/**
1891 * lttng_event_notifier_group_notif_release - event_notifier ring buffer release file operation
1892 * @inode: opened inode
1893 * @file: opened file
1894 *
1895 * Release implementation.
1896 */
1897static int lttng_event_notifier_group_notif_release(struct inode *inode, struct file *file)
1898{
1899 struct lttng_event_notifier_group *event_notifier_group = file->private_data;
e20c0fec 1900 struct lttng_kernel_ring_buffer *buf = event_notifier_group->buf;
db2511b4
MD		 1901 int ret;
1902
1903 ret = lib_ring_buffer_release(inode, file, buf);
1904 if (ret)
1905 return ret;
1906 fput(event_notifier_group->file);
1907 return 0;
1908}
1909
21f58fb7
FD		 1910static const struct file_operations lttng_event_notifier_group_notif_fops = {
1911 .owner = THIS_MODULE,
db2511b4
MD		 1912 .open = lttng_event_notifier_group_notif_open,
1913 .release = lttng_event_notifier_group_notif_release,
1914 .read = lttng_event_notifier_group_notif_read,
1915 .poll = lttng_event_notifier_group_notif_poll,
21f58fb7
FD		 1916};
1917
d83004aa
JD		 1918/**
1919 * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
1920 * @filp: the file
1921 * @wait: poll table
1922 *
1923 * Handles the poll operations for the metadata channels.
1924 */
ad1c05e1 1925static
d83004aa
JD		 1926unsigned int lttng_metadata_ring_buffer_poll(struct file *filp,
1927 poll_table *wait)
1928{
1929 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 1930 struct lttng_kernel_ring_buffer *buf = stream->priv;
d83004aa
JD		 1931 int finalized;
1932 unsigned int mask = 0;
1933
1934 if (filp->f_mode & FMODE_READ) {
1935 poll_wait_set_exclusive(wait);
1936 poll_wait(filp, &stream->read_wait, wait);
1937
1938 finalized = stream->finalized;
1939
1940 /*
1941 * lib_ring_buffer_is_finalized() contains a smp_rmb()
1942 * ordering finalized load before offsets loads.
1943 */
1944 WARN_ON(atomic_long_read(&buf->active_readers) != 1);
1945
1946 if (finalized)
1947 mask |= POLLHUP;
1948
92d9f5e6 1949 mutex_lock(&stream->metadata_cache->lock);
d83004aa 1950 if (stream->metadata_cache->metadata_written >
f613e3e6 1951 stream->metadata_out)
d83004aa 1952 mask |= POLLIN;
92d9f5e6 1953 mutex_unlock(&stream->metadata_cache->lock);
d83004aa
JD		 1954 }
1955
1956 return mask;
1957}
1958
f613e3e6
MD		 1959static
1960void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file *filp,
1961 unsigned int cmd, unsigned long arg)
1962{
1963 struct lttng_metadata_stream *stream = filp->private_data;
1964
1965 stream->metadata_out = stream->metadata_in;
1966}
1967
d1344afa
JD		 1968/*
1969 * Reset the counter of how much metadata has been consumed to 0. That way,
1970 * the consumer receives the content of the metadata cache unchanged. This is
1971 * different from the metadata_regenerate where the offset from epoch is
1972 * resampled, here we want the exact same content as the last time the metadata
1973 * was generated. This command is only possible if all the metadata written
1974 * in the cache has been output to the metadata stream to avoid corrupting the
1975 * metadata file.
1976 *
1977 * Return 0 on success, a negative value on error.
1978 */
1979static
1980int lttng_metadata_cache_dump(struct lttng_metadata_stream *stream)
1981{
1982 int ret;
1983 struct lttng_metadata_cache *cache = stream->metadata_cache;
1984
1985 mutex_lock(&cache->lock);
1986 if (stream->metadata_out != cache->metadata_written) {
1987 ret = -EBUSY;
1988 goto end;
1989 }
1990 stream->metadata_out = 0;
1991 stream->metadata_in = 0;
1992 wake_up_interruptible(&stream->read_wait);
1993 ret = 0;
1994
1995end:
1996 mutex_unlock(&cache->lock);
1997 return ret;
1998}
1999
d83004aa
JD		 2000static
2001long lttng_metadata_ring_buffer_ioctl(struct file *filp,
2002 unsigned int cmd, unsigned long arg)
2003{
2004 int ret;
2005 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2006 struct lttng_kernel_ring_buffer *buf = stream->priv;
8b97fd42
MD		 2007 unsigned int rb_cmd;
2008 bool coherent;
2009
606828e4
MD		 2010 if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
2011 rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF;
8b97fd42
MD		 2012 else
2013 rb_cmd = cmd;
d83004aa
JD		 2014
2015 switch (cmd) {
606828e4 2016 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF:
d83004aa 2017 {
35097f36 2018 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2019 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2020 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
35097f36 2021
8b97fd42 2022 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 2023 if (ret > 0) {
2024 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2025 ret = 0;
2026 } else if (ret < 0)
d83004aa
JD		 2027 goto err;
2028 break;
2029 }
606828e4 2030 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF:
f613e3e6
MD		 2031 {
2032 /*
2033 * Random access is not allowed for metadata channel.
2034 */
2035 return -ENOSYS;
2036 }
c190d76e
MJ		 2037 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY:
2038 lttng_fallthrough;
606828e4 2039 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH:
35097f36
JD		 2040 {
2041 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2042 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2043 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
35097f36
JD		 2044
2045 /*
2046 * Before doing the actual ring buffer flush, write up to one
2047 * packet of metadata in the ring buffer.
2048 */
8b97fd42 2049 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 2050 if (ret < 0)
2051 goto err;
2052 break;
2053 }
606828e4 2054 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION:
9616f0bf
JD		 2055 {
2056 struct lttng_metadata_stream *stream = filp->private_data;
2057
2058 return put_u64(stream->version, arg);
2059 }
606828e4 2060 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP:
d1344afa
JD		 2061 {
2062 struct lttng_metadata_stream *stream = filp->private_data;
2063
2064 return lttng_metadata_cache_dump(stream);
2065 }
606828e4 2066 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
8b97fd42
MD		 2067 {
2068 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2069 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2070 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
8b97fd42
MD		 2071
2072 ret = lttng_metadata_output_channel(stream, chan, &coherent);
2073 if (ret > 0) {
2074 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2075 ret = 0;
2076 } else if (ret < 0) {
2077 goto err;
2078 }
2079 break;
2080 }
d83004aa
JD		 2081 default:
2082 break;
2083 }
f613e3e6
MD		 2084 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2085
d83004aa 2086 /* Performing lib ring buffer ioctl after our own. */
8b97fd42 2087 ret = lib_ring_buffer_ioctl(filp, rb_cmd, arg, buf);
f613e3e6
MD		 2088 if (ret < 0)
2089 goto err;
d83004aa 2090
f613e3e6 2091 switch (cmd) {
606828e4 2092 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF:
f613e3e6
MD		 2093 {
2094 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
2095 cmd, arg);
2096 break;
2097 }
606828e4 2098 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
8b97fd42
MD		 2099 {
2100 return put_u32(coherent, arg);
2101 }
f613e3e6
MD		 2102 default:
2103 break;
2104 }
d83004aa
JD		 2105err:
2106 return ret;
2107}
2108
aeb9064d 2109#ifdef CONFIG_COMPAT
d83004aa
JD		 2110static
2111long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp,
2112 unsigned int cmd, unsigned long arg)
2113{
2114 int ret;
2115 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2116 struct lttng_kernel_ring_buffer *buf = stream->priv;
8b97fd42
MD		 2117 unsigned int rb_cmd;
2118 bool coherent;
2119
606828e4
MD		 2120 if (cmd == LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK)
2121 rb_cmd = LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF;
8b97fd42
MD		 2122 else
2123 rb_cmd = cmd;
d83004aa
JD		 2124
2125 switch (cmd) {
606828e4 2126 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF:
d83004aa 2127 {
35097f36 2128 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2129 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2130 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
35097f36 2131
8b97fd42 2132 ret = lttng_metadata_output_channel(stream, chan, NULL);
35097f36
JD		 2133 if (ret > 0) {
2134 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2135 ret = 0;
2136 } else if (ret < 0)
d83004aa
JD		 2137 goto err;
2138 break;
2139 }
606828e4 2140 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SUBBUF:
f613e3e6
MD		 2141 {
2142 /*
2143 * Random access is not allowed for metadata channel.
2144 */
2145 return -ENOSYS;
2146 }
c190d76e
MJ		 2147 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH_EMPTY:
2148 lttng_fallthrough;
606828e4 2149 case LTTNG_KERNEL_ABI_RING_BUFFER_FLUSH:
96c55c2f
MD		 2150 {
2151 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2152 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2153 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
96c55c2f
MD		 2154
2155 /*
2156 * Before doing the actual ring buffer flush, write up to one
2157 * packet of metadata in the ring buffer.
2158 */
8b97fd42 2159 ret = lttng_metadata_output_channel(stream, chan, NULL);
96c55c2f
MD		 2160 if (ret < 0)
2161 goto err;
2162 break;
2163 }
606828e4 2164 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_METADATA_VERSION:
96c55c2f
MD		 2165 {
2166 struct lttng_metadata_stream *stream = filp->private_data;
2167
2168 return put_u64(stream->version, arg);
2169 }
606828e4 2170 case LTTNG_KERNEL_ABI_RING_BUFFER_METADATA_CACHE_DUMP:
d1344afa
JD		 2171 {
2172 struct lttng_metadata_stream *stream = filp->private_data;
2173
2174 return lttng_metadata_cache_dump(stream);
2175 }
606828e4 2176 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
8b97fd42
MD		 2177 {
2178 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2179 struct lttng_kernel_ring_buffer *buf = stream->priv;
860c213b 2180 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
8b97fd42
MD		 2181
2182 ret = lttng_metadata_output_channel(stream, chan, &coherent);
2183 if (ret > 0) {
2184 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
2185 ret = 0;
2186 } else if (ret < 0) {
2187 goto err;
2188 }
2189 break;
2190 }
d83004aa
JD		 2191 default:
2192 break;
2193 }
f613e3e6
MD		 2194 /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
2195
d83004aa 2196 /* Performing lib ring buffer ioctl after our own. */
8b97fd42 2197 ret = lib_ring_buffer_compat_ioctl(filp, rb_cmd, arg, buf);
f613e3e6
MD		 2198 if (ret < 0)
2199 goto err;
d83004aa 2200
f613e3e6 2201 switch (cmd) {
606828e4 2202 case LTTNG_KERNEL_ABI_RING_BUFFER_PUT_NEXT_SUBBUF:
f613e3e6
MD		 2203 {
2204 lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
2205 cmd, arg);
2206 break;
2207 }
606828e4 2208 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_NEXT_SUBBUF_METADATA_CHECK:
8b97fd42
MD		 2209 {
2210 return put_u32(coherent, arg);
2211 }
f613e3e6
MD		 2212 default:
2213 break;
2214 }
d83004aa
JD		 2215err:
2216 return ret;
2217}
aeb9064d 2218#endif
d83004aa 2219
b3b8072b
MD		 2220/*
2221 * This is not used by anonymous file descriptors. This code is left
2222 * there if we ever want to implement an inode with open() operation.
2223 */
d83004aa
JD		 2224static
2225int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file)
2226{
2227 struct lttng_metadata_stream *stream = inode->i_private;
e20c0fec 2228 struct lttng_kernel_ring_buffer *buf = stream->priv;
d83004aa
JD		 2229
2230 file->private_data = buf;
b3b8072b
MD		 2231 /*
2232 * Since life-time of metadata cache differs from that of
2233 * session, we need to keep our own reference on the transport.
2234 */
2235 if (!try_module_get(stream->transport->owner)) {
5a15f70c 2236 printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
b3b8072b
MD		 2237 return -EBUSY;
2238 }
d83004aa
JD		 2239 return lib_ring_buffer_open(inode, file, buf);
2240}
2241
2242static
2243int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file)
2244{
2245 struct lttng_metadata_stream *stream = file->private_data;
e20c0fec 2246 struct lttng_kernel_ring_buffer *buf = stream->priv;
d83004aa 2247
92143b2c 2248 mutex_lock(&stream->metadata_cache->lock);
94ac1e17 2249 list_del(&stream->node);
92143b2c 2250 mutex_unlock(&stream->metadata_cache->lock);
d83004aa 2251 kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
b3b8072b 2252 module_put(stream->transport->owner);
92143b2c 2253 kfree(stream);
d83004aa
JD		 2254 return lib_ring_buffer_release(inode, file, buf);
2255}
2256
2257static
2258ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
2259 struct pipe_inode_info *pipe, size_t len,
2260 unsigned int flags)
2261{
2262 struct lttng_metadata_stream *stream = in->private_data;
e20c0fec 2263 struct lttng_kernel_ring_buffer *buf = stream->priv;
d83004aa
JD		 2264
2265 return lib_ring_buffer_splice_read(in, ppos, pipe, len,
2266 flags, buf);
2267}
2268
2269static
2270int lttng_metadata_ring_buffer_mmap(struct file *filp,
2271 struct vm_area_struct *vma)
2272{
2273 struct lttng_metadata_stream *stream = filp->private_data;
e20c0fec 2274 struct lttng_kernel_ring_buffer *buf = stream->priv;
d83004aa
JD		 2275
2276 return lib_ring_buffer_mmap(filp, vma, buf);
2277}
2278
2279static
2280const struct file_operations lttng_metadata_ring_buffer_file_operations = {
2281 .owner = THIS_MODULE,
2282 .open = lttng_metadata_ring_buffer_open,
2283 .release = lttng_metadata_ring_buffer_release,
2284 .poll = lttng_metadata_ring_buffer_poll,
2285 .splice_read = lttng_metadata_ring_buffer_splice_read,
2286 .mmap = lttng_metadata_ring_buffer_mmap,
2287 .unlocked_ioctl = lttng_metadata_ring_buffer_ioctl,
2288 .llseek = vfs_lib_ring_buffer_no_llseek,
2289#ifdef CONFIG_COMPAT
2290 .compat_ioctl = lttng_metadata_ring_buffer_compat_ioctl,
2291#endif
2292};
2293
2294static
2295int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
a3fcd499 2296 const struct file_operations *fops, const char *name)
ad1c05e1 2297{
ad1c05e1 2298 int stream_fd, ret;
11b5a3c2 2299 struct file *stream_file;
ad1c05e1 2300
2a059b14 2301 stream_fd = get_unused_fd_flags(0);
ad1c05e1
MD		 2302 if (stream_fd < 0) {
2303 ret = stream_fd;
2304 goto fd_error;
2305 }
a3fcd499 2306 stream_file = anon_inode_getfile(name, fops, stream_priv, O_RDWR);
c0e31d2e
MD		 2307 if (IS_ERR(stream_file)) {
2308 ret = PTR_ERR(stream_file);
ad1c05e1
MD		 2309 goto file_error;
2310 }
409453cb
MD		 2311 /*
2312 * OPEN_FMODE, called within anon_inode_getfile/alloc_file, don't honor
2313 * FMODE_LSEEK, FMODE_PREAD nor FMODE_PWRITE. We need to read from this
2314 * file descriptor, so we set FMODE_PREAD here.
2315 */
d7b6f197 2316 stream_file->f_mode |= FMODE_PREAD;
c0e31d2e 2317 fd_install(stream_fd, stream_file);
dda6a249
MD		 2318 /*
2319 * The stream holds a reference to the channel within the generic ring
2320 * buffer library, so no need to hold a refcount on the channel and
2321 * session files here.
2322 */
ad1c05e1
MD		 2323 return stream_fd;
2324
2325file_error:
2326 put_unused_fd(stream_fd);
d83004aa
JD		 2327fd_error:
2328 return ret;
2329}
2330
2331static
2332int lttng_abi_open_stream(struct file *channel_file)
2333{
f7d06400 2334 struct lttng_kernel_channel_buffer *channel = channel_file->private_data;
e20c0fec 2335 struct lttng_kernel_ring_buffer *buf;
d83004aa
JD		 2336 int ret;
2337 void *stream_priv;
2338
f7d06400 2339 buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan);
d83004aa
JD		 2340 if (!buf)
2341 return -ENOENT;
2342
2343 stream_priv = buf;
2344 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
a3fcd499
MD		 2345 &lttng_stream_ring_buffer_file_operations,
2346 "[lttng_stream]");
d83004aa
JD		 2347 if (ret < 0)
2348 goto fd_error;
2349
2350 return ret;
2351
2352fd_error:
4a399b76 2353 channel->ops->priv->buffer_read_close(buf);
d83004aa
JD		 2354 return ret;
2355}
2356
2357static
2358int lttng_abi_open_metadata_stream(struct file *channel_file)
2359{
f7d06400
MD		 2360 struct lttng_kernel_channel_buffer *channel = channel_file->private_data;
2361 struct lttng_kernel_session *session = channel->parent.session;
e20c0fec 2362 struct lttng_kernel_ring_buffer *buf;
d83004aa
JD		 2363 int ret;
2364 struct lttng_metadata_stream *metadata_stream;
2365 void *stream_priv;
2366
f7d06400 2367 buf = channel->ops->priv->buffer_read_open(channel->priv->rb_chan);
d83004aa
JD		 2368 if (!buf)
2369 return -ENOENT;
2370
2371 metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
2372 GFP_KERNEL);
b3b8072b
MD		 2373 if (!metadata_stream) {
2374 ret = -ENOMEM;
2375 goto nomem;
2376 }
8cdc1a81 2377 metadata_stream->metadata_cache = session->priv->metadata_cache;
d83004aa
JD		 2378 init_waitqueue_head(&metadata_stream->read_wait);
2379 metadata_stream->priv = buf;
2380 stream_priv = metadata_stream;
f7d06400 2381 metadata_stream->transport = channel->priv->transport;
8b97fd42
MD		 2382 /* Initial state is an empty metadata, considered as incoherent. */
2383 metadata_stream->coherent = false;
b3b8072b
MD		 2384
2385 /*
2386 * Since life-time of metadata cache differs from that of
2387 * session, we need to keep our own reference on the transport.
2388 */
2389 if (!try_module_get(metadata_stream->transport->owner)) {
5a15f70c 2390 printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
b3b8072b
MD		 2391 ret = -EINVAL;
2392 goto notransport;
2393 }
2394
8cdc1a81 2395 if (!lttng_kref_get(&session->priv->metadata_cache->refcount)) {
901aaa5f 2396 ret = -EOVERFLOW;
9c1f4643 2397 goto kref_error;
901aaa5f
FD		 2398 }
2399
d83004aa 2400 ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
a3fcd499
MD		 2401 &lttng_metadata_ring_buffer_file_operations,
2402 "[lttng_metadata_stream]");
d83004aa
JD		 2403 if (ret < 0)
2404 goto fd_error;
2405
8cdc1a81 2406 mutex_lock(&session->priv->metadata_cache->lock);
94ac1e17 2407 list_add(&metadata_stream->node,
8cdc1a81
MD		 2408 &session->priv->metadata_cache->metadata_stream);
2409 mutex_unlock(&session->priv->metadata_cache->lock);
d83004aa
JD		 2410 return ret;
2411
ad1c05e1 2412fd_error:
8cdc1a81 2413 kref_put(&session->priv->metadata_cache->refcount, metadata_cache_destroy);
9c1f4643 2414kref_error:
b3b8072b
MD		 2415 module_put(metadata_stream->transport->owner);
2416notransport:
2417 kfree(metadata_stream);
2418nomem:
4a399b76 2419 channel->ops->priv->buffer_read_close(buf);
ad1c05e1
MD		 2420 return ret;
2421}
2422
21f58fb7
FD		 2423static
2424int lttng_abi_open_event_notifier_group_stream(struct file *notif_file)
2425{
2426 struct lttng_event_notifier_group *event_notifier_group = notif_file->private_data;
860c213b 2427 struct lttng_kernel_ring_buffer_channel *chan = event_notifier_group->chan;
e20c0fec 2428 struct lttng_kernel_ring_buffer *buf;
21f58fb7
FD		 2429 int ret;
2430 void *stream_priv;
2431
4a399b76 2432 buf = event_notifier_group->ops->priv->buffer_read_open(chan);
21f58fb7
FD		 2433 if (!buf)
2434 return -ENOENT;
2435
2436 /* The event_notifier notification fd holds a reference on the event_notifier group */
2437 if (!atomic_long_add_unless(&notif_file->f_count, 1, LONG_MAX)) {
2438 ret = -EOVERFLOW;
2439 goto refcount_error;
2440 }
2441 event_notifier_group->buf = buf;
2442 stream_priv = event_notifier_group;
2443 ret = lttng_abi_create_stream_fd(notif_file, stream_priv,
2444 &lttng_event_notifier_group_notif_fops,
2445 "[lttng_event_notifier_stream]");
2446 if (ret < 0)
2447 goto fd_error;
2448
2449 return ret;
2450
2451fd_error:
2452 atomic_long_dec(&notif_file->f_count);
2453refcount_error:
4a399b76 2454 event_notifier_group->ops->priv->buffer_read_close(buf);
21f58fb7
FD		 2455 return ret;
2456}
2457
badfe9f5 2458static
3bca4b7a
MD		 2459int lttng_abi_validate_event_param(struct lttng_kernel_abi_event *event_param,
2460 struct lttng_kernel_abi_event_ext *event_param_ext)
badfe9f5 2461{
3bca4b7a
MD		 2462 enum lttng_kernel_abi_match_check match_check;
2463
2464 if (user_event_param_ext_get_match_check(event_param_ext, &match_check))
2465 return -EINVAL;
2466
badfe9f5
MD		 2467 /* Limit ABI to implemented features. */
2468 switch (event_param->instrumentation) {
606828e4 2469 case LTTNG_KERNEL_ABI_SYSCALL:
badfe9f5 2470 switch (event_param->u.syscall.entryexit) {
49b50b8d
MD		 2471 case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT:
2472 lttng_fallthrough;
c190d76e
MJ		 2473 case LTTNG_KERNEL_ABI_SYSCALL_ENTRY:
2474 lttng_fallthrough;
2475 case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
badfe9f5
MD		 2476 break;
2477 default:
2478 return -EINVAL;
2479 }
2480 switch (event_param->u.syscall.abi) {
606828e4 2481 case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
badfe9f5
MD		 2482 break;
2483 default:
2484 return -EINVAL;
2485 }
2486 switch (event_param->u.syscall.match) {
606828e4 2487 case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME:
badfe9f5
MD		 2488 break;
2489 default:
2490 return -EINVAL;
2491 }
3bca4b7a
MD		 2492 switch (match_check) {
2493 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2494 lttng_fallthrough;
2495 case LTTNG_KERNEL_ABI_MATCH_LAZY:
2496 break;
2497 default:
2498 return -EINVAL;
2499 }
badfe9f5
MD		 2500 break;
2501
606828e4 2502 case LTTNG_KERNEL_ABI_KRETPROBE:
88a82b17 2503 switch (event_param->u.kretprobe.entryexit) {
49b50b8d 2504 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRYEXIT:
99414eaf 2505 lttng_fallthrough;
49b50b8d 2506 case LTTNG_KERNEL_ABI_KRETPROBE_ENTRY:
c190d76e 2507 lttng_fallthrough;
49b50b8d 2508 case LTTNG_KERNEL_ABI_KRETPROBE_EXIT:
99414eaf 2509 break;
88a82b17
MD		 2510 default:
2511 return -EINVAL;
2512 }
3bca4b7a
MD		 2513 switch (match_check) {
2514 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2515 lttng_fallthrough;
2516 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
2517 break;
2518 default:
2519 return -EINVAL;
2520 }
88a82b17
MD		 2521 break;
2522
c190d76e 2523 case LTTNG_KERNEL_ABI_TRACEPOINT:
3bca4b7a
MD		 2524 switch (match_check) {
2525 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2526 lttng_fallthrough;
2527 case LTTNG_KERNEL_ABI_MATCH_LAZY:
2528 break;
2529 default:
2530 return -EINVAL;
2531 }
2532 break;
2533
c190d76e
MJ		 2534 case LTTNG_KERNEL_ABI_KPROBE:
2535 lttng_fallthrough;
606828e4 2536 case LTTNG_KERNEL_ABI_UPROBE:
3bca4b7a
MD		 2537 switch (match_check) {
2538 case LTTNG_KERNEL_ABI_MATCH_DEFAULT:
2539 lttng_fallthrough;
2540 case LTTNG_KERNEL_ABI_MATCH_IMMEDIATE:
2541 break;
2542 default:
2543 return -EINVAL;
2544 }
badfe9f5
MD		 2545 break;
2546
c190d76e
MJ		 2547 case LTTNG_KERNEL_ABI_FUNCTION:
2548 lttng_fallthrough;
2549 case LTTNG_KERNEL_ABI_NOOP:
2550 lttng_fallthrough;
badfe9f5
MD		 2551 default:
2552 return -EINVAL;
2553 }
2554 return 0;
2555}
2556
3bca4b7a
MD		 2557static
2558int lttng_abi_validate_event_match(struct lttng_kernel_abi_event *event_param,
2559 struct lttng_kernel_abi_event_ext *event_param_ext)
2560{
2561 enum lttng_kernel_abi_match_check match_check;
2562 int ret;
2563
2564 if (user_event_param_ext_get_match_check(event_param_ext, &match_check))
2565 return -EINVAL;
2566
2567 /* Validate match */
2568 if (match_check == LTTNG_KERNEL_ABI_MATCH_DEFAULT) {
2569 switch (event_param->instrumentation) {
2570 case LTTNG_KERNEL_ABI_TRACEPOINT:
2571 lttng_fallthrough;
2572 case LTTNG_KERNEL_ABI_SYSCALL:
2573 match_check = LTTNG_KERNEL_ABI_MATCH_LAZY;
2574 break;
2575 case LTTNG_KERNEL_ABI_KPROBE:
2576 lttng_fallthrough;
2577 case LTTNG_KERNEL_ABI_KRETPROBE:
2578 lttng_fallthrough;
2579 case LTTNG_KERNEL_ABI_UPROBE:
2580 match_check = LTTNG_KERNEL_ABI_MATCH_IMMEDIATE;
2581 break;
2582
2583 case LTTNG_KERNEL_ABI_FUNCTION:
2584 lttng_fallthrough;
2585 case LTTNG_KERNEL_ABI_NOOP:
2586 lttng_fallthrough;
2587 default:
2588 return -EINVAL;
2589 }
2590 }
2591
2592 if (match_check == LTTNG_KERNEL_ABI_MATCH_IMMEDIATE) {
2593 switch (event_param->instrumentation) {
2594 break;
2595 case LTTNG_KERNEL_ABI_KPROBE:
2596 ret = lttng_kprobes_match_check(event_param->u.kprobe.symbol_name,
2597 event_param->u.kprobe.offset,
2598 event_param->u.kprobe.addr);
2599 if (ret)
2600 return ret;
2601 break;
2602 case LTTNG_KERNEL_ABI_KRETPROBE:
2603 ret = lttng_kretprobes_match_check(event_param->u.kretprobe.symbol_name,
2604 event_param->u.kretprobe.offset,
2605 event_param->u.kretprobe.addr);
2606 if (ret)
2607 return ret;
2608 break;
2609 case LTTNG_KERNEL_ABI_UPROBE:
2610 /*
2611 * uprobes are immediately created, which includes match checking.
2612 */
2613 break;
2614
2615 case LTTNG_KERNEL_ABI_TRACEPOINT:
2616 lttng_fallthrough;
2617 case LTTNG_KERNEL_ABI_SYSCALL:
2618 lttng_fallthrough;
2619 case LTTNG_KERNEL_ABI_FUNCTION:
2620 lttng_fallthrough;
2621 case LTTNG_KERNEL_ABI_NOOP:
2622 lttng_fallthrough;
2623 default:
2624 return -EINVAL;
2625 }
2626 }
2627 return 0;
2628}
2629
653fe716 2630static
6674c9bd 2631int lttng_abi_create_event_recorder_enabler(struct file *channel_file,
3bca4b7a
MD		 2632 struct lttng_kernel_abi_event *event_param,
2633 struct lttng_kernel_abi_event_ext *event_param_ext)
653fe716 2634{
ef784b4d 2635 const struct file_operations *fops;
f7d06400 2636 struct lttng_kernel_channel_buffer *channel = channel_file->private_data;
653fe716 2637 int event_fd, ret;
11b5a3c2 2638 struct file *event_file;
3c997079 2639 void *priv;
653fe716 2640
606828e4 2641 event_param->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
6dccd6c1 2642 switch (event_param->instrumentation) {
606828e4
MD		 2643 case LTTNG_KERNEL_ABI_KRETPROBE:
2644 event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
7371f44c 2645 break;
606828e4
MD		 2646 case LTTNG_KERNEL_ABI_KPROBE:
2647 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
e0a7a7c4 2648 break;
606828e4 2649 case LTTNG_KERNEL_ABI_FUNCTION:
e884017c
MD		 2650 WARN_ON_ONCE(1);
2651 /* Not implemented. */
e0a7a7c4
MD		 2652 break;
2653 default:
2654 break;
2655 }
ef784b4d
MD		 2656
2657 switch (event_param->instrumentation) {
c190d76e
MJ		 2658 case LTTNG_KERNEL_ABI_TRACEPOINT:
2659 lttng_fallthrough;
ef784b4d 2660 case LTTNG_KERNEL_ABI_SYSCALL:
fd0402f3
MD		 2661 lttng_fallthrough;
2662 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 2663 lttng_fallthrough;
2664 case LTTNG_KERNEL_ABI_KRETPROBE:
1437a010 2665 fops = &lttng_event_session_enabler_fops;
ef784b4d 2666 break;
99414eaf 2667
ef784b4d 2668 case LTTNG_KERNEL_ABI_UPROBE:
1437a010 2669 fops = &lttng_event_session_fops;
ef784b4d
MD		 2670 break;
2671
c190d76e
MJ		 2672 case LTTNG_KERNEL_ABI_FUNCTION:
2673 lttng_fallthrough;
2674 case LTTNG_KERNEL_ABI_NOOP:
2675 lttng_fallthrough;
ef784b4d
MD		 2676 default:
2677 return -EINVAL;
2678 }
2679
2a059b14 2680 event_fd = get_unused_fd_flags(0);
33a39a3c
MD		 2681 if (event_fd < 0) {
2682 ret = event_fd;
2683 goto fd_error;
2684 }
6ef1e2f5 2685 event_file = anon_inode_getfile("[lttng_event_recorder]",
ef784b4d 2686 fops, NULL, O_RDWR);
33a39a3c
MD		 2687 if (IS_ERR(event_file)) {
2688 ret = PTR_ERR(event_file);
2689 goto file_error;
2690 }
9c1f4643 2691 /* The event holds a reference on the channel */
98d7281c 2692 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
0d2c717f 2693 ret = -EOVERFLOW;
9c1f4643
MD		 2694 goto refcount_error;
2695 }
3bca4b7a
MD		 2696 ret = lttng_abi_validate_event_param(event_param, event_param_ext);
2697 if (ret)
2698 goto event_error;
2699 ret = lttng_abi_validate_event_match(event_param, event_param_ext);
badfe9f5
MD		 2700 if (ret)
2701 goto event_error;
684a1e4d
MD		 2702
2703 switch (event_param->instrumentation) {
c190d76e
MJ		 2704 case LTTNG_KERNEL_ABI_TRACEPOINT:
2705 lttng_fallthrough;
606828e4 2706 case LTTNG_KERNEL_ABI_SYSCALL:
684a1e4d 2707 {
1ae083ba 2708 struct lttng_event_recorder_enabler *event_enabler;
33a39a3c 2709
4993071a
PP		 2710 if (strutils_is_star_glob_pattern(event_param->name)) {
2711 /*
2712 * If the event name is a star globbing pattern,
2713 * we create the special star globbing enabler.
2714 */
1ae083ba 2715 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
33a39a3c 2716 event_param, channel);
3c997079 2717 } else {
1ae083ba 2718 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
33a39a3c 2719 event_param, channel);
1ec65de1 2720 }
def1e304 2721 if (event_enabler)
6ef1e2f5 2722 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
b2bc0bc8 2723 priv = event_enabler;
684a1e4d
MD		 2724 break;
2725 }
2726
c190d76e 2727 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 2728 lttng_fallthrough;
2729 case LTTNG_KERNEL_ABI_KRETPROBE:
fd0402f3
MD		 2730 {
2731 struct lttng_event_recorder_enabler *event_enabler;
2732
2733 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
2734 event_param, channel);
2735 if (event_enabler)
2736 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2737 priv = event_enabler;
2738 break;
2739 }
2740
606828e4 2741 case LTTNG_KERNEL_ABI_UPROBE:
684a1e4d 2742 {
83006ee0 2743 struct lttng_kernel_event_common *event;
1ae083ba 2744 struct lttng_event_recorder_enabler *event_enabler;
4ee2453d 2745
1ae083ba 2746 event_enabler = lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
def1e304
MD		 2747 event_param, channel);
2748 if (!event_enabler) {
2749 ret = -ENOMEM;
2750 goto event_error;
2751 }
33a39a3c
MD		 2752 /*
2753 * We tolerate no failure path after event creation. It
2754 * will stay invariant for the rest of the session.
2755 */
44d1600b 2756 event = lttng_kernel_event_create(&event_enabler->parent.parent, NULL, NULL);
4a46ca39 2757 lttng_event_enabler_destroy(&event_enabler->parent.parent);
33a39a3c
MD		 2758 if (IS_ERR(event)) {
2759 ret = PTR_ERR(event);
2760 goto event_error;
80f87dd2 2761 }
1437a010 2762 priv = event;
684a1e4d
MD		 2763 break;
2764 }
2765
c190d76e
MJ		 2766 case LTTNG_KERNEL_ABI_FUNCTION:
2767 lttng_fallthrough;
2768 case LTTNG_KERNEL_ABI_NOOP:
2769 lttng_fallthrough;
684a1e4d
MD		 2770 default:
2771 ret = -EINVAL;
2772 goto event_error;
03037b98 2773 }
33a39a3c
MD		 2774 event_file->private_data = priv;
2775 fd_install(event_fd, event_file);
653fe716
MD		 2776 return event_fd;
2777
03037b98 2778event_error:
9c1f4643
MD		 2779 atomic_long_dec(&channel_file->f_count);
2780refcount_error:
c0e31d2e 2781 fput(event_file);
653fe716
MD		 2782file_error:
2783 put_unused_fd(event_fd);
2784fd_error:
653fe716
MD		 2785 return ret;
2786}
ad1c05e1 2787
6ef1e2f5
MD		 2788static
2789int lttng_abi_create_event_counter_enabler(struct file *channel_file,
7b0f1e69 2790 struct lttng_kernel_counter_event *counter_event)
6ef1e2f5
MD		 2791{
2792 const struct file_operations *fops;
2793 struct lttng_kernel_channel_counter *channel = channel_file->private_data;
7b0f1e69
MD		 2794 struct lttng_kernel_abi_event *event_param = &counter_event->event_param;
2795 struct lttng_kernel_abi_event_ext *event_param_ext = &counter_event->event_param_ext;
2796 struct lttng_kernel_counter_key *counter_key = counter_event->counter_key;
6ef1e2f5
MD		 2797 int event_fd, ret;
2798 struct file *event_file;
2799 void *priv;
2800
2801 event_param->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
2802 switch (event_param->instrumentation) {
2803 case LTTNG_KERNEL_ABI_KRETPROBE:
2804 event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
2805 break;
2806 case LTTNG_KERNEL_ABI_KPROBE:
2807 event_param->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
2808 break;
2809 case LTTNG_KERNEL_ABI_FUNCTION:
2810 WARN_ON_ONCE(1);
2811 /* Not implemented. */
2812 break;
2813 default:
2814 break;
2815 }
2816
2817 switch (event_param->instrumentation) {
2818 case LTTNG_KERNEL_ABI_TRACEPOINT:
2819 lttng_fallthrough;
2820 case LTTNG_KERNEL_ABI_SYSCALL:
fd0402f3
MD		 2821 lttng_fallthrough;
2822 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 2823 lttng_fallthrough;
2824 case LTTNG_KERNEL_ABI_KRETPROBE:
6ef1e2f5
MD		 2825 fops = &lttng_event_session_enabler_fops;
2826 break;
fd0402f3 2827
6ef1e2f5
MD		 2828 case LTTNG_KERNEL_ABI_UPROBE:
2829 fops = &lttng_event_session_fops;
2830 break;
2831
2832 case LTTNG_KERNEL_ABI_FUNCTION:
2833 lttng_fallthrough;
2834 case LTTNG_KERNEL_ABI_NOOP:
2835 lttng_fallthrough;
2836 default:
2837 return -EINVAL;
2838 }
2839
2840 event_fd = get_unused_fd_flags(0);
2841 if (event_fd < 0) {
2842 ret = event_fd;
2843 goto fd_error;
2844 }
2845 event_file = anon_inode_getfile("[lttng_event_counter]",
2846 fops, NULL, O_RDWR);
2847 if (IS_ERR(event_file)) {
2848 ret = PTR_ERR(event_file);
2849 goto file_error;
2850 }
2851 /* The event holds a reference on the channel */
2852 if (!atomic_long_add_unless(&channel_file->f_count, 1, LONG_MAX)) {
2853 ret = -EOVERFLOW;
2854 goto refcount_error;
2855 }
3bca4b7a
MD		 2856 ret = lttng_abi_validate_event_param(event_param, event_param_ext);
2857 if (ret)
2858 goto event_error;
2859 ret = lttng_abi_validate_event_match(event_param, event_param_ext);
6ef1e2f5
MD		 2860 if (ret)
2861 goto event_error;
2862
2863 switch (event_param->instrumentation) {
2864 case LTTNG_KERNEL_ABI_TRACEPOINT:
2865 lttng_fallthrough;
2866 case LTTNG_KERNEL_ABI_SYSCALL:
2867 {
2868 struct lttng_event_counter_enabler *event_enabler;
2869
2870 if (strutils_is_star_glob_pattern(event_param->name)) {
2871 /*
2872 * If the event name is a star globbing pattern,
2873 * we create the special star globbing enabler.
2874 */
2875 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_STAR_GLOB,
7b0f1e69 2876 event_param, counter_key, channel);
6ef1e2f5
MD		 2877 } else {
2878 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
7b0f1e69 2879 event_param, counter_key, channel);
6ef1e2f5
MD		 2880 }
2881 if (event_enabler)
2882 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2883 priv = event_enabler;
2884 break;
2885 }
2886
2887 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 2888 lttng_fallthrough;
2889 case LTTNG_KERNEL_ABI_KRETPROBE:
fd0402f3
MD		 2890 {
2891 struct lttng_event_counter_enabler *event_enabler;
2892
2893 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
7b0f1e69 2894 event_param, counter_key, channel);
fd0402f3
MD		 2895 if (event_enabler)
2896 lttng_event_enabler_session_add(channel->parent.session, &event_enabler->parent);
2897 priv = event_enabler;
2898 break;
2899 }
2900
6ef1e2f5
MD		 2901 case LTTNG_KERNEL_ABI_UPROBE:
2902 {
2903 struct lttng_kernel_event_common *event;
2904 struct lttng_event_counter_enabler *event_enabler;
2905
2906 event_enabler = lttng_event_counter_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
7b0f1e69 2907 event_param, counter_key, channel);
6ef1e2f5
MD		 2908 if (!event_enabler) {
2909 ret = -ENOMEM;
2910 goto event_error;
2911 }
2912 /*
2913 * We tolerate no failure path after event creation. It
2914 * will stay invariant for the rest of the session.
2915 */
44d1600b 2916 event = lttng_kernel_event_create(&event_enabler->parent.parent, NULL, NULL);
6ef1e2f5
MD		 2917 lttng_event_enabler_destroy(&event_enabler->parent.parent);
2918 if (IS_ERR(event)) {
2919 ret = PTR_ERR(event);
2920 goto event_error;
2921 }
2922 priv = event;
2923 break;
2924 }
2925
2926 case LTTNG_KERNEL_ABI_FUNCTION:
2927 lttng_fallthrough;
2928 case LTTNG_KERNEL_ABI_NOOP:
2929 lttng_fallthrough;
2930 default:
2931 ret = -EINVAL;
2932 goto event_error;
2933 }
2934 event_file->private_data = priv;
2935 fd_install(event_fd, event_file);
2936 return event_fd;
2937
2938event_error:
2939 atomic_long_dec(&channel_file->f_count);
2940refcount_error:
2941 fput(event_file);
2942file_error:
2943 put_unused_fd(event_fd);
2944fd_error:
2945 return ret;
2946}
2947
dffef45d 2948static
ef784b4d 2949long lttng_event_notifier_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
dffef45d 2950{
1437a010 2951 struct lttng_kernel_event_common *event = file->private_data;
dffef45d
FD		 2952
2953 switch (cmd) {
606828e4 2954 case LTTNG_KERNEL_ABI_ENABLE:
1437a010 2955 return lttng_event_enable(event);
606828e4 2956 case LTTNG_KERNEL_ABI_DISABLE:
1437a010 2957 return lttng_event_disable(event);
606828e4 2958 case LTTNG_KERNEL_ABI_FILTER:
ef784b4d 2959 return -EINVAL;
606828e4 2960 case LTTNG_KERNEL_ABI_CAPTURE:
ef784b4d 2961 return -EINVAL;
606828e4 2962 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
1437a010 2963 return lttng_event_add_callsite(event,
ef784b4d 2964 (struct lttng_kernel_abi_event_callsite __user *) arg);
dffef45d
FD		 2965 default:
2966 return -ENOIOCTLCMD;
2967 }
2968}
2969
2970static
ef784b4d 2971long lttng_event_notifier_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
dffef45d 2972{
1437a010 2973 struct lttng_event_enabler_common *event = file->private_data;
dffef45d 2974
ef784b4d
MD		 2975 switch (cmd) {
2976 case LTTNG_KERNEL_ABI_ENABLE:
1437a010 2977 return lttng_event_enabler_enable(event);
ef784b4d 2978 case LTTNG_KERNEL_ABI_DISABLE:
1437a010 2979 return lttng_event_enabler_disable(event);
ef784b4d 2980 case LTTNG_KERNEL_ABI_FILTER:
1437a010 2981 return lttng_event_enabler_attach_filter_bytecode(event,
ef784b4d
MD		 2982 (struct lttng_kernel_abi_filter_bytecode __user *) arg);
2983 case LTTNG_KERNEL_ABI_CAPTURE:
1437a010
MD		 2984 {
2985 struct lttng_event_notifier_enabler *event_notifier_enabler =
2986 container_of(event, struct lttng_event_notifier_enabler, parent);
ef784b4d
MD		 2987 return lttng_event_notifier_enabler_attach_capture_bytecode(
2988 event_notifier_enabler,
2989 (struct lttng_kernel_abi_capture_bytecode __user *) arg);
1437a010 2990 }
ef784b4d
MD		 2991 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
2992 return -EINVAL;
dffef45d 2993 default:
ef784b4d 2994 return -ENOIOCTLCMD;
dffef45d 2995 }
ef784b4d 2996}
dffef45d 2997
ef784b4d
MD		 2998static
2999int lttng_event_notifier_event_release(struct inode *inode, struct file *file)
3000{
1437a010 3001 struct lttng_kernel_event_common *event = file->private_data;
ef784b4d 3002
1437a010
MD		 3003 if (event) {
3004 struct lttng_kernel_event_notifier *event_notifier =
3005 container_of(event, struct lttng_kernel_event_notifier, parent);
a67ba386 3006 fput(event_notifier->priv->group->file);
1437a010 3007 }
dffef45d
FD		 3008 return 0;
3009}
3010
ef784b4d
MD		 3011static
3012int lttng_event_notifier_enabler_release(struct inode *inode, struct file *file)
3013{
1437a010 3014 struct lttng_event_enabler_common *event_enabler = file->private_data;
ef784b4d 3015
1437a010
MD		 3016 if (event_enabler) {
3017 struct lttng_event_notifier_enabler *event_notifier_enabler =
3018 container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
ef784b4d 3019 fput(event_notifier_enabler->group->file);
1437a010 3020 }
ef784b4d
MD		 3021 return 0;
3022}
3023
3024static const struct file_operations lttng_event_notifier_event_fops = {
3025 .owner = THIS_MODULE,
3026 .release = lttng_event_notifier_event_release,
3027 .unlocked_ioctl = lttng_event_notifier_event_ioctl,
3028#ifdef CONFIG_COMPAT
3029 .compat_ioctl = lttng_event_notifier_event_ioctl,
3030#endif
3031};
3032
3033static const struct file_operations lttng_event_notifier_enabler_fops = {
dffef45d 3034 .owner = THIS_MODULE,
ef784b4d
MD		 3035 .release = lttng_event_notifier_enabler_release,
3036 .unlocked_ioctl = lttng_event_notifier_enabler_ioctl,
dffef45d 3037#ifdef CONFIG_COMPAT
ef784b4d 3038 .compat_ioctl = lttng_event_notifier_enabler_ioctl,
dffef45d
FD		 3039#endif
3040};
3041
3042static
3043int lttng_abi_create_event_notifier(struct file *event_notifier_group_file,
3bca4b7a
MD		 3044 struct lttng_kernel_abi_event_notifier *event_notifier_param,
3045 struct lttng_kernel_abi_event_ext *event_param_ext)
dffef45d
FD		 3046{
3047 struct lttng_event_notifier_group *event_notifier_group =
3048 event_notifier_group_file->private_data;
ef784b4d 3049 const struct file_operations *fops;
dffef45d
FD		 3050 int event_notifier_fd, ret;
3051 struct file *event_notifier_file;
3052 void *priv;
3053
ef784b4d 3054 switch (event_notifier_param->event.instrumentation) {
c190d76e
MJ		 3055 case LTTNG_KERNEL_ABI_TRACEPOINT:
3056 lttng_fallthrough;
ef784b4d 3057 case LTTNG_KERNEL_ABI_SYSCALL:
fd0402f3
MD		 3058 lttng_fallthrough;
3059 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 3060 lttng_fallthrough;
3061 case LTTNG_KERNEL_ABI_KRETPROBE:
ef784b4d
MD		 3062 fops = &lttng_event_notifier_enabler_fops;
3063 break;
fd0402f3 3064
ef784b4d
MD		 3065 case LTTNG_KERNEL_ABI_UPROBE:
3066 fops = &lttng_event_notifier_event_fops;
3067 break;
3068
c190d76e
MJ		 3069 case LTTNG_KERNEL_ABI_FUNCTION:
3070 lttng_fallthrough;
3071 case LTTNG_KERNEL_ABI_NOOP:
3072 lttng_fallthrough;
ef784b4d
MD		 3073 default:
3074 ret = -EINVAL;
3075 goto inval_instr;
3076 }
3077
606828e4 3078 event_notifier_param->event.name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
e5457479
MD		 3079 switch (event_notifier_param->event.instrumentation) {
3080 case LTTNG_KERNEL_ABI_KRETPROBE:
3081 event_notifier_param->event.u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
3082 break;
3083 case LTTNG_KERNEL_ABI_KPROBE:
3084 event_notifier_param->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
3085 break;
3086 default:
3087 break;
3088 }
dffef45d 3089
2a059b14 3090 event_notifier_fd = get_unused_fd_flags(0);
dffef45d
FD		 3091 if (event_notifier_fd < 0) {
3092 ret = event_notifier_fd;
3093 goto fd_error;
3094 }
3095
3096 event_notifier_file = anon_inode_getfile("[lttng_event_notifier]",
ef784b4d 3097 fops, NULL, O_RDWR);
dffef45d
FD		 3098 if (IS_ERR(event_notifier_file)) {
3099 ret = PTR_ERR(event_notifier_file);
3100 goto file_error;
3101 }
3102
3103 /* The event notifier holds a reference on the event notifier group. */
3104 if (!atomic_long_add_unless(&event_notifier_group_file->f_count, 1, LONG_MAX)) {
3105 ret = -EOVERFLOW;
3106 goto refcount_error;
3107 }
3108
3bca4b7a
MD		 3109 ret = lttng_abi_validate_event_param(&event_notifier_param->event, event_param_ext);
3110 if (ret)
3111 goto event_notifier_error;
3112 ret = lttng_abi_validate_event_match(&event_notifier_param->event, event_param_ext);
56237619
MD		 3113 if (ret)
3114 goto event_notifier_error;
3115
684a1e4d 3116 switch (event_notifier_param->event.instrumentation) {
c190d76e
MJ		 3117 case LTTNG_KERNEL_ABI_TRACEPOINT:
3118 lttng_fallthrough;
606828e4 3119 case LTTNG_KERNEL_ABI_SYSCALL:
684a1e4d 3120 {
dffef45d
FD		 3121 struct lttng_event_notifier_enabler *enabler;
3122
3123 if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) {
3124 /*
3125 * If the event name is a star globbing pattern,
3126 * we create the special star globbing enabler.
3127 */
3128 enabler = lttng_event_notifier_enabler_create(
dffef45d 3129 LTTNG_ENABLER_FORMAT_STAR_GLOB,
1bbb5b2d
MD		 3130 event_notifier_param,
3131 event_notifier_group);
dffef45d
FD		 3132 } else {
3133 enabler = lttng_event_notifier_enabler_create(
dffef45d 3134 LTTNG_ENABLER_FORMAT_NAME,
1bbb5b2d
MD		 3135 event_notifier_param,
3136 event_notifier_group);
dffef45d 3137 }
1bbb5b2d
MD		 3138 if (enabler)
3139 lttng_event_notifier_enabler_group_add(event_notifier_group, enabler);
dffef45d 3140 priv = enabler;
684a1e4d
MD		 3141 break;
3142 }
3143
c190d76e 3144 case LTTNG_KERNEL_ABI_KPROBE:
99414eaf
MD		 3145 lttng_fallthrough;
3146 case LTTNG_KERNEL_ABI_KRETPROBE:
fd0402f3
MD		 3147 {
3148 struct lttng_event_notifier_enabler *enabler;
3149
3150 enabler = lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
3151 event_notifier_param, event_notifier_group);
3152 if (enabler)
3153 lttng_event_notifier_enabler_group_add(event_notifier_group, enabler);
3154 priv = enabler;
3155 break;
3156 }
3157
606828e4 3158 case LTTNG_KERNEL_ABI_UPROBE:
684a1e4d 3159 {
83006ee0 3160 struct lttng_kernel_event_common *event;
1bbb5b2d 3161 struct lttng_event_notifier_enabler *event_notifier_enabler;
dffef45d 3162
1bbb5b2d
MD		 3163 event_notifier_enabler = lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME,
3164 event_notifier_param, event_notifier_group);
3165 if (!event_notifier_enabler) {
3166 ret = -ENOMEM;
3167 goto event_notifier_error;
3168 }
44d1600b 3169 event = lttng_kernel_event_create(&event_notifier_enabler->parent, NULL, NULL);
1bbb5b2d 3170 lttng_event_enabler_destroy(&event_notifier_enabler->parent);
83006ee0
MD		 3171 if (IS_ERR(event)) {
3172 ret = PTR_ERR(event);
dffef45d
FD		 3173 goto event_notifier_error;
3174 }
1437a010 3175 priv = event;
684a1e4d
MD		 3176 break;
3177 }
3178
c190d76e
MJ		 3179 case LTTNG_KERNEL_ABI_FUNCTION:
3180 lttng_fallthrough;
3181 case LTTNG_KERNEL_ABI_NOOP:
3182 lttng_fallthrough;
684a1e4d
MD		 3183 default:
3184 ret = -EINVAL;
3185 goto event_notifier_error;
dffef45d
FD		 3186 }
3187 event_notifier_file->private_data = priv;
3188 fd_install(event_notifier_fd, event_notifier_file);
3189 return event_notifier_fd;
3190
3191event_notifier_error:
3192 atomic_long_dec(&event_notifier_group_file->f_count);
3193refcount_error:
3194 fput(event_notifier_file);
3195file_error:
3196 put_unused_fd(event_notifier_fd);
3197fd_error:
3198inval_instr:
3199 return ret;
3200}
3201
2ff86ce2
MD		 3202static
3203long lttng_abi_session_create_counter(
3204 struct lttng_kernel_session *session,
81ab5b77 3205 const struct lttng_kernel_counter_conf *counter_conf)
2ff86ce2
MD		 3206{
3207 int counter_fd, ret;
3208 char *counter_transport_name;
3209 struct lttng_kernel_channel_counter *chan_counter = NULL;
3210 struct file *counter_file;
2ff86ce2 3211
81ab5b77 3212 if (counter_conf->arithmetic != LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR) {
2ff86ce2
MD		 3213 printk(KERN_ERR "LTTng: Maps: Counter of the wrong arithmetic type.\n");
3214 return -EINVAL;
3215 }
3216
2ff86ce2 3217 switch (counter_conf->bitness) {
81ab5b77 3218 case LTTNG_KERNEL_COUNTER_BITNESS_64:
2ff86ce2
MD		 3219 counter_transport_name = "counter-per-cpu-64-modular";
3220 break;
81ab5b77 3221 case LTTNG_KERNEL_COUNTER_BITNESS_32:
2ff86ce2
MD		 3222 counter_transport_name = "counter-per-cpu-32-modular";
3223 break;
3224 default:
3225 return -EINVAL;
3226 }
3227
3228 lttng_lock_sessions();
3229
3230 counter_fd = get_unused_fd_flags(0);
3231 if (counter_fd < 0) {
3232 ret = counter_fd;
3233 goto fd_error;
3234 }
3235
3236 counter_file = anon_inode_getfile("[lttng_counter]",
3237 &lttng_counter_fops,
3238 NULL, O_RDONLY);
3239 if (IS_ERR(counter_file)) {
3240 ret = PTR_ERR(counter_file);
3241 goto file_error;
3242 }
3243
2ff86ce2
MD		 3244 if (!atomic_long_add_unless(&session->priv->file->f_count, 1, LONG_MAX)) {
3245 ret = -EOVERFLOW;
3246 goto refcount_error;
3247 }
3248
81ab5b77
MD		 3249 chan_counter = lttng_kernel_counter_create(counter_transport_name, 1, counter_conf->dimension_array, 0,
3250 counter_conf->flags & LTTNG_KERNEL_COUNTER_CONF_FLAG_COALESCE_HITS);
2ff86ce2
MD		 3251 if (!chan_counter) {
3252 ret = -EINVAL;
3253 goto create_error;
3254 }
3255
3256 chan_counter->priv->parent.file = counter_file;
3257 chan_counter->priv->owner = session->priv->file;
3258 chan_counter->parent.session = session;
3259 list_add(&chan_counter->priv->parent.node, &session->priv->chan_head);
3260 counter_file->private_data = chan_counter;
3261
3262 fd_install(counter_fd, counter_file);
3263 lttng_unlock_sessions();
3264
3265 return counter_fd;
3266
3267create_error:
3268 atomic_long_dec(&session->priv->file->f_count);
3269refcount_error:
3270 fput(counter_file);
3271file_error:
3272 put_unused_fd(counter_fd);
3273fd_error:
3274 lttng_unlock_sessions();
3275 return ret;
3276}
3277
99f52fcc
FD		 3278static
3279long lttng_abi_event_notifier_group_create_error_counter(
3280 struct file *event_notifier_group_file,
81ab5b77 3281 const struct lttng_kernel_counter_conf *counter_conf)
99f52fcc
FD		 3282{
3283 int counter_fd, ret;
3284 char *counter_transport_name;
76ba9cee 3285 struct lttng_kernel_channel_counter *chan_counter = NULL;
99f52fcc
FD		 3286 struct file *counter_file;
3287 struct lttng_event_notifier_group *event_notifier_group =
3288 (struct lttng_event_notifier_group *) event_notifier_group_file->private_data;
76ba9cee 3289 size_t counter_len;
99f52fcc 3290
81ab5b77 3291 if (counter_conf->arithmetic != LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR) {
99f52fcc
FD		 3292 printk(KERN_ERR "LTTng: event_notifier: Error counter of the wrong arithmetic type.\n");
3293 return -EINVAL;
3294 }
3295
81ab5b77
MD		 3296 switch (counter_conf->bitness) {
3297 case LTTNG_KERNEL_COUNTER_BITNESS_64:
99f52fcc
FD		 3298 counter_transport_name = "counter-per-cpu-64-modular";
3299 break;
81ab5b77 3300 case LTTNG_KERNEL_COUNTER_BITNESS_32:
99f52fcc
FD		 3301 counter_transport_name = "counter-per-cpu-32-modular";
3302 break;
3303 default:
3304 return -EINVAL;
3305 }
3306
3307 /*
3308 * Lock sessions to provide mutual exclusion against concurrent
3309 * modification of event_notifier group, which would result in
3310 * overwriting the error counter if set concurrently.
3311 */
3312 lttng_lock_sessions();
3313
3314 if (event_notifier_group->error_counter) {
3315 printk(KERN_ERR "Error counter already created in event_notifier group\n");
3316 ret = -EBUSY;
3317 goto fd_error;
3318 }
3319
2a059b14 3320 counter_fd = get_unused_fd_flags(0);
99f52fcc
FD		 3321 if (counter_fd < 0) {
3322 ret = counter_fd;
3323 goto fd_error;
3324 }
3325
3326 counter_file = anon_inode_getfile("[lttng_counter]",
3327 &lttng_counter_fops,
3328 NULL, O_RDONLY);
3329 if (IS_ERR(counter_file)) {
3330 ret = PTR_ERR(counter_file);
3331 goto file_error;
3332 }
3333
99f52fcc
FD		 3334 if (!atomic_long_add_unless(&event_notifier_group_file->f_count, 1, LONG_MAX)) {
3335 ret = -EOVERFLOW;
3336 goto refcount_error;
3337 }
3338
81ab5b77
MD		 3339 counter_len = counter_conf->dimension_array[0].size;
3340 chan_counter = lttng_kernel_counter_create(counter_transport_name, 1, counter_conf->dimension_array, 0, false);
76ba9cee 3341 if (!chan_counter) {
99f52fcc 3342 ret = -EINVAL;
76ba9cee 3343 goto create_error;
99f52fcc
FD		 3344 }
3345
76ba9cee
MD		 3346 chan_counter->priv->parent.file = counter_file;
3347 chan_counter->priv->owner = event_notifier_group->file;
3348 counter_file->private_data = chan_counter;
99f52fcc 3349 event_notifier_group->error_counter_len = counter_len;
ab04d7b1
MD		 3350 /*
3351 * store-release to publish error counter matches load-acquire
3352 * in record_error. Ensures the counter is created and the
3353 * error_counter_len is set before they are used.
3354 */
76ba9cee
MD		 3355 smp_store_release(&event_notifier_group->error_counter,
3356 chan_counter);
99f52fcc
FD		 3357
3358 fd_install(counter_fd, counter_file);
3359 lttng_unlock_sessions();
3360
3361 return counter_fd;
3362
76ba9cee 3363create_error:
99f52fcc
FD		 3364 atomic_long_dec(&event_notifier_group_file->f_count);
3365refcount_error:
3366 fput(counter_file);
3367file_error:
3368 put_unused_fd(counter_fd);
3369fd_error:
3370 lttng_unlock_sessions();
3371 return ret;
3372}
3373
750b05f2
FD		 3374static
3375long lttng_event_notifier_group_ioctl(struct file *file, unsigned int cmd,
3376 unsigned long arg)
3377{
81ab5b77
MD		 3378 int ret;
3379
750b05f2 3380 switch (cmd) {
606828e4 3381 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD:
21f58fb7
FD		 3382 {
3383 return lttng_abi_open_event_notifier_group_stream(file);
3384 }
606828e4 3385 case LTTNG_KERNEL_ABI_EVENT_NOTIFIER_CREATE:
dffef45d 3386 {
606828e4 3387 struct lttng_kernel_abi_event_notifier uevent_notifier_param;
bd8af103 3388 struct lttng_kernel_abi_event_ext uevent_param_ext = {};
3bca4b7a 3389 int ret;
dffef45d
FD		 3390
3391 if (copy_from_user(&uevent_notifier_param,
606828e4 3392 (struct lttng_kernel_abi_event_notifier __user *) arg,
dffef45d
FD		 3393 sizeof(uevent_notifier_param)))
3394 return -EFAULT;
3bca4b7a
MD		 3395 ret = copy_user_event_param_ext(&uevent_param_ext, &uevent_notifier_param.event);
3396 if (ret)
3397 return ret;
3398 return lttng_abi_create_event_notifier(file, &uevent_notifier_param, &uevent_param_ext);
dffef45d 3399 }
69c3677a 3400 case LTTNG_KERNEL_ABI_OLD_COUNTER:
99f52fcc 3401 {
434e86ee 3402 struct lttng_kernel_counter_conf counter_conf;
99f52fcc 3403
81ab5b77
MD		 3404 ret = lttng_abi_copy_user_old_counter_conf(&counter_conf,
3405 (struct lttng_kernel_abi_old_counter_conf __user *) arg);
3406 if (ret)
3407 return ret;
3408 return lttng_abi_event_notifier_group_create_error_counter(file, &counter_conf);
3409 }
3410 case LTTNG_KERNEL_ABI_COUNTER:
3411 {
434e86ee 3412 struct lttng_kernel_counter_conf counter_conf;
81ab5b77
MD		 3413
3414 ret = lttng_abi_copy_user_counter_conf(&counter_conf,
3415 (struct lttng_kernel_abi_counter_conf __user *) arg);
3416 if (ret)
3417 return ret;
3418 return lttng_abi_event_notifier_group_create_error_counter(file, &counter_conf);
99f52fcc 3419 }
750b05f2
FD		 3420 default:
3421 return -ENOIOCTLCMD;
3422 }
3423 return 0;
3424}
3425
3426static
3427int lttng_event_notifier_group_release(struct inode *inode, struct file *file)
3428{
3429 struct lttng_event_notifier_group *event_notifier_group =
3430 file->private_data;
3431
3432 if (event_notifier_group)
3433 lttng_event_notifier_group_destroy(event_notifier_group);
3434 return 0;
3435}
3436
3437static const struct file_operations lttng_event_notifier_group_fops = {
3438 .owner = THIS_MODULE,
3439 .release = lttng_event_notifier_group_release,
3440 .unlocked_ioctl = lttng_event_notifier_group_ioctl,
3441#ifdef CONFIG_COMPAT
3442 .compat_ioctl = lttng_event_notifier_group_ioctl,
3443#endif
3444};
3445
ad1c05e1
MD		 3446/**
3447 * lttng_channel_ioctl - lttng syscall through ioctl
3448 *
c0e31d2e 3449 * @file: the file
ad1c05e1
MD		 3450 * @cmd: the command
3451 * @arg: command arg
3452 *
3453 * This ioctl implements lttng commands:
606828e4 3454 * LTTNG_KERNEL_ABI_STREAM
ad1c05e1
MD		 3455 * Returns an event stream file descriptor or failure.
3456 * (typically, one event stream records events from one CPU)
606828e4 3457 * LTTNG_KERNEL_ABI_EVENT
ad1c05e1 3458 * Returns an event file descriptor or failure.
606828e4 3459 * LTTNG_KERNEL_ABI_CONTEXT
8070f5c0 3460 * Prepend a context field to each event in the channel
606828e4 3461 * LTTNG_KERNEL_ABI_ENABLE
e64957da 3462 * Enable recording for events in this channel (weak enable)
606828e4 3463 * LTTNG_KERNEL_ABI_DISABLE
e64957da 3464 * Disable recording for events in this channel (strong disable)
baf20995 3465 *
baf20995
MD		 3466 * Channel and event file descriptors also hold a reference on the session.
3467 */
ad1c05e1 3468static
c0e31d2e 3469long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
baf20995 3470{
f7d06400 3471 struct lttng_kernel_channel_buffer *channel = file->private_data;
8070f5c0 3472
baf20995 3473 switch (cmd) {
606828e4
MD		 3474 case LTTNG_KERNEL_ABI_OLD_STREAM:
3475 case LTTNG_KERNEL_ABI_STREAM:
c0e31d2e 3476 return lttng_abi_open_stream(file);
606828e4 3477 case LTTNG_KERNEL_ABI_OLD_EVENT:
6dccd6c1 3478 {
606828e4
MD		 3479 struct lttng_kernel_abi_event *uevent_param;
3480 struct lttng_kernel_abi_old_event *old_uevent_param;
6dccd6c1
JD		 3481 int ret;
3482
606828e4 3483 uevent_param = kmalloc(sizeof(struct lttng_kernel_abi_event),
6dccd6c1
JD		 3484 GFP_KERNEL);
3485 if (!uevent_param) {
3486 ret = -ENOMEM;
3487 goto old_event_end;
3488 }
3489 old_uevent_param = kmalloc(
606828e4 3490 sizeof(struct lttng_kernel_abi_old_event),
6dccd6c1
JD		 3491 GFP_KERNEL);
3492 if (!old_uevent_param) {
3493 ret = -ENOMEM;
3494 goto old_event_error_free_param;
3495 }
3496 if (copy_from_user(old_uevent_param,
606828e4
MD		 3497 (struct lttng_kernel_abi_old_event __user *) arg,
3498 sizeof(struct lttng_kernel_abi_old_event))) {
6dccd6c1
JD		 3499 ret = -EFAULT;
3500 goto old_event_error_free_old_param;
3501 }
3502
3503 memcpy(uevent_param->name, old_uevent_param->name,
3504 sizeof(uevent_param->name));
3505 uevent_param->instrumentation =
3506 old_uevent_param->instrumentation;
3507
3508 switch (old_uevent_param->instrumentation) {
606828e4 3509 case LTTNG_KERNEL_ABI_KPROBE:
6dccd6c1
JD		 3510 uevent_param->u.kprobe.addr =
3511 old_uevent_param->u.kprobe.addr;
3512 uevent_param->u.kprobe.offset =
3513 old_uevent_param->u.kprobe.offset;
3514 memcpy(uevent_param->u.kprobe.symbol_name,
3515 old_uevent_param->u.kprobe.symbol_name,
3516 sizeof(uevent_param->u.kprobe.symbol_name));
3517 break;
606828e4 3518 case LTTNG_KERNEL_ABI_KRETPROBE:
6dccd6c1
JD		 3519 uevent_param->u.kretprobe.addr =
3520 old_uevent_param->u.kretprobe.addr;
3521 uevent_param->u.kretprobe.offset =
3522 old_uevent_param->u.kretprobe.offset;
3523 memcpy(uevent_param->u.kretprobe.symbol_name,
3524 old_uevent_param->u.kretprobe.symbol_name,
3525 sizeof(uevent_param->u.kretprobe.symbol_name));
3526 break;
606828e4 3527 case LTTNG_KERNEL_ABI_FUNCTION:
e884017c
MD		 3528 WARN_ON_ONCE(1);
3529 /* Not implemented. */
6dccd6c1
JD		 3530 break;
3531 default:
3532 break;
3533 }
3bca4b7a 3534 ret = lttng_abi_create_event_recorder_enabler(file, uevent_param, NULL);
6dccd6c1
JD		 3535
3536old_event_error_free_old_param:
3537 kfree(old_uevent_param);
3538old_event_error_free_param:
3539 kfree(uevent_param);
3540old_event_end:
3541 return ret;
3542 }
606828e4 3543 case LTTNG_KERNEL_ABI_EVENT:
6dccd6c1 3544 {
606828e4 3545 struct lttng_kernel_abi_event uevent_param;
bd8af103 3546 struct lttng_kernel_abi_event_ext uevent_param_ext = {};
3bca4b7a 3547 int ret;
6dccd6c1
JD		 3548
3549 if (copy_from_user(&uevent_param,
606828e4 3550 (struct lttng_kernel_abi_event __user *) arg,
6dccd6c1
JD		 3551 sizeof(uevent_param)))
3552 return -EFAULT;
3bca4b7a
MD		 3553 ret = copy_user_event_param_ext(&uevent_param_ext, &uevent_param);
3554 if (ret)
3555 return ret;
3556 return lttng_abi_create_event_recorder_enabler(file, &uevent_param, &uevent_param_ext);
6dccd6c1 3557 }
606828e4 3558 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
6dccd6c1 3559 {
606828e4
MD		 3560 struct lttng_kernel_abi_context *ucontext_param;
3561 struct lttng_kernel_abi_old_context *old_ucontext_param;
6dccd6c1
JD		 3562 int ret;
3563
606828e4 3564 ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_context),
6dccd6c1
JD		 3565 GFP_KERNEL);
3566 if (!ucontext_param) {
3567 ret = -ENOMEM;
3568 goto old_ctx_end;
3569 }
606828e4 3570 old_ucontext_param = kmalloc(sizeof(struct lttng_kernel_abi_old_context),
6dccd6c1
JD		 3571 GFP_KERNEL);
3572 if (!old_ucontext_param) {
3573 ret = -ENOMEM;
3574 goto old_ctx_error_free_param;
3575 }
3576
3577 if (copy_from_user(old_ucontext_param,
606828e4
MD		 3578 (struct lttng_kernel_abi_old_context __user *) arg,
3579 sizeof(struct lttng_kernel_abi_old_context))) {
6dccd6c1
JD		 3580 ret = -EFAULT;
3581 goto old_ctx_error_free_old_param;
3582 }
3583 ucontext_param->ctx = old_ucontext_param->ctx;
3584 memcpy(ucontext_param->padding, old_ucontext_param->padding,
3585 sizeof(ucontext_param->padding));
3586 /* only type that uses the union */
606828e4 3587 if (old_ucontext_param->ctx == LTTNG_KERNEL_ABI_CONTEXT_PERF_COUNTER) {
6dccd6c1
JD		 3588 ucontext_param->u.perf_counter.type =
3589 old_ucontext_param->u.perf_counter.type;
3590 ucontext_param->u.perf_counter.config =
3591 old_ucontext_param->u.perf_counter.config;
3592 memcpy(ucontext_param->u.perf_counter.name,
3593 old_ucontext_param->u.perf_counter.name,
3594 sizeof(ucontext_param->u.perf_counter.name));
3595 }
3596
3597 ret = lttng_abi_add_context(file,
3598 ucontext_param,
f7d06400 3599 &channel->priv->ctx, channel->parent.session);
6dccd6c1
JD		 3600
3601old_ctx_error_free_old_param:
3602 kfree(old_ucontext_param);
3603old_ctx_error_free_param:
3604 kfree(ucontext_param);
3605old_ctx_end:
3606 return ret;
3607 }
606828e4 3608 case LTTNG_KERNEL_ABI_CONTEXT:
6dccd6c1 3609 {
606828e4 3610 struct lttng_kernel_abi_context ucontext_param;
6dccd6c1
JD		 3611
3612 if (copy_from_user(&ucontext_param,
606828e4 3613 (struct lttng_kernel_abi_context __user *) arg,
6dccd6c1
JD		 3614 sizeof(ucontext_param)))
3615 return -EFAULT;
3616 return lttng_abi_add_context(file,
3617 &ucontext_param,
f7d06400 3618 &channel->priv->ctx, channel->parent.session);
6dccd6c1 3619 }
606828e4
MD		 3620 case LTTNG_KERNEL_ABI_OLD_ENABLE:
3621 case LTTNG_KERNEL_ABI_ENABLE:
6b757027 3622 return lttng_channel_enable(&channel->parent);
606828e4
MD		 3623 case LTTNG_KERNEL_ABI_OLD_DISABLE:
3624 case LTTNG_KERNEL_ABI_DISABLE:
6b757027 3625 return lttng_channel_disable(&channel->parent);
606828e4 3626 case LTTNG_KERNEL_ABI_SYSCALL_MASK:
c970b655 3627 return lttng_syscall_table_get_active_mask(&channel->priv->parent.syscall_table,
606828e4 3628 (struct lttng_kernel_abi_syscall_mask __user *) arg);
baf20995
MD		 3629 default:
3630 return -ENOIOCTLCMD;
3631 }
3632}
3633
5dbbdb43
MD		 3634/**
3635 * lttng_metadata_ioctl - lttng syscall through ioctl
3636 *
3637 * @file: the file
3638 * @cmd: the command
3639 * @arg: command arg
3640 *
3641 * This ioctl implements lttng commands:
606828e4 3642 * LTTNG_KERNEL_ABI_STREAM
5dbbdb43
MD		 3643 * Returns an event stream file descriptor or failure.
3644 *
3645 * Channel and event file descriptors also hold a reference on the session.
3646 */
3647static
3648long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3649{
3650 switch (cmd) {
606828e4
MD		 3651 case LTTNG_KERNEL_ABI_OLD_STREAM:
3652 case LTTNG_KERNEL_ABI_STREAM:
d83004aa 3653 return lttng_abi_open_metadata_stream(file);
5dbbdb43
MD		 3654 default:
3655 return -ENOIOCTLCMD;
3656 }
3657}
3658
653fe716
MD		 3659/**
3660 * lttng_channel_poll - lttng stream addition/removal monitoring
3661 *
c0e31d2e 3662 * @file: the file
653fe716
MD		 3663 * @wait: poll table
3664 */
56386a64 3665static
c0e31d2e 3666unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
653fe716 3667{
f7d06400 3668 struct lttng_kernel_channel_buffer *channel = file->private_data;
653fe716
MD		 3669 unsigned int mask = 0;
3670
c0e31d2e 3671 if (file->f_mode & FMODE_READ) {
a33e44a6 3672 poll_wait_set_exclusive(wait);
f7d06400 3673 poll_wait(file, channel->ops->priv->get_hp_wait_queue(channel->priv->rb_chan),
24cedcfe 3674 wait);
653fe716 3675
f7d06400 3676 if (channel->ops->priv->is_disabled(channel->priv->rb_chan))
254ec7bc 3677 return POLLERR;
f7d06400 3678 if (channel->ops->priv->is_finalized(channel->priv->rb_chan))
653fe716 3679 return POLLHUP;
f7d06400 3680 if (channel->ops->priv->buffer_has_read_closed_stream(channel->priv->rb_chan))
653fe716 3681 return POLLIN | POLLRDNORM;
f71ecafa 3682 return 0;
653fe716
MD		 3683 }
3684 return mask;
3685
3686}
3687
0a84a57f
MD		 3688static
3689int lttng_channel_release(struct inode *inode, struct file *file)
3690{
f7d06400 3691 struct lttng_kernel_channel_buffer *channel = file->private_data;
c269fff4
MD		 3692
3693 if (channel)
f7d06400 3694 fput(channel->parent.session->priv->file);
0a84a57f
MD		 3695 return 0;
3696}
3697
d83004aa
JD		 3698static
3699int lttng_metadata_channel_release(struct inode *inode, struct file *file)
3700{
f7d06400 3701 struct lttng_kernel_channel_buffer *channel = file->private_data;
d83004aa
JD		 3702
3703 if (channel) {
f7d06400 3704 fput(channel->parent.session->priv->file);
2ff86ce2 3705 lttng_metadata_channel_buffer_destroy(channel);
d83004aa
JD		 3706 }
3707
3708 return 0;
3709}
3710
ad1c05e1 3711static const struct file_operations lttng_channel_fops = {
a33c9927 3712 .owner = THIS_MODULE,
03037b98 3713 .release = lttng_channel_release,
653fe716 3714 .poll = lttng_channel_poll,
ad1c05e1 3715 .unlocked_ioctl = lttng_channel_ioctl,
baf20995 3716#ifdef CONFIG_COMPAT
03037b98 3717 .compat_ioctl = lttng_channel_ioctl,
baf20995 3718#endif
11b5a3c2 3719};
baf20995 3720
5dbbdb43 3721static const struct file_operations lttng_metadata_fops = {
a33c9927 3722 .owner = THIS_MODULE,
d83004aa 3723 .release = lttng_metadata_channel_release,
5dbbdb43
MD		 3724 .unlocked_ioctl = lttng_metadata_ioctl,
3725#ifdef CONFIG_COMPAT
3726 .compat_ioctl = lttng_metadata_ioctl,
3727#endif
3728};
3729
8070f5c0 3730/**
1437a010 3731 * lttng_event_ioctl - lttng syscall through ioctl
8070f5c0
MD		 3732 *
3733 * @file: the file
3734 * @cmd: the command
3735 * @arg: command arg
3736 *
3737 * This ioctl implements lttng commands:
606828e4 3738 * LTTNG_KERNEL_ABI_CONTEXT
8070f5c0 3739 * Prepend a context field to each record of this event
606828e4 3740 * LTTNG_KERNEL_ABI_ENABLE
e64957da 3741 * Enable recording for this event (weak enable)
606828e4 3742 * LTTNG_KERNEL_ABI_DISABLE
e64957da 3743 * Disable recording for this event (strong disable)
8070f5c0
MD		 3744 */
3745static
1437a010 3746long lttng_event_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
8070f5c0 3747{
1437a010 3748 struct lttng_kernel_event_common *event = file->private_data;
8070f5c0
MD		 3749
3750 switch (cmd) {
606828e4 3751 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
6dccd6c1 3752 {
3c997079
MD		 3753 /* Not implemented */
3754 return -ENOSYS;
6dccd6c1 3755 }
606828e4 3756 case LTTNG_KERNEL_ABI_CONTEXT:
6dccd6c1 3757 {
3c997079
MD		 3758 /* Not implemented */
3759 return -ENOSYS;
6dccd6c1 3760 }
606828e4
MD		 3761 case LTTNG_KERNEL_ABI_OLD_ENABLE:
3762 case LTTNG_KERNEL_ABI_ENABLE:
1437a010 3763 return lttng_event_enable(event);
606828e4
MD		 3764 case LTTNG_KERNEL_ABI_OLD_DISABLE:
3765 case LTTNG_KERNEL_ABI_DISABLE:
1437a010 3766 return lttng_event_disable(event);
606828e4 3767 case LTTNG_KERNEL_ABI_FILTER:
ef784b4d 3768 return -EINVAL;
606828e4 3769 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
1437a010 3770 return lttng_event_add_callsite(event,
ef784b4d 3771 (struct lttng_kernel_abi_event_callsite __user *) arg);
8070f5c0
MD		 3772 default:
3773 return -ENOIOCTLCMD;
3774 }
3775}
3776
ef784b4d
MD		 3777/**
3778 * lttng_event_recorder_enabler_ioctl - lttng syscall through ioctl
3779 *
3780 * @file: the file
3781 * @cmd: the command
3782 * @arg: command arg
3783 *
3784 * This ioctl implements lttng commands:
3785 * LTTNG_KERNEL_ABI_CONTEXT
3786 * Prepend a context field to each record of this event
3787 * LTTNG_KERNEL_ABI_ENABLE
3788 * Enable recording for this event (weak enable)
3789 * LTTNG_KERNEL_ABI_DISABLE
3790 * Disable recording for this event (strong disable)
3791 */
0a84a57f 3792static
1437a010 3793long lttng_event_enabler_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
0a84a57f 3794{
1437a010 3795 struct lttng_event_enabler_common *event_enabler = file->private_data;
3c997079 3796
ef784b4d
MD		 3797 switch (cmd) {
3798 case LTTNG_KERNEL_ABI_OLD_CONTEXT:
3799 {
3800 /* Not implemented */
3801 return -ENOSYS;
3802 }
3803 case LTTNG_KERNEL_ABI_CONTEXT:
3804 {
3805 /* Not implemented */
3806 return -ENOSYS;
3807 }
3808 case LTTNG_KERNEL_ABI_OLD_ENABLE:
3809 case LTTNG_KERNEL_ABI_ENABLE:
1437a010 3810 return lttng_event_enabler_enable(event_enabler);
ef784b4d
MD		 3811 case LTTNG_KERNEL_ABI_OLD_DISABLE:
3812 case LTTNG_KERNEL_ABI_DISABLE:
1437a010 3813 return lttng_event_enabler_disable(event_enabler);
ef784b4d 3814 case LTTNG_KERNEL_ABI_FILTER:
fd0402f3
MD		 3815 /*
3816 * Filters are only supported by tracepoint and syscall instrumentation.
3817 */
3818 switch (event_enabler->event_param.instrumentation) {
3819 case LTTNG_KERNEL_ABI_TRACEPOINT:
3820 lttng_fallthrough;
3821 case LTTNG_KERNEL_ABI_SYSCALL:
3822 return lttng_event_enabler_attach_filter_bytecode(event_enabler,
3823 (struct lttng_kernel_abi_filter_bytecode __user *) arg);
3824
3825 default:
3826 return -EINVAL;
3827 }
ef784b4d
MD		 3828 case LTTNG_KERNEL_ABI_ADD_CALLSITE:
3829 return -EINVAL;
3c997079 3830 default:
ef784b4d 3831 return -ENOIOCTLCMD;
3c997079 3832 }
ef784b4d
MD		 3833}
3834
3835static
1437a010 3836int lttng_event_session_release(struct inode *inode, struct file *file)
ef784b4d 3837{
1437a010 3838 struct lttng_kernel_event_common *event = file->private_data;
ef784b4d 3839
1437a010
MD		 3840 if (event) {
3841 struct lttng_kernel_event_session_common_private *event_session_priv =
3842 container_of(event->priv, struct lttng_kernel_event_session_common_private, parent);
3843 fput(event_session_priv->chan->priv->file);
3844 }
ef784b4d
MD		 3845 return 0;
3846}
c269fff4 3847
ef784b4d 3848static
1437a010 3849int lttng_event_session_enabler_release(struct inode *inode, struct file *file)
ef784b4d 3850{
1437a010 3851 struct lttng_event_enabler_common *event_enabler = file->private_data;
ef784b4d 3852
1437a010
MD		 3853 if (event_enabler) {
3854 struct lttng_event_enabler_session_common *event_session_enabler =
3855 container_of(event_enabler, struct lttng_event_enabler_session_common, parent);
3856 fput(event_session_enabler->chan->priv->file);
3857 }
0a84a57f
MD		 3858 return 0;
3859}
3860
1437a010 3861static const struct file_operations lttng_event_session_fops = {
ef784b4d 3862 .owner = THIS_MODULE,
1437a010
MD		 3863 .release = lttng_event_session_release,
3864 .unlocked_ioctl = lttng_event_ioctl,
ef784b4d 3865#ifdef CONFIG_COMPAT
1437a010 3866 .compat_ioctl = lttng_event_ioctl,
ef784b4d
MD		 3867#endif
3868};
3869
1437a010 3870static const struct file_operations lttng_event_session_enabler_fops = {
a33c9927 3871 .owner = THIS_MODULE,
1437a010
MD		 3872 .release = lttng_event_session_enabler_release,
3873 .unlocked_ioctl = lttng_event_enabler_ioctl,
8070f5c0 3874#ifdef CONFIG_COMPAT
1437a010 3875 .compat_ioctl = lttng_event_enabler_ioctl,
8070f5c0 3876#endif
11b5a3c2 3877};
0a84a57f 3878
3b731ab1
JD		 3879static int put_u64(uint64_t val, unsigned long arg)
3880{
3881 return put_user(val, (uint64_t __user *) arg);
3882}
3883
8b97fd42
MD		 3884static int put_u32(uint32_t val, unsigned long arg)
3885{
3886 return put_user(val, (uint32_t __user *) arg);
3887}
3888
ed8d02d6
JD		 3889static long lttng_stream_ring_buffer_ioctl(struct file *filp,
3890 unsigned int cmd, unsigned long arg)
3891{
e20c0fec 3892 struct lttng_kernel_ring_buffer *buf = filp->private_data;
860c213b 3893 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
e20c0fec 3894 const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
4a399b76 3895 const struct lttng_kernel_channel_buffer_ops *ops = chan->backend.priv_ops;
3b731ab1
JD		 3896 int ret;
3897
3898 if (atomic_read(&chan->record_disabled))
3899 return -EIO;
3900
ed8d02d6 3901 switch (cmd) {
606828e4 3902 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_BEGIN:
3b731ab1
JD		 3903 {
3904 uint64_t ts;
3905
4a399b76 3906 ret = ops->priv->timestamp_begin(config, buf, &ts);
3b731ab1
JD		 3907 if (ret < 0)
3908 goto error;
3909 return put_u64(ts, arg);
3910 }
606828e4 3911 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_TIMESTAMP_END:
3b731ab1
JD		 3912 {
3913 uint64_t ts;
3914
4a399b76 3915 ret = ops->priv->timestamp_end(config, buf, &ts);
3b731ab1
JD		 3916 if (ret < 0)
3917 goto error;
3918 return put_u64(ts, arg);
3919 }
606828e4 3920 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_EVENTS_DISCARDED:
3b731ab1
JD		 3921 {
3922 uint64_t ed;
3923
4a399b76 3924 ret = ops->priv->events_discarded(config, buf, &ed);
3b731ab1
JD		 3925 if (ret < 0)
3926 goto error;
3927 return put_u64(ed, arg);
3928 }
606828e4 3929 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CONTENT_SIZE:
3b731ab1
JD		 3930 {
3931 uint64_t cs;
3932
4a399b76 3933 ret = ops->priv->content_size(config, buf, &cs);
3b731ab1
JD		 3934 if (ret < 0)
3935 goto error;
3936 return put_u64(cs, arg);
3937 }
606828e4 3938 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_PACKET_SIZE:
3b731ab1
JD		 3939 {
3940 uint64_t ps;
3941
4a399b76 3942 ret = ops->priv->packet_size(config, buf, &ps);
3b731ab1
JD		 3943 if (ret < 0)
3944 goto error;
3945 return put_u64(ps, arg);
3946 }
606828e4 3947 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_STREAM_ID:
3b731ab1
JD		 3948 {
3949 uint64_t si;
3950
4a399b76 3951 ret = ops->priv->stream_id(config, buf, &si);
3b731ab1
JD		 3952 if (ret < 0)
3953 goto error;
3954 return put_u64(si, arg);
3955 }
606828e4 3956 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP:
2348ca17
JD		 3957 {
3958 uint64_t ts;
3959
4a399b76 3960 ret = ops->priv->current_timestamp(config, buf, &ts);
2348ca17
JD		 3961 if (ret < 0)
3962 goto error;
3963 return put_u64(ts, arg);
3964 }
606828e4 3965 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_SEQ_NUM:
5b3cf4f9
JD		 3966 {
3967 uint64_t seq;
3968
4a399b76 3969 ret = ops->priv->sequence_number(config, buf, &seq);
5b3cf4f9
JD		 3970 if (ret < 0)
3971 goto error;
3972 return put_u64(seq, arg);
3973 }
606828e4 3974 case LTTNG_KERNEL_ABI_RING_BUFFER_INSTANCE_ID:
5594698f
JD		 3975 {
3976 uint64_t id;
3977
4a399b76 3978 ret = ops->priv->instance_id(config, buf, &id);
5594698f
JD		 3979 if (ret < 0)
3980 goto error;
3981 return put_u64(id, arg);
3982 }
3b731ab1
JD		 3983 default:
3984 return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
3985 cmd, arg);
ed8d02d6 3986 }
3b731ab1
JD		 3987
3988error:
3989 return -ENOSYS;
ed8d02d6
JD		 3990}
3991
3992#ifdef CONFIG_COMPAT
3993static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp,
3994 unsigned int cmd, unsigned long arg)
3995{
e20c0fec 3996 struct lttng_kernel_ring_buffer *buf = filp->private_data;
860c213b 3997 struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
e20c0fec 3998 const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
4a399b76 3999 const struct lttng_kernel_channel_buffer_ops *ops = chan->backend.priv_ops;
3b731ab1
JD		 4000 int ret;
4001
4002 if (atomic_read(&chan->record_disabled))
4003 return -EIO;
4004
ed8d02d6 4005 switch (cmd) {
606828e4 4006 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN:
3b731ab1
JD		 4007 {
4008 uint64_t ts;
4009
4a399b76 4010 ret = ops->priv->timestamp_begin(config, buf, &ts);
3b731ab1
JD		 4011 if (ret < 0)
4012 goto error;
4013 return put_u64(ts, arg);
4014 }
606828e4 4015 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_TIMESTAMP_END:
3b731ab1
JD		 4016 {
4017 uint64_t ts;
4018
4a399b76 4019 ret = ops->priv->timestamp_end(config, buf, &ts);
3b731ab1
JD		 4020 if (ret < 0)
4021 goto error;
4022 return put_u64(ts, arg);
4023 }
606828e4 4024 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED:
3b731ab1
JD		 4025 {
4026 uint64_t ed;
4027
4a399b76 4028 ret = ops->priv->events_discarded(config, buf, &ed);
3b731ab1
JD		 4029 if (ret < 0)
4030 goto error;
4031 return put_u64(ed, arg);
ed8d02d6 4032 }
606828e4 4033 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_CONTENT_SIZE:
3b731ab1
JD		 4034 {
4035 uint64_t cs;
4036
4a399b76 4037 ret = ops->priv->content_size(config, buf, &cs);
3b731ab1
JD		 4038 if (ret < 0)
4039 goto error;
4040 return put_u64(cs, arg);
4041 }
606828e4 4042 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_PACKET_SIZE:
3b731ab1
JD		 4043 {
4044 uint64_t ps;
4045
4a399b76 4046 ret = ops->priv->packet_size(config, buf, &ps);
3b731ab1
JD		 4047 if (ret < 0)
4048 goto error;
4049 return put_u64(ps, arg);
4050 }
606828e4 4051 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_STREAM_ID:
3b731ab1
JD		 4052 {
4053 uint64_t si;
4054
4a399b76 4055 ret = ops->priv->stream_id(config, buf, &si);
3b731ab1
JD		 4056 if (ret < 0)
4057 goto error;
4058 return put_u64(si, arg);
4059 }
606828e4 4060 case LTTNG_KERNEL_ABI_RING_BUFFER_GET_CURRENT_TIMESTAMP:
2348ca17
JD		 4061 {
4062 uint64_t ts;
4063
4a399b76 4064 ret = ops->priv->current_timestamp(config, buf, &ts);
2348ca17
JD		 4065 if (ret < 0)
4066 goto error;
4067 return put_u64(ts, arg);
4068 }
606828e4 4069 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_GET_SEQ_NUM:
5b3cf4f9
JD		 4070 {
4071 uint64_t seq;
4072
4a399b76 4073 ret = ops->priv->sequence_number(config, buf, &seq);
5b3cf4f9
JD		 4074 if (ret < 0)
4075 goto error;
4076 return put_u64(seq, arg);
4077 }
606828e4 4078 case LTTNG_KERNEL_ABI_RING_BUFFER_COMPAT_INSTANCE_ID:
5594698f
JD		 4079 {
4080 uint64_t id;
4081
4a399b76 4082 ret = ops->priv->instance_id(config, buf, &id);
5594698f
JD		 4083 if (ret < 0)
4084 goto error;
4085 return put_u64(id, arg);
4086 }
3b731ab1
JD		 4087 default:
4088 return lib_ring_buffer_file_operations.compat_ioctl(filp,
4089 cmd, arg);
4090 }
4091
4092error:
4093 return -ENOSYS;
ed8d02d6
JD		 4094}
4095#endif /* CONFIG_COMPAT */
4096
4097static void lttng_stream_override_ring_buffer_fops(void)
4098{
4099 lttng_stream_ring_buffer_file_operations.owner = THIS_MODULE;
4100 lttng_stream_ring_buffer_file_operations.open =
4101 lib_ring_buffer_file_operations.open;
4102 lttng_stream_ring_buffer_file_operations.release =
4103 lib_ring_buffer_file_operations.release;
4104 lttng_stream_ring_buffer_file_operations.poll =
4105 lib_ring_buffer_file_operations.poll;
4106 lttng_stream_ring_buffer_file_operations.splice_read =
4107 lib_ring_buffer_file_operations.splice_read;
4108 lttng_stream_ring_buffer_file_operations.mmap =
4109 lib_ring_buffer_file_operations.mmap;
4110 lttng_stream_ring_buffer_file_operations.unlocked_ioctl =
4111 lttng_stream_ring_buffer_ioctl;
4112 lttng_stream_ring_buffer_file_operations.llseek =
4113 lib_ring_buffer_file_operations.llseek;
4114#ifdef CONFIG_COMPAT
4115 lttng_stream_ring_buffer_file_operations.compat_ioctl =
4116 lttng_stream_ring_buffer_compat_ioctl;
4117#endif
4118}
4119
80996790 4120int __init lttng_abi_init(void)
baf20995
MD		 4121{
4122 int ret = 0;
4123
263b6c88 4124 wrapper_vmalloc_sync_mappings();
2754583e 4125 lttng_clock_ref();
f771eda6
JD		 4126
4127 ret = lttng_tp_mempool_init();
4128 if (ret) {
4129 goto error;
4130 }
4131
d29348f7 4132 lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
059de147 4133 &lttng_proc_ops, NULL);
2470a237 4134
255e52a4 4135 if (!lttng_proc_dentry) {
5a15f70c 4136 printk(KERN_ERR "LTTng: Error creating control file\n");
baf20995
MD		 4137 ret = -ENOMEM;
4138 goto error;
4139 }
ed8d02d6 4140 lttng_stream_override_ring_buffer_fops();
2754583e 4141 return 0;
ed8d02d6 4142
baf20995 4143error:
f771eda6 4144 lttng_tp_mempool_destroy();
2754583e 4145 lttng_clock_unref();
baf20995
MD		 4146 return ret;
4147}
4148
e6e65fcd
MD		 4149/* No __exit annotation because used by init error path too. */
4150void lttng_abi_exit(void)
baf20995 4151{
f771eda6 4152 lttng_tp_mempool_destroy();
2754583e 4153 lttng_clock_unref();
e6a17f26
MD		 4154 if (lttng_proc_dentry)
4155 remove_proc_entry("lttng", NULL);
baf20995 4156}
LTTng 2.0/0.x modules
This page took 0.291672 seconds and 4 git commands to generate.