Validate match of all session channel's UUID
[lttng-ust.git] / liblttng-ust / lttng-ust-abi.c
CommitLineData
f4681817 1/*
c0c0989a 2 * SPDX-License-Identifier: LGPL-2.1-only
f4681817 3 *
e92f3e28
MD
4 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
c0c0989a 6 * LTTng UST ABI
e92f3e28 7 *
f4681817
MD
8 * Mimic system calls for:
9 * - session creation, returns an object descriptor or failure.
10 * - channel creation, returns an object descriptor or failure.
11 * - Operates on a session object descriptor
12 * - Takes all channel options as parameters.
13 * - stream get, returns an object descriptor or failure.
14 * - Operates on a channel object descriptor.
15 * - stream notifier get, returns an object descriptor or failure.
16 * - Operates on a channel object descriptor.
17 * - event creation, returns an object descriptor or failure.
18 * - Operates on a channel object descriptor
19 * - Takes an event name as parameter
20 * - Takes an instrumentation source as parameter
21 * - e.g. tracepoints, dynamic_probes...
22 * - Takes instrumentation source specific arguments.
f4681817
MD
23 */
24
3fbec7dc 25#define _LGPL_SOURCE
d8d2416d 26#include <fcntl.h>
fb31eb73 27#include <stdint.h>
4e79769f 28#include <unistd.h>
fb31eb73 29
f4681817
MD
30#include <urcu/compiler.h>
31#include <urcu/list.h>
fb31eb73 32
fb31eb73
FD
33#include <lttng/tracepoint.h>
34#include <lttng/ust-abi.h>
35#include <lttng/ust-error.h>
4318ae1b 36#include <lttng/ust-events.h>
23c8854a 37#include <lttng/ust-version.h>
6548fca4 38#include <ust-fd.h>
44c72f10 39#include <usterr-signal-safe.h>
fb31eb73
FD
40
41#include "../libringbuffer/frontend_types.h"
42#include "../libringbuffer/shm.h"
ebabbf58 43#include "../libcounter/counter.h"
10544ee8 44#include "tracepoint-internal.h"
7dd08bec 45#include "lttng-tracer.h"
196ec2df 46#include "string-utils.h"
d871c65b 47#include "ust-events-internal.h"
fc80554e 48#include "context-internal.h"
ddabe860 49#include "ust-helper.h"
4ab44fbe 50
7047f3da
MD
51#define OBJ_NAME_LEN 16
52
45e9e699
MD
53static int lttng_ust_abi_close_in_progress;
54
51489cad 55static
f59ed768 56int lttng_abi_tracepoint_list(void *owner);
06d4f27e 57static
f59ed768 58int lttng_abi_tracepoint_field_list(void *owner);
51489cad 59
f4681817
MD
60/*
61 * Object descriptor table. Should be protected from concurrent access
62 * by the caller.
63 */
64
fd17d7ce 65struct lttng_ust_abi_obj {
f4681817
MD
66 union {
67 struct {
68 void *private_data;
fd17d7ce 69 const struct lttng_ust_abi_objd_ops *ops;
f4681817 70 int f_count;
1849ef7c 71 int owner_ref; /* has ref from owner */
f59ed768 72 void *owner;
7047f3da 73 char name[OBJ_NAME_LEN];
f4681817
MD
74 } s;
75 int freelist_next; /* offset freelist. end is -1. */
76 } u;
77};
78
fd17d7ce
MD
79struct lttng_ust_abi_objd_table {
80 struct lttng_ust_abi_obj *array;
f4681817
MD
81 unsigned int len, allocated_len;
82 int freelist_head; /* offset freelist head. end is -1 */
83};
84
fd17d7ce 85static struct lttng_ust_abi_objd_table objd_table = {
f4681817
MD
86 .freelist_head = -1,
87};
88
89static
fd17d7ce 90int objd_alloc(void *private_data, const struct lttng_ust_abi_objd_ops *ops,
7047f3da 91 void *owner, const char *name)
f4681817 92{
fd17d7ce 93 struct lttng_ust_abi_obj *obj;
f4681817
MD
94
95 if (objd_table.freelist_head != -1) {
96 obj = &objd_table.array[objd_table.freelist_head];
97 objd_table.freelist_head = obj->u.freelist_next;
98 goto end;
99 }
100
101 if (objd_table.len >= objd_table.allocated_len) {
102 unsigned int new_allocated_len, old_allocated_len;
fd17d7ce 103 struct lttng_ust_abi_obj *new_table, *old_table;
f4681817
MD
104
105 old_allocated_len = objd_table.allocated_len;
106 old_table = objd_table.array;
107 if (!old_allocated_len)
108 new_allocated_len = 1;
109 else
110 new_allocated_len = old_allocated_len << 1;
fd17d7ce 111 new_table = zmalloc(sizeof(struct lttng_ust_abi_obj) * new_allocated_len);
f4681817
MD
112 if (!new_table)
113 return -ENOMEM;
114 memcpy(new_table, old_table,
fd17d7ce 115 sizeof(struct lttng_ust_abi_obj) * old_allocated_len);
f4681817
MD
116 free(old_table);
117 objd_table.array = new_table;
118 objd_table.allocated_len = new_allocated_len;
119 }
120 obj = &objd_table.array[objd_table.len];
121 objd_table.len++;
122end:
123 obj->u.s.private_data = private_data;
124 obj->u.s.ops = ops;
a4be8962
MD
125 obj->u.s.f_count = 2; /* count == 1 : object is allocated */
126 /* count == 2 : allocated + hold ref */
1849ef7c 127 obj->u.s.owner_ref = 1; /* One owner reference */
f59ed768 128 obj->u.s.owner = owner;
7047f3da
MD
129 strncpy(obj->u.s.name, name, OBJ_NAME_LEN);
130 obj->u.s.name[OBJ_NAME_LEN - 1] = '\0';
f4681817
MD
131 return obj - objd_table.array;
132}
133
134static
fd17d7ce 135struct lttng_ust_abi_obj *_objd_get(int id)
f4681817
MD
136{
137 if (id >= objd_table.len)
138 return NULL;
a4be8962
MD
139 if (!objd_table.array[id].u.s.f_count)
140 return NULL;
f4681817
MD
141 return &objd_table.array[id];
142}
143
144static
145void *objd_private(int id)
146{
fd17d7ce 147 struct lttng_ust_abi_obj *obj = _objd_get(id);
f4681817
MD
148 assert(obj);
149 return obj->u.s.private_data;
150}
151
152static
153void objd_set_private(int id, void *private_data)
154{
fd17d7ce 155 struct lttng_ust_abi_obj *obj = _objd_get(id);
f4681817
MD
156 assert(obj);
157 obj->u.s.private_data = private_data;
158}
159
fd17d7ce 160const struct lttng_ust_abi_objd_ops *lttng_ust_abi_objd_ops(int id)
f4681817 161{
fd17d7ce 162 struct lttng_ust_abi_obj *obj = _objd_get(id);
46050b1a 163
a4be8962
MD
164 if (!obj)
165 return NULL;
f4681817
MD
166 return obj->u.s.ops;
167}
168
169static
170void objd_free(int id)
171{
fd17d7ce 172 struct lttng_ust_abi_obj *obj = _objd_get(id);
f4681817
MD
173
174 assert(obj);
175 obj->u.freelist_next = objd_table.freelist_head;
176 objd_table.freelist_head = obj - objd_table.array;
a4be8962
MD
177 assert(obj->u.s.f_count == 1);
178 obj->u.s.f_count = 0; /* deallocated */
f4681817
MD
179}
180
181static
182void objd_ref(int id)
183{
fd17d7ce 184 struct lttng_ust_abi_obj *obj = _objd_get(id);
072886c4 185 assert(obj != NULL);
f4681817
MD
186 obj->u.s.f_count++;
187}
188
fd17d7ce 189int lttng_ust_abi_objd_unref(int id, int is_owner)
f4681817 190{
fd17d7ce 191 struct lttng_ust_abi_obj *obj = _objd_get(id);
f4681817 192
1ea11eab
MD
193 if (!obj)
194 return -EINVAL;
a4be8962
MD
195 if (obj->u.s.f_count == 1) {
196 ERR("Reference counting error\n");
197 return -EINVAL;
198 }
1849ef7c
MD
199 if (is_owner) {
200 if (!obj->u.s.owner_ref) {
201 ERR("Error decrementing owner reference");
202 return -EINVAL;
203 }
204 obj->u.s.owner_ref--;
205 }
a4be8962 206 if ((--obj->u.s.f_count) == 1) {
fd17d7ce 207 const struct lttng_ust_abi_objd_ops *ops = lttng_ust_abi_objd_ops(id);
196ec2df 208
f4681817
MD
209 if (ops->release)
210 ops->release(id);
211 objd_free(id);
212 }
1ea11eab 213 return 0;
f4681817
MD
214}
215
216static
217void objd_table_destroy(void)
218{
a4be8962
MD
219 int i;
220
1849ef7c 221 for (i = 0; i < objd_table.allocated_len; i++) {
fd17d7ce 222 struct lttng_ust_abi_obj *obj;
1849ef7c
MD
223
224 obj = _objd_get(i);
225 if (!obj)
226 continue;
227 if (!obj->u.s.owner_ref)
228 continue; /* only unref owner ref. */
fd17d7ce 229 (void) lttng_ust_abi_objd_unref(i, 1);
1849ef7c 230 }
f4681817 231 free(objd_table.array);
02fb3381
MD
232 objd_table.array = NULL;
233 objd_table.len = 0;
234 objd_table.allocated_len = 0;
17dfb34b 235 objd_table.freelist_head = -1;
f4681817
MD
236}
237
74d81a6c
MD
238const char *lttng_ust_obj_get_name(int id)
239{
fd17d7ce 240 struct lttng_ust_abi_obj *obj = _objd_get(id);
74d81a6c
MD
241
242 if (!obj)
243 return NULL;
244 return obj->u.s.name;
245}
246
fd17d7ce 247void lttng_ust_abi_objd_table_owner_cleanup(void *owner)
f59ed768
MD
248{
249 int i;
250
251 for (i = 0; i < objd_table.allocated_len; i++) {
fd17d7ce 252 struct lttng_ust_abi_obj *obj;
f59ed768
MD
253
254 obj = _objd_get(i);
255 if (!obj)
256 continue;
257 if (!obj->u.s.owner)
258 continue; /* skip root handles */
1849ef7c
MD
259 if (!obj->u.s.owner_ref)
260 continue; /* only unref owner ref. */
f59ed768 261 if (obj->u.s.owner == owner)
fd17d7ce 262 (void) lttng_ust_abi_objd_unref(i, 1);
f59ed768
MD
263 }
264}
265
f4681817
MD
266/*
267 * This is LTTng's own personal way to create an ABI for sessiond.
268 * We send commands over a socket.
269 */
270
fd17d7ce
MD
271static const struct lttng_ust_abi_objd_ops lttng_ops;
272static const struct lttng_ust_abi_objd_ops lttng_event_notifier_group_ops;
273static const struct lttng_ust_abi_objd_ops lttng_session_ops;
274static const struct lttng_ust_abi_objd_ops lttng_channel_ops;
275static const struct lttng_ust_abi_objd_ops lttng_event_enabler_ops;
276static const struct lttng_ust_abi_objd_ops lttng_event_notifier_enabler_ops;
277static const struct lttng_ust_abi_objd_ops lttng_tracepoint_list_ops;
278static const struct lttng_ust_abi_objd_ops lttng_tracepoint_field_list_ops;
f4681817 279
46050b1a
MD
280int lttng_abi_create_root_handle(void)
281{
282 int root_handle;
283
f59ed768 284 /* root handles have NULL owners */
7047f3da 285 root_handle = objd_alloc(NULL, &lttng_ops, NULL, "root");
46050b1a
MD
286 return root_handle;
287}
288
74d81a6c 289static
e7bc0ef6 290int lttng_is_channel_ready(struct lttng_ust_channel_buffer *lttng_chan)
74d81a6c 291{
5198080d 292 struct lttng_ust_lib_ring_buffer_channel *chan;
74d81a6c
MD
293 unsigned int nr_streams, exp_streams;
294
295 chan = lttng_chan->chan;
296 nr_streams = channel_handle_get_nr_streams(lttng_chan->handle);
297 exp_streams = chan->nr_streams;
298 return nr_streams == exp_streams;
299}
300
818173b9 301static
f59ed768 302int lttng_abi_create_session(void *owner)
f4681817 303{
f69fe5fb 304 struct lttng_ust_session *session;
f4681817
MD
305 int session_objd, ret;
306
7dd08bec 307 session = lttng_session_create();
f4681817
MD
308 if (!session)
309 return -ENOMEM;
7047f3da 310 session_objd = objd_alloc(session, &lttng_session_ops, owner, "session");
f4681817
MD
311 if (session_objd < 0) {
312 ret = session_objd;
313 goto objd_error;
314 }
bdb12629
MD
315 session->priv->objd = session_objd;
316 session->priv->owner = owner;
f4681817
MD
317 return session_objd;
318
319objd_error:
7dd08bec 320 lttng_session_destroy(session);
f4681817
MD
321 return ret;
322}
323
f4681817
MD
324static
325long lttng_abi_tracer_version(int objd,
fd17d7ce 326 struct lttng_ust_abi_tracer_version *v)
f4681817 327{
32ce8569
MD
328 v->major = LTTNG_UST_MAJOR_VERSION;
329 v->minor = LTTNG_UST_MINOR_VERSION;
330 v->patchlevel = LTTNG_UST_PATCHLEVEL_VERSION;
f4681817
MD
331 return 0;
332}
333
d8d2416d 334static
f52e5902 335int lttng_abi_event_notifier_send_fd(void *owner, int *event_notifier_notif_fd)
d8d2416d
FD
336{
337 struct lttng_event_notifier_group *event_notifier_group;
f52e5902 338 int event_notifier_group_objd, ret, fd_flag;
d8d2416d
FD
339
340 event_notifier_group = lttng_event_notifier_group_create();
341 if (!event_notifier_group)
342 return -ENOMEM;
343
344 /*
345 * Set this file descriptor as NON-BLOCKING.
346 */
f52e5902 347 fd_flag = fcntl(*event_notifier_notif_fd, F_GETFL);
d8d2416d
FD
348
349 fd_flag |= O_NONBLOCK;
350
f52e5902 351 ret = fcntl(*event_notifier_notif_fd, F_SETFL, fd_flag);
d8d2416d
FD
352 if (ret) {
353 ret = -errno;
354 goto fd_error;
355 }
356
357 event_notifier_group_objd = objd_alloc(event_notifier_group,
358 &lttng_event_notifier_group_ops, owner, "event_notifier_group");
359 if (event_notifier_group_objd < 0) {
360 ret = event_notifier_group_objd;
361 goto objd_error;
362 }
363
364 event_notifier_group->objd = event_notifier_group_objd;
365 event_notifier_group->owner = owner;
f52e5902
MD
366 event_notifier_group->notification_fd = *event_notifier_notif_fd;
367 /* Object descriptor takes ownership of notification fd. */
368 *event_notifier_notif_fd = -1;
d8d2416d
FD
369
370 return event_notifier_group_objd;
371
372objd_error:
373 lttng_event_notifier_group_destroy(event_notifier_group);
374fd_error:
d8d2416d
FD
375 return ret;
376}
377
f4681817
MD
378static
379long lttng_abi_add_context(int objd,
fd17d7ce
MD
380 struct lttng_ust_abi_context *context_param,
381 union lttng_ust_abi_args *uargs,
f69fe5fb 382 struct lttng_ust_ctx **ctx, struct lttng_ust_session *session)
f4681817 383{
8e696cfa 384 return lttng_attach_context(context_param, uargs, ctx, session);
f4681817
MD
385}
386
387/**
388 * lttng_cmd - lttng control through socket commands
389 *
390 * @objd: the object descriptor
391 * @cmd: the command
392 * @arg: command arg
ef9ff354 393 * @uargs: UST arguments (internal)
f59ed768 394 * @owner: objd owner
f4681817
MD
395 *
396 * This descriptor implements lttng commands:
fd17d7ce 397 * LTTNG_UST_ABI_SESSION
f4681817 398 * Returns a LTTng trace session object descriptor
fd17d7ce 399 * LTTNG_UST_ABI_TRACER_VERSION
f4681817 400 * Returns the LTTng kernel tracer version
fd17d7ce 401 * LTTNG_UST_ABI_TRACEPOINT_LIST
f4681817 402 * Returns a file descriptor listing available tracepoints
fd17d7ce 403 * LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST
06d4f27e 404 * Returns a file descriptor listing available tracepoint fields
fd17d7ce 405 * LTTNG_UST_ABI_WAIT_QUIESCENT
f4681817
MD
406 * Returns after all previously running probes have completed
407 *
408 * The returned session will be deleted when its file descriptor is closed.
409 */
410static
ef9ff354 411long lttng_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 412 union lttng_ust_abi_args *uargs, void *owner)
f4681817
MD
413{
414 switch (cmd) {
fd17d7ce 415 case LTTNG_UST_ABI_SESSION:
f59ed768 416 return lttng_abi_create_session(owner);
fd17d7ce 417 case LTTNG_UST_ABI_TRACER_VERSION:
f4681817 418 return lttng_abi_tracer_version(objd,
fd17d7ce
MD
419 (struct lttng_ust_abi_tracer_version *) arg);
420 case LTTNG_UST_ABI_TRACEPOINT_LIST:
f59ed768 421 return lttng_abi_tracepoint_list(owner);
fd17d7ce 422 case LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST:
f59ed768 423 return lttng_abi_tracepoint_field_list(owner);
fd17d7ce 424 case LTTNG_UST_ABI_WAIT_QUIESCENT:
b653ddc1 425 lttng_ust_urcu_synchronize_rcu();
f4681817 426 return 0;
fd17d7ce 427 case LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE:
d8d2416d 428 return lttng_abi_event_notifier_send_fd(owner,
f52e5902 429 &uargs->event_notifier_handle.event_notifier_notif_fd);
f4681817
MD
430 default:
431 return -EINVAL;
432 }
433}
434
fd17d7ce 435static const struct lttng_ust_abi_objd_ops lttng_ops = {
f4681817
MD
436 .cmd = lttng_cmd,
437};
438
04a351cb 439static
74d81a6c 440int lttng_abi_map_channel(int session_objd,
fd17d7ce
MD
441 struct lttng_ust_abi_channel *ust_chan,
442 union lttng_ust_abi_args *uargs,
74d81a6c 443 void *owner)
f4681817 444{
f69fe5fb 445 struct lttng_ust_session *session = objd_private(session_objd);
f4681817 446 const char *transport_name;
a084756d 447 struct lttng_transport *transport;
74d81a6c 448 const char *chan_name;
f4681817 449 int chan_objd;
74d81a6c 450 struct lttng_ust_shm_handle *channel_handle;
f0fde1c3 451 struct lttng_ust_abi_channel_config *lttng_chan_config;
e7bc0ef6 452 struct lttng_ust_channel_buffer *lttng_chan_buf;
5198080d 453 struct lttng_ust_lib_ring_buffer_channel *chan;
74d81a6c
MD
454 struct lttng_ust_lib_ring_buffer_config *config;
455 void *chan_data;
ff0f5728 456 int wakeup_fd;
74d81a6c
MD
457 uint64_t len;
458 int ret;
fd17d7ce 459 enum lttng_ust_abi_chan_type type;
74d81a6c
MD
460
461 chan_data = uargs->channel.chan_data;
ff0f5728 462 wakeup_fd = uargs->channel.wakeup_fd;
74d81a6c
MD
463 len = ust_chan->len;
464 type = ust_chan->type;
465
466 switch (type) {
fd17d7ce 467 case LTTNG_UST_ABI_CHAN_PER_CPU:
74d81a6c
MD
468 break;
469 default:
ff0f5728
MD
470 ret = -EINVAL;
471 goto invalid;
74d81a6c
MD
472 }
473
bdb12629 474 if (session->priv->been_active) {
74d81a6c
MD
475 ret = -EBUSY;
476 goto active; /* Refuse to add channel to active session */
477 }
f4681817 478
e7bc0ef6
MD
479 lttng_chan_buf = lttng_ust_alloc_channel_buffer();
480 if (!lttng_chan_buf) {
f0fde1c3 481 ret = -ENOMEM;
e7bc0ef6 482 goto lttng_chan_buf_error;
f0fde1c3
MD
483 }
484
ff0f5728 485 channel_handle = channel_handle_create(chan_data, len, wakeup_fd);
74d81a6c
MD
486 if (!channel_handle) {
487 ret = -EINVAL;
488 goto handle_error;
489 }
490
867942fd
MD
491 /* Ownership of chan_data and wakeup_fd taken by channel handle. */
492 uargs->channel.chan_data = NULL;
493 uargs->channel.wakeup_fd = -1;
494
74d81a6c
MD
495 chan = shmp(channel_handle, channel_handle->chan);
496 assert(chan);
03d2d293 497 chan->handle = channel_handle;
74d81a6c 498 config = &chan->backend.config;
f0fde1c3
MD
499 lttng_chan_config = channel_get_private_config(chan);
500 if (!lttng_chan_config) {
74d81a6c
MD
501 ret = -EINVAL;
502 goto alloc_error;
503 }
504
9daacd1a
MD
505 if (lttng_ust_session_uuid_validate(session, lttng_chan_config->uuid)) {
506 ret = -EINVAL;
507 goto uuid_error;
508 }
509
74d81a6c
MD
510 /* Lookup transport name */
511 switch (type) {
fd17d7ce 512 case LTTNG_UST_ABI_CHAN_PER_CPU:
74d81a6c 513 if (config->output == RING_BUFFER_MMAP) {
34a91bdb
MD
514 if (config->mode == RING_BUFFER_OVERWRITE) {
515 if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) {
516 transport_name = "relay-overwrite-mmap";
517 } else {
518 transport_name = "relay-overwrite-rt-mmap";
519 }
520 } else {
521 if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) {
522 transport_name = "relay-discard-mmap";
523 } else {
524 transport_name = "relay-discard-rt-mmap";
525 }
526 }
f4681817 527 } else {
74d81a6c
MD
528 ret = -EINVAL;
529 goto notransport;
f4681817 530 }
74d81a6c 531 chan_name = "channel";
f4681817 532 break;
f4681817 533 default:
74d81a6c
MD
534 ret = -EINVAL;
535 goto notransport;
fe38d4af 536 }
65c48d6a 537 transport = lttng_ust_transport_find(transport_name);
74d81a6c
MD
538 if (!transport) {
539 DBG("LTTng transport %s not found\n",
540 transport_name);
541 ret = -EINVAL;
542 goto notransport;
543 }
544
545 chan_objd = objd_alloc(NULL, &lttng_channel_ops, owner, chan_name);
fe38d4af
MD
546 if (chan_objd < 0) {
547 ret = chan_objd;
548 goto objd_error;
f4681817 549 }
74d81a6c
MD
550
551 /* Initialize our lttng chan */
e7bc0ef6
MD
552 lttng_chan_buf->parent->enabled = 1;
553 lttng_chan_buf->parent->session = session;
554
555 lttng_chan_buf->priv->parent.tstate = 1;
0950190a 556 lttng_chan_buf->priv->ctx = NULL;
e7bc0ef6 557
e7bc0ef6
MD
558 lttng_chan_buf->ops = &transport->ops;
559 lttng_chan_buf->chan = chan;
560 lttng_chan_buf->handle = channel_handle;
561
562 memcpy(&chan->backend.config,
74d81a6c 563 transport->client_config,
e7bc0ef6
MD
564 sizeof(chan->backend.config));
565 cds_list_add(&lttng_chan_buf->priv->node, &session->priv->chan_head);
566 lttng_chan_buf->priv->header_type = 0;
567 lttng_chan_buf->priv->type = type;
f0fde1c3 568 /* Copy fields from lttng ust chan config. */
e7bc0ef6
MD
569 lttng_chan_buf->priv->id = lttng_chan_config->id;
570 memcpy(lttng_chan_buf->priv->uuid, lttng_chan_config->uuid, LTTNG_UST_UUID_LEN);
571 channel_set_private(chan, lttng_chan_buf);
74d81a6c 572
f4681817
MD
573 /*
574 * We tolerate no failure path after channel creation. It will stay
575 * invariant for the rest of the session.
576 */
e7bc0ef6
MD
577 objd_set_private(chan_objd, lttng_chan_buf);
578 lttng_chan_buf->priv->parent.objd = chan_objd;
f4681817
MD
579 /* The channel created holds a reference on the session */
580 objd_ref(session_objd);
f4681817
MD
581 return chan_objd;
582
ff0f5728 583 /* error path after channel was created */
f4681817 584objd_error:
74d81a6c 585notransport:
9daacd1a 586uuid_error:
74d81a6c
MD
587alloc_error:
588 channel_destroy(chan, channel_handle, 0);
e7bc0ef6 589 lttng_ust_free_channel_common(lttng_chan_buf->parent);
ff0f5728
MD
590 return ret;
591
74d81a6c 592handle_error:
e7bc0ef6
MD
593 lttng_ust_free_channel_common(lttng_chan_buf->parent);
594lttng_chan_buf_error:
74d81a6c 595active:
ff0f5728 596invalid:
f4681817
MD
597 return ret;
598}
599
600/**
601 * lttng_session_cmd - lttng session object command
602 *
603 * @obj: the object
604 * @cmd: the command
605 * @arg: command arg
ef9ff354 606 * @uargs: UST arguments (internal)
f59ed768 607 * @owner: objd owner
f4681817
MD
608 *
609 * This descriptor implements lttng commands:
fd17d7ce 610 * LTTNG_UST_ABI_CHANNEL
f4681817 611 * Returns a LTTng channel object descriptor
fd17d7ce 612 * LTTNG_UST_ABI_ENABLE
f4681817 613 * Enables tracing for a session (weak enable)
fd17d7ce 614 * LTTNG_UST_ABI_DISABLE
f4681817 615 * Disables tracing for a session (strong disable)
f4681817
MD
616 *
617 * The returned channel will be deleted when its file descriptor is closed.
618 */
619static
ef9ff354 620long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 621 union lttng_ust_abi_args *uargs, void *owner)
f4681817 622{
f69fe5fb 623 struct lttng_ust_session *session = objd_private(objd);
f4681817
MD
624
625 switch (cmd) {
fd17d7ce 626 case LTTNG_UST_ABI_CHANNEL:
74d81a6c 627 return lttng_abi_map_channel(objd,
fd17d7ce 628 (struct lttng_ust_abi_channel *) arg,
74d81a6c 629 uargs, owner);
fd17d7ce
MD
630 case LTTNG_UST_ABI_SESSION_START:
631 case LTTNG_UST_ABI_ENABLE:
7dd08bec 632 return lttng_session_enable(session);
fd17d7ce
MD
633 case LTTNG_UST_ABI_SESSION_STOP:
634 case LTTNG_UST_ABI_DISABLE:
7dd08bec 635 return lttng_session_disable(session);
fd17d7ce 636 case LTTNG_UST_ABI_SESSION_STATEDUMP:
710b8ee3 637 return lttng_session_statedump(session);
fd17d7ce
MD
638 case LTTNG_UST_ABI_COUNTER:
639 case LTTNG_UST_ABI_COUNTER_GLOBAL:
640 case LTTNG_UST_ABI_COUNTER_CPU:
ebabbf58
MD
641 /* Not implemented yet. */
642 return -EINVAL;
f4681817
MD
643 default:
644 return -EINVAL;
645 }
646}
647
648/*
649 * Called when the last file reference is dropped.
650 *
651 * Big fat note: channels and events are invariant for the whole session after
652 * their creation. So this session destruction also destroys all channel and
653 * event structures specific to this session (they are not destroyed when their
654 * individual file is released).
655 */
656static
1ea11eab 657int lttng_release_session(int objd)
f4681817 658{
f69fe5fb 659 struct lttng_ust_session *session = objd_private(objd);
f4681817 660
1ea11eab 661 if (session) {
7dd08bec 662 lttng_session_destroy(session);
1ea11eab
MD
663 return 0;
664 } else {
665 return -EINVAL;
666 }
f4681817
MD
667}
668
fd17d7ce 669static const struct lttng_ust_abi_objd_ops lttng_session_ops = {
1ea11eab 670 .release = lttng_release_session,
f4681817
MD
671 .cmd = lttng_session_cmd,
672};
673
d8d2416d 674static int lttng_ust_event_notifier_enabler_create(int event_notifier_group_obj,
fd17d7ce 675 void *owner, struct lttng_ust_abi_event_notifier *event_notifier_param,
d8d2416d
FD
676 enum lttng_enabler_format_type type)
677{
678 struct lttng_event_notifier_group *event_notifier_group =
679 objd_private(event_notifier_group_obj);
680 struct lttng_event_notifier_enabler *event_notifier_enabler;
681 int event_notifier_objd, ret;
682
fd17d7ce 683 event_notifier_param->event.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
d8d2416d
FD
684 event_notifier_objd = objd_alloc(NULL, &lttng_event_notifier_enabler_ops, owner,
685 "event_notifier enabler");
686 if (event_notifier_objd < 0) {
687 ret = event_notifier_objd;
688 goto objd_error;
689 }
690
691 event_notifier_enabler = lttng_event_notifier_enabler_create(
692 event_notifier_group, type, event_notifier_param);
693 if (!event_notifier_enabler) {
694 ret = -ENOMEM;
695 goto event_notifier_error;
696 }
697
698 objd_set_private(event_notifier_objd, event_notifier_enabler);
699 /* The event_notifier holds a reference on the event_notifier group. */
700 objd_ref(event_notifier_enabler->group->objd);
701
702 return event_notifier_objd;
703
704event_notifier_error:
705 {
706 int err;
707
fd17d7ce 708 err = lttng_ust_abi_objd_unref(event_notifier_objd, 1);
d8d2416d
FD
709 assert(!err);
710 }
711objd_error:
712 return ret;
713}
714
715static
716long lttng_event_notifier_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 717 union lttng_ust_abi_args *uargs, void *owner)
d8d2416d
FD
718{
719 struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd);
720 switch (cmd) {
fd17d7ce 721 case LTTNG_UST_ABI_FILTER:
a56fd376
FD
722 return lttng_event_notifier_enabler_attach_filter_bytecode(
723 event_notifier_enabler,
ab89263e 724 (struct lttng_ust_bytecode_node **) arg);
fd17d7ce 725 case LTTNG_UST_ABI_EXCLUSION:
d8d2416d 726 return lttng_event_notifier_enabler_attach_exclusion(event_notifier_enabler,
e9fe6aad 727 (struct lttng_ust_excluder_node **) arg);
fd17d7ce 728 case LTTNG_UST_ABI_CAPTURE:
d37ecb3f
FD
729 return lttng_event_notifier_enabler_attach_capture_bytecode(
730 event_notifier_enabler,
49cde654 731 (struct lttng_ust_bytecode_node **) arg);
fd17d7ce 732 case LTTNG_UST_ABI_ENABLE:
d8d2416d 733 return lttng_event_notifier_enabler_enable(event_notifier_enabler);
fd17d7ce 734 case LTTNG_UST_ABI_DISABLE:
d8d2416d
FD
735 return lttng_event_notifier_enabler_disable(event_notifier_enabler);
736 default:
737 return -EINVAL;
738 }
739}
740
ebabbf58
MD
741/**
742 * lttng_event_notifier_group_error_counter_cmd - lttng event_notifier group error counter object command
743 *
744 * @obj: the object
745 * @cmd: the command
746 * @arg: command arg
747 * @uargs: UST arguments (internal)
748 * @owner: objd owner
749 *
750 * This descriptor implements lttng commands:
fd17d7ce 751 * LTTNG_UST_ABI_COUNTER_GLOBAL
ebabbf58 752 * Return negative error code on error, 0 on success.
fd17d7ce 753 * LTTNG_UST_ABI_COUNTER_CPU
ebabbf58
MD
754 * Return negative error code on error, 0 on success.
755 */
756static
757long lttng_event_notifier_group_error_counter_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 758 union lttng_ust_abi_args *uargs, void *owner)
ebabbf58 759{
ba5b3d2b 760 int ret;
ebabbf58
MD
761 struct lttng_counter *counter = objd_private(objd);
762
763 switch (cmd) {
fd17d7ce 764 case LTTNG_UST_ABI_COUNTER_GLOBAL:
ba5b3d2b
JR
765 ret = -EINVAL; /* Unimplemented. */
766 break;
fd17d7ce 767 case LTTNG_UST_ABI_COUNTER_CPU:
ebabbf58 768 {
fd17d7ce
MD
769 struct lttng_ust_abi_counter_cpu *counter_cpu =
770 (struct lttng_ust_abi_counter_cpu *)arg;
ba5b3d2b
JR
771
772 ret = lttng_counter_set_cpu_shm(counter->counter,
ebabbf58 773 counter_cpu->cpu_nr, uargs->counter_shm.shm_fd);
ba5b3d2b
JR
774 if (!ret) {
775 /* Take ownership of the shm_fd. */
776 uargs->counter_shm.shm_fd = -1;
777 }
778 break;
ebabbf58
MD
779 }
780 default:
ba5b3d2b
JR
781 ret = -EINVAL;
782 break;
ebabbf58 783 }
ba5b3d2b
JR
784
785 return ret;
ebabbf58
MD
786}
787
ddabe860 788__attribute__((visibility("hidden")))
ebabbf58
MD
789int lttng_release_event_notifier_group_error_counter(int objd)
790{
791 struct lttng_counter *counter = objd_private(objd);
792
793 if (counter) {
fd17d7ce 794 return lttng_ust_abi_objd_unref(counter->event_notifier_group->objd, 0);
ebabbf58
MD
795 } else {
796 return -EINVAL;
797 }
798}
799
fd17d7ce 800static const struct lttng_ust_abi_objd_ops lttng_event_notifier_group_error_counter_ops = {
ebabbf58
MD
801 .release = lttng_release_event_notifier_group_error_counter,
802 .cmd = lttng_event_notifier_group_error_counter_cmd,
803};
804
805static
806int lttng_ust_event_notifier_group_create_error_counter(int event_notifier_group_objd, void *owner,
fd17d7ce 807 struct lttng_ust_abi_counter_conf *error_counter_conf)
ebabbf58
MD
808{
809 const char *counter_transport_name;
810 struct lttng_event_notifier_group *event_notifier_group =
811 objd_private(event_notifier_group_objd);
812 struct lttng_counter *counter;
813 int counter_objd, ret;
814 struct lttng_counter_dimension dimensions[1];
815 size_t counter_len;
816
817 if (event_notifier_group->error_counter)
818 return -EBUSY;
819
fd17d7ce 820 if (error_counter_conf->arithmetic != LTTNG_UST_ABI_COUNTER_ARITHMETIC_MODULAR)
ebabbf58
MD
821 return -EINVAL;
822
823 if (error_counter_conf->number_dimensions != 1)
824 return -EINVAL;
825
826 switch (error_counter_conf->bitness) {
fd17d7ce 827 case LTTNG_UST_ABI_COUNTER_BITNESS_64:
ebabbf58
MD
828 counter_transport_name = "counter-per-cpu-64-modular";
829 break;
fd17d7ce 830 case LTTNG_UST_ABI_COUNTER_BITNESS_32:
ebabbf58
MD
831 counter_transport_name = "counter-per-cpu-32-modular";
832 break;
833 default:
834 return -EINVAL;
835 }
836
837 counter_objd = objd_alloc(NULL, &lttng_event_notifier_group_error_counter_ops, owner,
838 "event_notifier group error counter");
839 if (counter_objd < 0) {
840 ret = counter_objd;
841 goto objd_error;
842 }
843
844 counter_len = error_counter_conf->dimensions[0].size;
845 dimensions[0].size = counter_len;
846 dimensions[0].underflow_index = 0;
847 dimensions[0].overflow_index = 0;
848 dimensions[0].has_underflow = 0;
849 dimensions[0].has_overflow = 0;
850
851 counter = lttng_ust_counter_create(counter_transport_name, 1, dimensions);
852 if (!counter) {
853 ret = -EINVAL;
854 goto create_error;
855 }
856
ebabbf58 857 event_notifier_group->error_counter_len = counter_len;
33f43caa
MD
858 /*
859 * store-release to publish error counter matches load-acquire
860 * in record_error. Ensures the counter is created and the
861 * error_counter_len is set before they are used.
862 * Currently a full memory barrier is used, which could be
863 * turned into acquire-release barriers.
864 */
865 cmm_smp_mb();
866 CMM_STORE_SHARED(event_notifier_group->error_counter, counter);
ebabbf58
MD
867
868 counter->objd = counter_objd;
869 counter->event_notifier_group = event_notifier_group; /* owner */
870
871 objd_set_private(counter_objd, counter);
872 /* The error counter holds a reference on the event_notifier group. */
873 objd_ref(event_notifier_group->objd);
874
875 return counter_objd;
876
877create_error:
878 {
879 int err;
880
fd17d7ce 881 err = lttng_ust_abi_objd_unref(counter_objd, 1);
ebabbf58
MD
882 assert(!err);
883 }
884objd_error:
885 return ret;
886}
887
d8d2416d
FD
888static
889long lttng_event_notifier_group_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 890 union lttng_ust_abi_args *uargs, void *owner)
d8d2416d
FD
891{
892 switch (cmd) {
fd17d7ce 893 case LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE:
d8d2416d 894 {
fd17d7ce
MD
895 struct lttng_ust_abi_event_notifier *event_notifier_param =
896 (struct lttng_ust_abi_event_notifier *) arg;
d8d2416d
FD
897 if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) {
898 /*
899 * If the event name is a star globbing pattern,
900 * we create the special star globbing enabler.
901 */
902 return lttng_ust_event_notifier_enabler_create(objd,
903 owner, event_notifier_param,
904 LTTNG_ENABLER_FORMAT_STAR_GLOB);
905 } else {
906 return lttng_ust_event_notifier_enabler_create(objd,
907 owner, event_notifier_param,
908 LTTNG_ENABLER_FORMAT_EVENT);
909 }
910 }
fd17d7ce 911 case LTTNG_UST_ABI_COUNTER:
ebabbf58 912 {
fd17d7ce
MD
913 struct lttng_ust_abi_counter_conf *counter_conf =
914 (struct lttng_ust_abi_counter_conf *) uargs->counter.counter_data;
ebabbf58
MD
915 return lttng_ust_event_notifier_group_create_error_counter(
916 objd, owner, counter_conf);
917 }
d8d2416d
FD
918 default:
919 return -EINVAL;
920 }
921}
922
923static
924int lttng_event_notifier_enabler_release(int objd)
925{
926 struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd);
927
928 if (event_notifier_enabler)
fd17d7ce 929 return lttng_ust_abi_objd_unref(event_notifier_enabler->group->objd, 0);
d8d2416d
FD
930 return 0;
931}
932
fd17d7ce 933static const struct lttng_ust_abi_objd_ops lttng_event_notifier_enabler_ops = {
d8d2416d
FD
934 .release = lttng_event_notifier_enabler_release,
935 .cmd = lttng_event_notifier_enabler_cmd,
936};
937
938static
939int lttng_release_event_notifier_group(int objd)
940{
941 struct lttng_event_notifier_group *event_notifier_group = objd_private(objd);
942
943 if (event_notifier_group) {
944 lttng_event_notifier_group_destroy(event_notifier_group);
945 return 0;
946 } else {
947 return -EINVAL;
948 }
949}
950
fd17d7ce 951static const struct lttng_ust_abi_objd_ops lttng_event_notifier_group_ops = {
d8d2416d
FD
952 .release = lttng_release_event_notifier_group,
953 .cmd = lttng_event_notifier_group_cmd,
954};
955
51489cad 956static
ef9ff354 957long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 958 union lttng_ust_abi_args *uargs, void *owner)
51489cad 959{
c8fcf224 960 struct lttng_ust_tracepoint_list *list = objd_private(objd);
fd17d7ce
MD
961 struct lttng_ust_abi_tracepoint_iter *tp =
962 (struct lttng_ust_abi_tracepoint_iter *) arg;
963 struct lttng_ust_abi_tracepoint_iter *iter;
51489cad
MD
964
965 switch (cmd) {
fd17d7ce 966 case LTTNG_UST_ABI_TRACEPOINT_LIST_GET:
c8fcf224 967 {
c8fcf224
MD
968 iter = lttng_ust_tracepoint_list_get_iter_next(list);
969 if (!iter)
7bc53e94 970 return -LTTNG_UST_ERR_NOENT;
c8fcf224 971 memcpy(tp, iter, sizeof(*tp));
51489cad 972 return 0;
c8fcf224 973 }
51489cad
MD
974 default:
975 return -EINVAL;
976 }
977}
978
979static
f59ed768 980int lttng_abi_tracepoint_list(void *owner)
51489cad
MD
981{
982 int list_objd, ret;
c8fcf224 983 struct lttng_ust_tracepoint_list *list;
51489cad 984
7047f3da 985 list_objd = objd_alloc(NULL, &lttng_tracepoint_list_ops, owner, "tp_list");
51489cad
MD
986 if (list_objd < 0) {
987 ret = list_objd;
988 goto objd_error;
989 }
990 list = zmalloc(sizeof(*list));
991 if (!list) {
992 ret = -ENOMEM;
993 goto alloc_error;
994 }
995 objd_set_private(list_objd, list);
996
c8fcf224 997 /* populate list by walking on all registered probes. */
7dd08bec 998 ret = lttng_probes_get_event_list(list);
c8fcf224
MD
999 if (ret) {
1000 goto list_error;
1001 }
51489cad
MD
1002 return list_objd;
1003
c8fcf224
MD
1004list_error:
1005 free(list);
51489cad
MD
1006alloc_error:
1007 {
1008 int err;
1009
fd17d7ce 1010 err = lttng_ust_abi_objd_unref(list_objd, 1);
51489cad
MD
1011 assert(!err);
1012 }
1013objd_error:
1014 return ret;
1015}
1016
1017static
1018int lttng_release_tracepoint_list(int objd)
1019{
c8fcf224 1020 struct lttng_ust_tracepoint_list *list = objd_private(objd);
51489cad
MD
1021
1022 if (list) {
7dd08bec 1023 lttng_probes_prune_event_list(list);
51489cad
MD
1024 free(list);
1025 return 0;
1026 } else {
1027 return -EINVAL;
1028 }
1029}
1030
fd17d7ce 1031static const struct lttng_ust_abi_objd_ops lttng_tracepoint_list_ops = {
51489cad
MD
1032 .release = lttng_release_tracepoint_list,
1033 .cmd = lttng_tracepoint_list_cmd,
1034};
1035
06d4f27e
MD
1036static
1037long lttng_tracepoint_field_list_cmd(int objd, unsigned int cmd,
fd17d7ce 1038 unsigned long arg, union lttng_ust_abi_args *uargs, void *owner)
06d4f27e
MD
1039{
1040 struct lttng_ust_field_list *list = objd_private(objd);
fd17d7ce
MD
1041 struct lttng_ust_abi_field_iter *tp = &uargs->field_list.entry;
1042 struct lttng_ust_abi_field_iter *iter;
06d4f27e
MD
1043
1044 switch (cmd) {
fd17d7ce 1045 case LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST_GET:
06d4f27e 1046 {
06d4f27e
MD
1047 iter = lttng_ust_field_list_get_iter_next(list);
1048 if (!iter)
7bc53e94 1049 return -LTTNG_UST_ERR_NOENT;
06d4f27e
MD
1050 memcpy(tp, iter, sizeof(*tp));
1051 return 0;
1052 }
1053 default:
1054 return -EINVAL;
1055 }
1056}
1057
1058static
f59ed768 1059int lttng_abi_tracepoint_field_list(void *owner)
06d4f27e
MD
1060{
1061 int list_objd, ret;
1062 struct lttng_ust_field_list *list;
1063
7047f3da
MD
1064 list_objd = objd_alloc(NULL, &lttng_tracepoint_field_list_ops, owner,
1065 "tp_field_list");
06d4f27e
MD
1066 if (list_objd < 0) {
1067 ret = list_objd;
1068 goto objd_error;
1069 }
1070 list = zmalloc(sizeof(*list));
1071 if (!list) {
1072 ret = -ENOMEM;
1073 goto alloc_error;
1074 }
1075 objd_set_private(list_objd, list);
1076
1077 /* populate list by walking on all registered probes. */
7dd08bec 1078 ret = lttng_probes_get_field_list(list);
06d4f27e
MD
1079 if (ret) {
1080 goto list_error;
1081 }
1082 return list_objd;
1083
1084list_error:
1085 free(list);
1086alloc_error:
1087 {
1088 int err;
1089
fd17d7ce 1090 err = lttng_ust_abi_objd_unref(list_objd, 1);
06d4f27e
MD
1091 assert(!err);
1092 }
1093objd_error:
1094 return ret;
1095}
1096
1097static
1098int lttng_release_tracepoint_field_list(int objd)
1099{
1100 struct lttng_ust_field_list *list = objd_private(objd);
1101
1102 if (list) {
7dd08bec 1103 lttng_probes_prune_field_list(list);
06d4f27e
MD
1104 free(list);
1105 return 0;
1106 } else {
1107 return -EINVAL;
1108 }
1109}
1110
fd17d7ce 1111static const struct lttng_ust_abi_objd_ops lttng_tracepoint_field_list_ops = {
06d4f27e
MD
1112 .release = lttng_release_tracepoint_field_list,
1113 .cmd = lttng_tracepoint_field_list_cmd,
1114};
1115
f4681817 1116static
fd17d7ce
MD
1117int lttng_abi_map_stream(int channel_objd, struct lttng_ust_abi_stream *info,
1118 union lttng_ust_abi_args *uargs, void *owner)
f4681817 1119{
e7bc0ef6 1120 struct lttng_ust_channel_buffer *lttng_chan_buf = objd_private(channel_objd);
74d81a6c 1121 int ret;
f4681817 1122
e7bc0ef6 1123 ret = channel_handle_add_stream(lttng_chan_buf->handle,
74d81a6c
MD
1124 uargs->stream.shm_fd, uargs->stream.wakeup_fd,
1125 info->stream_nr, info->len);
1126 if (ret)
1127 goto error_add_stream;
118c051e
MD
1128 /* Take ownership of shm_fd and wakeup_fd. */
1129 uargs->stream.shm_fd = -1;
1130 uargs->stream.wakeup_fd = -1;
74d81a6c
MD
1131
1132 return 0;
1133
1134error_add_stream:
f4681817
MD
1135 return ret;
1136}
f4681817
MD
1137
1138static
d871c65b 1139int lttng_abi_create_event_enabler(int channel_objd,
fd17d7ce 1140 struct lttng_ust_abi_event *event_param,
e58095ef 1141 void *owner,
e450e339 1142 enum lttng_enabler_format_type format_type)
f4681817 1143{
e7bc0ef6 1144 struct lttng_ust_channel_buffer *channel = objd_private(channel_objd);
d871c65b 1145 struct lttng_event_enabler *enabler;
f4681817
MD
1146 int event_objd, ret;
1147
fd17d7ce 1148 event_param->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
d871c65b
FD
1149 event_objd = objd_alloc(NULL, &lttng_event_enabler_ops, owner,
1150 "event enabler");
f4681817
MD
1151 if (event_objd < 0) {
1152 ret = event_objd;
1153 goto objd_error;
1154 }
1155 /*
1156 * We tolerate no failure path after event creation. It will stay
1157 * invariant for the rest of the session.
1158 */
d871c65b 1159 enabler = lttng_event_enabler_create(format_type, event_param, channel);
e58095ef
MD
1160 if (!enabler) {
1161 ret = -ENOMEM;
f4681817
MD
1162 goto event_error;
1163 }
e58095ef 1164 objd_set_private(event_objd, enabler);
f4681817
MD
1165 /* The event holds a reference on the channel */
1166 objd_ref(channel_objd);
1167 return event_objd;
1168
1169event_error:
1ea11eab
MD
1170 {
1171 int err;
1172
fd17d7ce 1173 err = lttng_ust_abi_objd_unref(event_objd, 1);
1ea11eab
MD
1174 assert(!err);
1175 }
f4681817
MD
1176objd_error:
1177 return ret;
1178}
1179
1180/**
1181 * lttng_channel_cmd - lttng control through object descriptors
1182 *
1183 * @objd: the object descriptor
1184 * @cmd: the command
1185 * @arg: command arg
ef9ff354 1186 * @uargs: UST arguments (internal)
f59ed768 1187 * @owner: objd owner
f4681817
MD
1188 *
1189 * This object descriptor implements lttng commands:
fd17d7ce 1190 * LTTNG_UST_ABI_STREAM
f4681817
MD
1191 * Returns an event stream object descriptor or failure.
1192 * (typically, one event stream records events from one CPU)
fd17d7ce 1193 * LTTNG_UST_ABI_EVENT
f4681817 1194 * Returns an event object descriptor or failure.
fd17d7ce 1195 * LTTNG_UST_ABI_CONTEXT
f4681817 1196 * Prepend a context field to each event in the channel
fd17d7ce 1197 * LTTNG_UST_ABI_ENABLE
f4681817 1198 * Enable recording for events in this channel (weak enable)
fd17d7ce 1199 * LTTNG_UST_ABI_DISABLE
f4681817
MD
1200 * Disable recording for events in this channel (strong disable)
1201 *
1202 * Channel and event file descriptors also hold a reference on the session.
1203 */
1204static
ef9ff354 1205long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 1206 union lttng_ust_abi_args *uargs, void *owner)
f4681817 1207{
e7bc0ef6 1208 struct lttng_ust_channel_buffer *lttng_chan_buf = objd_private(objd);
f4681817 1209
fd17d7ce 1210 if (cmd != LTTNG_UST_ABI_STREAM) {
74d81a6c
MD
1211 /*
1212 * Check if channel received all streams.
1213 */
e7bc0ef6 1214 if (!lttng_is_channel_ready(lttng_chan_buf))
74d81a6c
MD
1215 return -EPERM;
1216 }
1217
f4681817 1218 switch (cmd) {
fd17d7ce 1219 case LTTNG_UST_ABI_STREAM:
381c0f1e 1220 {
fd17d7ce 1221 struct lttng_ust_abi_stream *stream;
381c0f1e 1222
fd17d7ce 1223 stream = (struct lttng_ust_abi_stream *) arg;
381c0f1e 1224 /* stream used as output */
74d81a6c 1225 return lttng_abi_map_stream(objd, stream, uargs, owner);
381c0f1e 1226 }
fd17d7ce 1227 case LTTNG_UST_ABI_EVENT:
1f18504e 1228 {
fd17d7ce
MD
1229 struct lttng_ust_abi_event *event_param =
1230 (struct lttng_ust_abi_event *) arg;
196ec2df
PP
1231
1232 if (strutils_is_star_glob_pattern(event_param->name)) {
1233 /*
1234 * If the event name is a star globbing pattern,
1235 * we create the special star globbing enabler.
1236 */
d871c65b 1237 return lttng_abi_create_event_enabler(objd, event_param,
e450e339 1238 owner, LTTNG_ENABLER_FORMAT_STAR_GLOB);
1f18504e 1239 } else {
d871c65b 1240 return lttng_abi_create_event_enabler(objd, event_param,
e450e339 1241 owner, LTTNG_ENABLER_FORMAT_EVENT);
1f18504e
MD
1242 }
1243 }
fd17d7ce 1244 case LTTNG_UST_ABI_CONTEXT:
f4681817 1245 return lttng_abi_add_context(objd,
fd17d7ce 1246 (struct lttng_ust_abi_context *) arg, uargs,
0950190a 1247 &lttng_chan_buf->priv->ctx,
e7bc0ef6 1248 lttng_chan_buf->parent->session);
fd17d7ce 1249 case LTTNG_UST_ABI_ENABLE:
e7bc0ef6 1250 return lttng_channel_enable(lttng_chan_buf->parent);
fd17d7ce 1251 case LTTNG_UST_ABI_DISABLE:
e7bc0ef6 1252 return lttng_channel_disable(lttng_chan_buf->parent);
fd17d7ce 1253 case LTTNG_UST_ABI_FLUSH_BUFFER:
e7bc0ef6
MD
1254 return lttng_chan_buf->ops->priv->flush_buffer(lttng_chan_buf->chan,
1255 lttng_chan_buf->handle);
f4681817
MD
1256 default:
1257 return -EINVAL;
1258 }
1259}
1260
f4681817
MD
1261static
1262int lttng_channel_release(int objd)
1263{
e7bc0ef6 1264 struct lttng_ust_channel_buffer *lttng_chan_buf = objd_private(objd);
f4681817 1265
e7bc0ef6
MD
1266 if (lttng_chan_buf)
1267 return lttng_ust_abi_objd_unref(lttng_chan_buf->parent->session->priv->objd, 0);
f4681817
MD
1268 return 0;
1269}
1270
fd17d7ce 1271static const struct lttng_ust_abi_objd_ops lttng_channel_ops = {
f4681817 1272 .release = lttng_channel_release,
f4681817
MD
1273 .cmd = lttng_channel_cmd,
1274};
1275
f4681817 1276/**
e58095ef 1277 * lttng_enabler_cmd - lttng control through object descriptors
e6c12e3d
MD
1278 *
1279 * @objd: the object descriptor
1280 * @cmd: the command
1281 * @arg: command arg
ef9ff354 1282 * @uargs: UST arguments (internal)
f59ed768 1283 * @owner: objd owner
e6c12e3d
MD
1284 *
1285 * This object descriptor implements lttng commands:
fd17d7ce 1286 * LTTNG_UST_ABI_CONTEXT
e6c12e3d 1287 * Prepend a context field to each record of events of this
e58095ef 1288 * enabler.
fd17d7ce 1289 * LTTNG_UST_ABI_ENABLE
e58095ef 1290 * Enable recording for this enabler
fd17d7ce 1291 * LTTNG_UST_ABI_DISABLE
e58095ef 1292 * Disable recording for this enabler
fd17d7ce 1293 * LTTNG_UST_ABI_FILTER
e58095ef 1294 * Attach a filter to an enabler.
fd17d7ce 1295 * LTTNG_UST_ABI_EXCLUSION
0bfb5cbd 1296 * Attach exclusions to an enabler.
e6c12e3d
MD
1297 */
1298static
d871c65b 1299long lttng_event_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
fd17d7ce 1300 union lttng_ust_abi_args *uargs, void *owner)
e6c12e3d 1301{
d871c65b 1302 struct lttng_event_enabler *enabler = objd_private(objd);
e6c12e3d
MD
1303
1304 switch (cmd) {
fd17d7ce 1305 case LTTNG_UST_ABI_CONTEXT:
d871c65b 1306 return lttng_event_enabler_attach_context(enabler,
fd17d7ce
MD
1307 (struct lttng_ust_abi_context *) arg);
1308 case LTTNG_UST_ABI_ENABLE:
d871c65b 1309 return lttng_event_enabler_enable(enabler);
fd17d7ce 1310 case LTTNG_UST_ABI_DISABLE:
d871c65b 1311 return lttng_event_enabler_disable(enabler);
fd17d7ce 1312 case LTTNG_UST_ABI_FILTER:
2d78951a
MD
1313 {
1314 int ret;
1315
a56fd376 1316 ret = lttng_event_enabler_attach_filter_bytecode(enabler,
ab89263e 1317 (struct lttng_ust_bytecode_node **) arg);
2d78951a
MD
1318 if (ret)
1319 return ret;
2d78951a
MD
1320 return 0;
1321 }
fd17d7ce 1322 case LTTNG_UST_ABI_EXCLUSION:
0bfb5cbd 1323 {
d871c65b 1324 return lttng_event_enabler_attach_exclusion(enabler,
e9fe6aad 1325 (struct lttng_ust_excluder_node **) arg);
0bfb5cbd 1326 }
e6c12e3d
MD
1327 default:
1328 return -EINVAL;
1329 }
1330}
1331
1332static
d871c65b 1333int lttng_event_enabler_release(int objd)
e6c12e3d 1334{
d871c65b
FD
1335 struct lttng_event_enabler *event_enabler = objd_private(objd);
1336
1337 if (event_enabler)
e7bc0ef6 1338 return lttng_ust_abi_objd_unref(event_enabler->chan->priv->parent.objd, 0);
e6c12e3d 1339
e6c12e3d
MD
1340 return 0;
1341}
1342
fd17d7ce 1343static const struct lttng_ust_abi_objd_ops lttng_event_enabler_ops = {
d871c65b
FD
1344 .release = lttng_event_enabler_release,
1345 .cmd = lttng_event_enabler_cmd,
e6c12e3d
MD
1346};
1347
b35d179d 1348void lttng_ust_abi_exit(void)
f4681817 1349{
45e9e699 1350 lttng_ust_abi_close_in_progress = 1;
701a658f 1351 ust_lock_nocheck();
f4681817 1352 objd_table_destroy();
701a658f 1353 ust_unlock();
45e9e699 1354 lttng_ust_abi_close_in_progress = 0;
f4681817 1355}
This page took 0.108477 seconds and 4 git commands to generate.