projects / lttng-ust.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Copyright ownership transfer
[lttng-ust.git] / src / lib / lttng-ust-ctl / ustctl.c
1 /*
2 * SPDX-License-Identifier: GPL-2.0-only
3 *
4 * Copyright (C) 2011 EfficiOS Inc.
5 * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 */
7
8 #include <stdint.h>
9 #include <string.h>
10 #include <sys/mman.h>
11 #include <unistd.h>
12 #include <sys/types.h>
13 #include <sys/socket.h>
14
15 #include <lttng/ust-config.h>
16 #include <lttng/ust-ctl.h>
17 #include <lttng/ust-abi.h>
18 #include <lttng/ust-endian.h>
19 #include <lttng/ust-common.h>
20 #include <lttng/ust-sigbus.h>
21 #include <urcu/rculist.h>
22
23 #include "common/logging.h"
24 #include "common/ustcomm.h"
25 #include "common/macros.h"
26 #include "common/align.h"
27
28 #include "common/ringbuffer/backend.h"
29 #include "common/ringbuffer/frontend.h"
30 #include "common/events.h"
31 #include "common/wait.h"
32 #include "common/ringbuffer-clients/clients.h"
33 #include "common/getenv.h"
34 #include "common/tracer.h"
35 #include "common/counter-clients/clients.h"
36
37 #include "common/smp.h"
38 #include "common/counter/counter.h"
39
40 /*
41 * Number of milliseconds to retry before failing metadata writes on
42 * buffer full condition. (10 seconds)
43 */
44 #define LTTNG_METADATA_TIMEOUT_MSEC 10000
45
46 /*
47 * Channel representation within consumer.
48 */
49 struct lttng_ust_ctl_consumer_channel {
50 struct lttng_ust_channel_buffer *chan; /* lttng channel buffers */
51
52 /* initial attributes */
53 struct lttng_ust_ctl_consumer_channel_attr attr;
54 int wait_fd; /* monitor close() */
55 int wakeup_fd; /* monitor close() */
56 };
57
58 /*
59 * Stream representation within consumer.
60 */
61 struct lttng_ust_ctl_consumer_stream {
62 struct lttng_ust_ring_buffer *buf;
63 struct lttng_ust_ctl_consumer_channel *chan;
64 int shm_fd, wait_fd, wakeup_fd;
65 int cpu;
66 uint64_t memory_map_size;
67 void *memory_map_addr;
68 };
69
70 #define LTTNG_UST_CTL_COUNTER_ATTR_DIMENSION_MAX 8
71 struct lttng_ust_ctl_counter_attr {
72 enum lttng_ust_ctl_counter_arithmetic arithmetic;
73 enum lttng_ust_ctl_counter_bitness bitness;
74 uint32_t nr_dimensions;
75 int64_t global_sum_step;
76 struct lttng_ust_ctl_counter_dimension dimensions[LTTNG_UST_CTL_COUNTER_ATTR_DIMENSION_MAX];
77 bool coalesce_hits;
78 };
79
80 /*
81 * Counter representation within daemon.
82 */
83 struct lttng_ust_ctl_daemon_counter {
84 struct lib_counter *counter;
85 const struct lttng_counter_ops *ops;
86 struct lttng_ust_ctl_counter_attr *attr; /* initial attributes */
87 };
88
89 /*
90 * Evaluates to false if transaction begins, true if it has failed due to SIGBUS.
91 * The entire transaction must complete before the current function returns.
92 * A transaction can contain 0 or more tracked ranges as sigbus begin/end pairs.
93 */
94 #define sigbus_begin() \
95 ({ \
96 assert(!lttng_ust_sigbus_state.jmp_ready); \
97 if (!lttng_ust_sigbus_state.head.next) { \
98 /* \
99 * Lazy init because static list initialisation is \
100 * problematic for TLS variable. \
101 */ \
102 CDS_INIT_LIST_HEAD(&lttng_ust_sigbus_state.head); \
103 } \
104 if (sigsetjmp(lttng_ust_sigbus_state.sj_env, 1)) { \
105 /* SIGBUS. */ \
106 CMM_STORE_SHARED(lttng_ust_sigbus_state.jmp_ready, 0); \
107 true; \
108 } \
109 cmm_barrier(); \
110 CMM_STORE_SHARED(lttng_ust_sigbus_state.jmp_ready, 1); \
111 false; \
112 })
113
114 static void sigbus_end(void)
115 {
116 assert(lttng_ust_sigbus_state.jmp_ready);
117 cmm_barrier();
118 CMM_STORE_SHARED(lttng_ust_sigbus_state.jmp_ready, 0);
119 }
120
121 static
122 void lttng_ust_sigbus_add_range(struct lttng_ust_sigbus_range *range, void *start, size_t len)
123 {
124 range->start = start;
125 range->end = (char *)start + len;
126 cds_list_add_rcu(&range->node, &lttng_ust_sigbus_state.head);
127 cmm_barrier();
128 }
129
130 static
131 void lttng_ust_sigbus_del_range(struct lttng_ust_sigbus_range *range)
132 {
133 cmm_barrier();
134 cds_list_del_rcu(&range->node);
135 }
136
137 void lttng_ust_ctl_sigbus_handle(void *addr)
138 {
139 struct lttng_ust_sigbus_range *range;
140
141 if (!CMM_LOAD_SHARED(lttng_ust_sigbus_state.jmp_ready))
142 return;
143 cds_list_for_each_entry_rcu(range, &lttng_ust_sigbus_state.head, node) {
144 if (addr < range->start || addr >= range->end)
145 continue;
146 siglongjmp(lttng_ust_sigbus_state.sj_env, 1);
147 }
148 }
149
150 int lttng_ust_ctl_release_handle(int sock, int handle)
151 {
152 struct ustcomm_ust_msg lum;
153 struct ustcomm_ust_reply lur;
154
155 if (sock < 0 || handle < 0)
156 return 0;
157 memset(&lum, 0, sizeof(lum));
158 lum.handle = handle;
159 lum.cmd = LTTNG_UST_ABI_RELEASE;
160 return ustcomm_send_app_cmd(sock, &lum, &lur);
161 }
162
163 /*
164 * If sock is negative, it means we don't have to notify the other side
165 * (e.g. application has already vanished).
166 */
167 int lttng_ust_ctl_release_object(int sock, struct lttng_ust_abi_object_data *data)
168 {
169 int ret;
170
171 if (!data)
172 return -EINVAL;
173
174 switch (data->type) {
175 case LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL:
176 if (data->u.channel.wakeup_fd >= 0) {
177 ret = close(data->u.channel.wakeup_fd);
178 if (ret < 0) {
179 ret = -errno;
180 return ret;
181 }
182 data->u.channel.wakeup_fd = -1;
183 }
184 free(data->u.channel.data);
185 data->u.channel.data = NULL;
186 break;
187 case LTTNG_UST_ABI_OBJECT_TYPE_STREAM:
188 if (data->u.stream.shm_fd >= 0) {
189 ret = close(data->u.stream.shm_fd);
190 if (ret < 0) {
191 ret = -errno;
192 return ret;
193 }
194 data->u.stream.shm_fd = -1;
195 }
196 if (data->u.stream.wakeup_fd >= 0) {
197 ret = close(data->u.stream.wakeup_fd);
198 if (ret < 0) {
199 ret = -errno;
200 return ret;
201 }
202 data->u.stream.wakeup_fd = -1;
203 }
204 break;
205 case LTTNG_UST_ABI_OBJECT_TYPE_EVENT:
206 case LTTNG_UST_ABI_OBJECT_TYPE_CONTEXT:
207 case LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER_GROUP:
208 case LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER:
209 break;
210 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER:
211 free(data->u.counter.data);
212 data->u.counter.data = NULL;
213 break;
214 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL:
215 if (data->u.counter_global.shm_fd >= 0) {
216 ret = close(data->u.counter_global.shm_fd);
217 if (ret < 0) {
218 ret = -errno;
219 return ret;
220 }
221 data->u.counter_global.shm_fd = -1;
222 }
223 break;
224 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU:
225 if (data->u.counter_cpu.shm_fd >= 0) {
226 ret = close(data->u.counter_cpu.shm_fd);
227 if (ret < 0) {
228 ret = -errno;
229 return ret;
230 }
231 data->u.counter_cpu.shm_fd = -1;
232 }
233 break;
234 default:
235 assert(0);
236 }
237 return lttng_ust_ctl_release_handle(sock, data->handle);
238 }
239
240 /*
241 * Send registration done packet to the application.
242 */
243 int lttng_ust_ctl_register_done(int sock)
244 {
245 struct ustcomm_ust_msg lum;
246 struct ustcomm_ust_reply lur;
247 int ret;
248
249 DBG("Sending register done command to %d", sock);
250 memset(&lum, 0, sizeof(lum));
251 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
252 lum.cmd = LTTNG_UST_ABI_REGISTER_DONE;
253 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
254 if (ret)
255 return ret;
256 return 0;
257 }
258
259 /*
260 * returns session handle.
261 */
262 int lttng_ust_ctl_create_session(int sock)
263 {
264 struct ustcomm_ust_msg lum;
265 struct ustcomm_ust_reply lur;
266 int ret, session_handle;
267
268 /* Create session */
269 memset(&lum, 0, sizeof(lum));
270 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
271 lum.cmd = LTTNG_UST_ABI_SESSION;
272 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
273 if (ret)
274 return ret;
275 session_handle = lur.ret_val;
276 DBG("received session handle %u", session_handle);
277 return session_handle;
278 }
279
280 int lttng_ust_ctl_create_event(int sock, struct lttng_ust_abi_event *ev,
281 struct lttng_ust_abi_object_data *channel_data,
282 struct lttng_ust_abi_object_data **_event_data)
283 {
284 struct ustcomm_ust_msg lum;
285 struct ustcomm_ust_reply lur;
286 struct lttng_ust_abi_object_data *event_data;
287 int ret;
288
289 if (!channel_data || !_event_data)
290 return -EINVAL;
291
292 event_data = zmalloc(sizeof(*event_data));
293 if (!event_data)
294 return -ENOMEM;
295 event_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT;
296 memset(&lum, 0, sizeof(lum));
297 lum.handle = channel_data->handle;
298 lum.cmd = LTTNG_UST_ABI_EVENT;
299 strncpy(lum.u.event.name, ev->name,
300 LTTNG_UST_ABI_SYM_NAME_LEN);
301 lum.u.event.instrumentation = ev->instrumentation;
302 lum.u.event.loglevel_type = ev->loglevel_type;
303 lum.u.event.loglevel = ev->loglevel;
304 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
305 if (ret) {
306 free(event_data);
307 return ret;
308 }
309 event_data->handle = lur.ret_val;
310 DBG("received event handle %u", event_data->handle);
311 *_event_data = event_data;
312 return 0;
313 }
314
315 /*
316 * Protocol for LTTNG_UST_ABI_CONTEXT command:
317 *
318 * - send: struct ustcomm_ust_msg
319 * - send: var len ctx_name
320 * - receive: struct ustcomm_ust_reply
321 *
322 * TODO: At the next breaking protocol bump, we should indicate the total
323 * command message length as part of a message header so that the protocol can
324 * recover from invalid command errors.
325 */
326 int lttng_ust_ctl_add_context(int sock, struct lttng_ust_context_attr *ctx,
327 struct lttng_ust_abi_object_data *obj_data,
328 struct lttng_ust_abi_object_data **_context_data)
329 {
330 struct ustcomm_ust_msg lum;
331 struct ustcomm_ust_reply lur;
332 struct lttng_ust_abi_object_data *context_data = NULL;
333 char *buf = NULL;
334 size_t len;
335 int ret;
336
337 if (!obj_data || !_context_data) {
338 ret = -EINVAL;
339 goto end;
340 }
341
342 context_data = zmalloc(sizeof(*context_data));
343 if (!context_data) {
344 ret = -ENOMEM;
345 goto end;
346 }
347 context_data->type = LTTNG_UST_ABI_OBJECT_TYPE_CONTEXT;
348 memset(&lum, 0, sizeof(lum));
349 lum.handle = obj_data->handle;
350 lum.cmd = LTTNG_UST_ABI_CONTEXT;
351
352 lum.u.context.ctx = ctx->ctx;
353 switch (ctx->ctx) {
354 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER:
355 lum.u.context.u.perf_counter = ctx->u.perf_counter;
356 break;
357 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT:
358 {
359 size_t provider_name_len = strlen(
360 ctx->u.app_ctx.provider_name) + 1;
361 size_t ctx_name_len = strlen(ctx->u.app_ctx.ctx_name) + 1;
362
363 lum.u.context.u.app_ctx.provider_name_len = provider_name_len;
364 lum.u.context.u.app_ctx.ctx_name_len = ctx_name_len;
365
366 len = provider_name_len + ctx_name_len;
367 buf = zmalloc(len);
368 if (!buf) {
369 ret = -ENOMEM;
370 goto end;
371 }
372 memcpy(buf, ctx->u.app_ctx.provider_name,
373 provider_name_len);
374 memcpy(buf + provider_name_len, ctx->u.app_ctx.ctx_name,
375 ctx_name_len);
376 break;
377 }
378 default:
379 break;
380 }
381 ret = ustcomm_send_app_msg(sock, &lum);
382 if (ret)
383 goto end;
384 if (buf) {
385 /* send var len ctx_name */
386 ret = ustcomm_send_unix_sock(sock, buf, len);
387 if (ret < 0) {
388 goto end;
389 }
390 if (ret != len) {
391 ret = -EINVAL;
392 goto end;
393 }
394 }
395 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
396 if (ret < 0) {
397 if (ret == -EINVAL) {
398 /*
399 * Command unknown from remote end. The communication socket is
400 * now out-of-sync and needs to be shutdown.
401 */
402 (void) ustcomm_shutdown_unix_sock(sock);
403 }
404 goto end;
405 }
406 context_data->handle = -1;
407 DBG("Context created successfully");
408 *_context_data = context_data;
409 context_data = NULL;
410 end:
411 free(context_data);
412 free(buf);
413 return ret;
414 }
415
416 /*
417 * Protocol for LTTNG_UST_ABI_FILTER command:
418 *
419 * - send: struct ustcomm_ust_msg
420 * - send: var len bytecode
421 * - receive: struct ustcomm_ust_reply
422 *
423 * TODO: At the next breaking protocol bump, we should indicate the total
424 * command message length as part of a message header so that the protocol can
425 * recover from invalid command errors.
426 */
427 int lttng_ust_ctl_set_filter(int sock, struct lttng_ust_abi_filter_bytecode *bytecode,
428 struct lttng_ust_abi_object_data *obj_data)
429 {
430 struct ustcomm_ust_msg lum;
431 struct ustcomm_ust_reply lur;
432 int ret;
433
434 if (!obj_data)
435 return -EINVAL;
436
437 memset(&lum, 0, sizeof(lum));
438 lum.handle = obj_data->handle;
439 lum.cmd = LTTNG_UST_ABI_FILTER;
440 lum.u.filter.data_size = bytecode->len;
441 lum.u.filter.reloc_offset = bytecode->reloc_offset;
442 lum.u.filter.seqnum = bytecode->seqnum;
443
444 ret = ustcomm_send_app_msg(sock, &lum);
445 if (ret)
446 return ret;
447 /* send var len bytecode */
448 ret = ustcomm_send_unix_sock(sock, bytecode->data,
449 bytecode->len);
450 if (ret < 0) {
451 return ret;
452 }
453 if (ret != bytecode->len)
454 return -EINVAL;
455 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
456 if (ret == -EINVAL) {
457 /*
458 * Command unknown from remote end. The communication socket is
459 * now out-of-sync and needs to be shutdown.
460 */
461 (void) ustcomm_shutdown_unix_sock(sock);
462 }
463 return ret;
464 }
465
466 /*
467 * Protocol for LTTNG_UST_ABI_CAPTURE command:
468 *
469 * - send: struct ustcomm_ust_msg
470 * - receive: struct ustcomm_ust_reply
471 * - send: var len bytecode
472 * - receive: struct ustcomm_ust_reply (actual command return code)
473 */
474 int lttng_ust_ctl_set_capture(int sock, struct lttng_ust_abi_capture_bytecode *bytecode,
475 struct lttng_ust_abi_object_data *obj_data)
476 {
477 struct ustcomm_ust_msg lum;
478 struct ustcomm_ust_reply lur;
479 int ret;
480
481 if (!obj_data)
482 return -EINVAL;
483
484 memset(&lum, 0, sizeof(lum));
485 lum.handle = obj_data->handle;
486 lum.cmd = LTTNG_UST_ABI_CAPTURE;
487 lum.u.capture.data_size = bytecode->len;
488 lum.u.capture.reloc_offset = bytecode->reloc_offset;
489 lum.u.capture.seqnum = bytecode->seqnum;
490
491 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
492 if (ret)
493 return ret;
494 /* send var len bytecode */
495 ret = ustcomm_send_unix_sock(sock, bytecode->data,
496 bytecode->len);
497 if (ret < 0) {
498 return ret;
499 }
500 if (ret != bytecode->len)
501 return -EINVAL;
502 return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
503 }
504
505 /*
506 * Protocol for LTTNG_UST_ABI_EXCLUSION command:
507 *
508 * - send: struct ustcomm_ust_msg
509 * - send: var len exclusion names
510 * - receive: struct ustcomm_ust_reply
511 *
512 * TODO: At the next breaking protocol bump, we should indicate the total
513 * command message length as part of a message header so that the protocol can
514 * recover from invalid command errors.
515 */
516 int lttng_ust_ctl_set_exclusion(int sock, struct lttng_ust_abi_event_exclusion *exclusion,
517 struct lttng_ust_abi_object_data *obj_data)
518 {
519 struct ustcomm_ust_msg lum;
520 struct ustcomm_ust_reply lur;
521 int ret;
522
523 if (!obj_data) {
524 return -EINVAL;
525 }
526
527 memset(&lum, 0, sizeof(lum));
528 lum.handle = obj_data->handle;
529 lum.cmd = LTTNG_UST_ABI_EXCLUSION;
530 lum.u.exclusion.count = exclusion->count;
531
532 ret = ustcomm_send_app_msg(sock, &lum);
533 if (ret) {
534 return ret;
535 }
536
537 /* send var len exclusion names */
538 ret = ustcomm_send_unix_sock(sock,
539 exclusion->names,
540 exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN);
541 if (ret < 0) {
542 return ret;
543 }
544 if (ret != exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN) {
545 return -EINVAL;
546 }
547 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
548 if (ret == -EINVAL) {
549 /*
550 * Command unknown from remote end. The communication socket is
551 * now out-of-sync and needs to be shutdown.
552 */
553 (void) ustcomm_shutdown_unix_sock(sock);
554 }
555 return ret;
556 }
557
558 /* Enable event, channel and session ioctl */
559 int lttng_ust_ctl_enable(int sock, struct lttng_ust_abi_object_data *object)
560 {
561 struct ustcomm_ust_msg lum;
562 struct ustcomm_ust_reply lur;
563 int ret;
564
565 if (!object)
566 return -EINVAL;
567
568 memset(&lum, 0, sizeof(lum));
569 lum.handle = object->handle;
570 lum.cmd = LTTNG_UST_ABI_ENABLE;
571 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
572 if (ret)
573 return ret;
574 DBG("enabled handle %u", object->handle);
575 return 0;
576 }
577
578 /* Disable event, channel and session ioctl */
579 int lttng_ust_ctl_disable(int sock, struct lttng_ust_abi_object_data *object)
580 {
581 struct ustcomm_ust_msg lum;
582 struct ustcomm_ust_reply lur;
583 int ret;
584
585 if (!object)
586 return -EINVAL;
587
588 memset(&lum, 0, sizeof(lum));
589 lum.handle = object->handle;
590 lum.cmd = LTTNG_UST_ABI_DISABLE;
591 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
592 if (ret)
593 return ret;
594 DBG("disable handle %u", object->handle);
595 return 0;
596 }
597
598 int lttng_ust_ctl_start_session(int sock, int handle)
599 {
600 struct lttng_ust_abi_object_data obj;
601
602 obj.handle = handle;
603 return lttng_ust_ctl_enable(sock, &obj);
604 }
605
606 int lttng_ust_ctl_stop_session(int sock, int handle)
607 {
608 struct lttng_ust_abi_object_data obj;
609
610 obj.handle = handle;
611 return lttng_ust_ctl_disable(sock, &obj);
612 }
613
614 /*
615 * Protocol for LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE command:
616 *
617 * - send: struct ustcomm_ust_msg
618 * - receive: struct ustcomm_ust_reply
619 * - send: file descriptor
620 * - receive: struct ustcomm_ust_reply (actual command return code)
621 */
622 int lttng_ust_ctl_create_event_notifier_group(int sock, int pipe_fd,
623 struct lttng_ust_abi_object_data **_event_notifier_group_data)
624 {
625 struct lttng_ust_abi_object_data *event_notifier_group_data;
626 struct ustcomm_ust_msg lum;
627 struct ustcomm_ust_reply lur;
628 ssize_t len;
629 int ret;
630
631 if (!_event_notifier_group_data)
632 return -EINVAL;
633
634 event_notifier_group_data = zmalloc(sizeof(*event_notifier_group_data));
635 if (!event_notifier_group_data)
636 return -ENOMEM;
637
638 event_notifier_group_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER_GROUP;
639
640 memset(&lum, 0, sizeof(lum));
641 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
642 lum.cmd = LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE;
643
644 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
645 if (ret)
646 goto error;
647
648 /* Send event_notifier notification pipe. */
649 len = ustcomm_send_fds_unix_sock(sock, &pipe_fd, 1);
650 if (len <= 0) {
651 ret = len;
652 goto error;
653 }
654
655 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
656 if (ret)
657 goto error;
658
659 event_notifier_group_data->handle = lur.ret_val;
660 DBG("received event_notifier group handle %d", event_notifier_group_data->handle);
661
662 *_event_notifier_group_data = event_notifier_group_data;
663
664 ret = 0;
665 goto end;
666 error:
667 free(event_notifier_group_data);
668
669 end:
670 return ret;
671 }
672
673 /*
674 * Protocol for LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE command:
675 *
676 * - send: struct ustcomm_ust_msg
677 * - receive: struct ustcomm_ust_reply
678 * - send: struct lttng_ust_abi_event_notifier
679 * - receive: struct ustcomm_ust_reply (actual command return code)
680 */
681 int lttng_ust_ctl_create_event_notifier(int sock, struct lttng_ust_abi_event_notifier *event_notifier,
682 struct lttng_ust_abi_object_data *event_notifier_group,
683 struct lttng_ust_abi_object_data **_event_notifier_data)
684 {
685 struct ustcomm_ust_msg lum;
686 struct ustcomm_ust_reply lur;
687 struct lttng_ust_abi_object_data *event_notifier_data;
688 ssize_t len;
689 int ret;
690
691 if (!event_notifier_group || !_event_notifier_data)
692 return -EINVAL;
693
694 event_notifier_data = zmalloc(sizeof(*event_notifier_data));
695 if (!event_notifier_data)
696 return -ENOMEM;
697
698 event_notifier_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER;
699
700 memset(&lum, 0, sizeof(lum));
701 lum.handle = event_notifier_group->handle;
702 lum.cmd = LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE;
703 lum.u.event_notifier.len = sizeof(*event_notifier);
704
705 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
706 if (ret) {
707 free(event_notifier_data);
708 return ret;
709 }
710 /* Send struct lttng_ust_abi_event_notifier */
711 len = ustcomm_send_unix_sock(sock, event_notifier, sizeof(*event_notifier));
712 if (len != sizeof(*event_notifier)) {
713 free(event_notifier_data);
714 if (len < 0)
715 return len;
716 else
717 return -EIO;
718 }
719 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
720 if (ret) {
721 free(event_notifier_data);
722 return ret;
723 }
724 event_notifier_data->handle = lur.ret_val;
725 DBG("received event_notifier handle %u", event_notifier_data->handle);
726 *_event_notifier_data = event_notifier_data;
727
728 return ret;
729 }
730
731 int lttng_ust_ctl_tracepoint_list(int sock)
732 {
733 struct ustcomm_ust_msg lum;
734 struct ustcomm_ust_reply lur;
735 int ret, tp_list_handle;
736
737 memset(&lum, 0, sizeof(lum));
738 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
739 lum.cmd = LTTNG_UST_ABI_TRACEPOINT_LIST;
740 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
741 if (ret)
742 return ret;
743 tp_list_handle = lur.ret_val;
744 DBG("received tracepoint list handle %u", tp_list_handle);
745 return tp_list_handle;
746 }
747
748 int lttng_ust_ctl_tracepoint_list_get(int sock, int tp_list_handle,
749 struct lttng_ust_abi_tracepoint_iter *iter)
750 {
751 struct ustcomm_ust_msg lum;
752 struct ustcomm_ust_reply lur;
753 int ret;
754
755 if (!iter)
756 return -EINVAL;
757
758 memset(&lum, 0, sizeof(lum));
759 lum.handle = tp_list_handle;
760 lum.cmd = LTTNG_UST_ABI_TRACEPOINT_LIST_GET;
761 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
762 if (ret)
763 return ret;
764 DBG("received tracepoint list entry name %s loglevel %d",
765 lur.u.tracepoint.name,
766 lur.u.tracepoint.loglevel);
767 memcpy(iter, &lur.u.tracepoint, sizeof(*iter));
768 return 0;
769 }
770
771 int lttng_ust_ctl_tracepoint_field_list(int sock)
772 {
773 struct ustcomm_ust_msg lum;
774 struct ustcomm_ust_reply lur;
775 int ret, tp_field_list_handle;
776
777 memset(&lum, 0, sizeof(lum));
778 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
779 lum.cmd = LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST;
780 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
781 if (ret)
782 return ret;
783 tp_field_list_handle = lur.ret_val;
784 DBG("received tracepoint field list handle %u", tp_field_list_handle);
785 return tp_field_list_handle;
786 }
787
788 int lttng_ust_ctl_tracepoint_field_list_get(int sock, int tp_field_list_handle,
789 struct lttng_ust_abi_field_iter *iter)
790 {
791 struct ustcomm_ust_msg lum;
792 struct ustcomm_ust_reply lur;
793 int ret;
794 ssize_t len;
795
796 if (!iter)
797 return -EINVAL;
798
799 memset(&lum, 0, sizeof(lum));
800 lum.handle = tp_field_list_handle;
801 lum.cmd = LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST_GET;
802 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
803 if (ret)
804 return ret;
805 len = ustcomm_recv_unix_sock(sock, iter, sizeof(*iter));
806 if (len != sizeof(*iter)) {
807 return -EINVAL;
808 }
809 DBG("received tracepoint field list entry event_name %s event_loglevel %d field_name %s field_type %d",
810 iter->event_name,
811 iter->loglevel,
812 iter->field_name,
813 iter->type);
814 return 0;
815 }
816
817 int lttng_ust_ctl_tracer_version(int sock, struct lttng_ust_abi_tracer_version *v)
818 {
819 struct ustcomm_ust_msg lum;
820 struct ustcomm_ust_reply lur;
821 int ret;
822
823 if (!v)
824 return -EINVAL;
825
826 memset(&lum, 0, sizeof(lum));
827 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
828 lum.cmd = LTTNG_UST_ABI_TRACER_VERSION;
829 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
830 if (ret)
831 return ret;
832 memcpy(v, &lur.u.version, sizeof(*v));
833 DBG("received tracer version");
834 return 0;
835 }
836
837 int lttng_ust_ctl_wait_quiescent(int sock)
838 {
839 struct ustcomm_ust_msg lum;
840 struct ustcomm_ust_reply lur;
841 int ret;
842
843 memset(&lum, 0, sizeof(lum));
844 lum.handle = LTTNG_UST_ABI_ROOT_HANDLE;
845 lum.cmd = LTTNG_UST_ABI_WAIT_QUIESCENT;
846 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
847 if (ret)
848 return ret;
849 DBG("waited for quiescent state");
850 return 0;
851 }
852
853 int lttng_ust_ctl_calibrate(int sock __attribute__((unused)),
854 struct lttng_ust_abi_calibrate *calibrate)
855 {
856 if (!calibrate)
857 return -EINVAL;
858
859 return -ENOSYS;
860 }
861
862 int lttng_ust_ctl_sock_flush_buffer(int sock, struct lttng_ust_abi_object_data *object)
863 {
864 struct ustcomm_ust_msg lum;
865 struct ustcomm_ust_reply lur;
866 int ret;
867
868 if (!object)
869 return -EINVAL;
870
871 memset(&lum, 0, sizeof(lum));
872 lum.handle = object->handle;
873 lum.cmd = LTTNG_UST_ABI_FLUSH_BUFFER;
874 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
875 if (ret)
876 return ret;
877 DBG("flushed buffer handle %u", object->handle);
878 return 0;
879 }
880
881 static
882 int lttng_ust_ctl_send_channel(int sock,
883 enum lttng_ust_abi_chan_type type,
884 void *data,
885 uint64_t size,
886 int wakeup_fd,
887 int send_fd_only)
888 {
889 ssize_t len;
890
891 if (!send_fd_only) {
892 /* Send mmap size */
893 len = ustcomm_send_unix_sock(sock, &size, sizeof(size));
894 if (len != sizeof(size)) {
895 if (len < 0)
896 return len;
897 else
898 return -EIO;
899 }
900
901 /* Send channel type */
902 len = ustcomm_send_unix_sock(sock, &type, sizeof(type));
903 if (len != sizeof(type)) {
904 if (len < 0)
905 return len;
906 else
907 return -EIO;
908 }
909 }
910
911 /* Send channel data */
912 len = ustcomm_send_unix_sock(sock, data, size);
913 if (len != size) {
914 if (len < 0)
915 return len;
916 else
917 return -EIO;
918 }
919
920 /* Send wakeup fd */
921 len = ustcomm_send_fds_unix_sock(sock, &wakeup_fd, 1);
922 if (len <= 0) {
923 if (len < 0)
924 return len;
925 else
926 return -EIO;
927 }
928 return 0;
929 }
930
931 static
932 int lttng_ust_ctl_send_stream(int sock,
933 uint32_t stream_nr,
934 uint64_t memory_map_size,
935 int shm_fd, int wakeup_fd,
936 int send_fd_only)
937 {
938 ssize_t len;
939 int fds[2];
940
941 if (!send_fd_only) {
942 if (shm_fd < 0) {
943 /* finish iteration */
944 uint64_t v = -1;
945
946 len = ustcomm_send_unix_sock(sock, &v, sizeof(v));
947 if (len != sizeof(v)) {
948 if (len < 0)
949 return len;
950 else
951 return -EIO;
952 }
953 return 0;
954 }
955
956 /* Send mmap size */
957 len = ustcomm_send_unix_sock(sock, &memory_map_size,
958 sizeof(memory_map_size));
959 if (len != sizeof(memory_map_size)) {
960 if (len < 0)
961 return len;
962 else
963 return -EIO;
964 }
965
966 /* Send stream nr */
967 len = ustcomm_send_unix_sock(sock, &stream_nr,
968 sizeof(stream_nr));
969 if (len != sizeof(stream_nr)) {
970 if (len < 0)
971 return len;
972 else
973 return -EIO;
974 }
975 }
976
977 /* Send shm fd and wakeup fd */
978 fds[0] = shm_fd;
979 fds[1] = wakeup_fd;
980 len = ustcomm_send_fds_unix_sock(sock, fds, 2);
981 if (len <= 0) {
982 if (len < 0)
983 return len;
984 else
985 return -EIO;
986 }
987 return 0;
988 }
989
990 int lttng_ust_ctl_recv_channel_from_consumer(int sock,
991 struct lttng_ust_abi_object_data **_channel_data)
992 {
993 struct lttng_ust_abi_object_data *channel_data;
994 ssize_t len;
995 int wakeup_fd;
996 int ret;
997
998 channel_data = zmalloc(sizeof(*channel_data));
999 if (!channel_data) {
1000 ret = -ENOMEM;
1001 goto error_alloc;
1002 }
1003 channel_data->type = LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL;
1004 channel_data->handle = -1;
1005
1006 /* recv mmap size */
1007 len = ustcomm_recv_unix_sock(sock, &channel_data->size,
1008 sizeof(channel_data->size));
1009 if (len != sizeof(channel_data->size)) {
1010 if (len < 0)
1011 ret = len;
1012 else
1013 ret = -EINVAL;
1014 goto error;
1015 }
1016
1017 /* recv channel type */
1018 len = ustcomm_recv_unix_sock(sock, &channel_data->u.channel.type,
1019 sizeof(channel_data->u.channel.type));
1020 if (len != sizeof(channel_data->u.channel.type)) {
1021 if (len < 0)
1022 ret = len;
1023 else
1024 ret = -EINVAL;
1025 goto error;
1026 }
1027
1028 /* recv channel data */
1029 channel_data->u.channel.data = zmalloc(channel_data->size);
1030 if (!channel_data->u.channel.data) {
1031 ret = -ENOMEM;
1032 goto error;
1033 }
1034 len = ustcomm_recv_unix_sock(sock, channel_data->u.channel.data,
1035 channel_data->size);
1036 if (len != channel_data->size) {
1037 if (len < 0)
1038 ret = len;
1039 else
1040 ret = -EINVAL;
1041 goto error_recv_data;
1042 }
1043 /* recv wakeup fd */
1044 len = ustcomm_recv_fds_unix_sock(sock, &wakeup_fd, 1);
1045 if (len <= 0) {
1046 if (len < 0) {
1047 ret = len;
1048 goto error_recv_data;
1049 } else {
1050 ret = -EIO;
1051 goto error_recv_data;
1052 }
1053 }
1054 channel_data->u.channel.wakeup_fd = wakeup_fd;
1055 *_channel_data = channel_data;
1056 return 0;
1057
1058 error_recv_data:
1059 free(channel_data->u.channel.data);
1060 error:
1061 free(channel_data);
1062 error_alloc:
1063 return ret;
1064 }
1065
1066 int lttng_ust_ctl_recv_stream_from_consumer(int sock,
1067 struct lttng_ust_abi_object_data **_stream_data)
1068 {
1069 struct lttng_ust_abi_object_data *stream_data;
1070 ssize_t len;
1071 int ret;
1072 int fds[2];
1073
1074 stream_data = zmalloc(sizeof(*stream_data));
1075 if (!stream_data) {
1076 ret = -ENOMEM;
1077 goto error_alloc;
1078 }
1079
1080 stream_data->type = LTTNG_UST_ABI_OBJECT_TYPE_STREAM;
1081 stream_data->handle = -1;
1082
1083 /* recv mmap size */
1084 len = ustcomm_recv_unix_sock(sock, &stream_data->size,
1085 sizeof(stream_data->size));
1086 if (len != sizeof(stream_data->size)) {
1087 if (len < 0)
1088 ret = len;
1089 else
1090 ret = -EINVAL;
1091 goto error;
1092 }
1093 if (stream_data->size == -1) {
1094 ret = -LTTNG_UST_ERR_NOENT;
1095 goto error;
1096 }
1097
1098 /* recv stream nr */
1099 len = ustcomm_recv_unix_sock(sock, &stream_data->u.stream.stream_nr,
1100 sizeof(stream_data->u.stream.stream_nr));
1101 if (len != sizeof(stream_data->u.stream.stream_nr)) {
1102 if (len < 0)
1103 ret = len;
1104 else
1105 ret = -EINVAL;
1106 goto error;
1107 }
1108
1109 /* recv shm fd and wakeup fd */
1110 len = ustcomm_recv_fds_unix_sock(sock, fds, 2);
1111 if (len <= 0) {
1112 if (len < 0) {
1113 ret = len;
1114 goto error;
1115 } else {
1116 ret = -EIO;
1117 goto error;
1118 }
1119 }
1120 stream_data->u.stream.shm_fd = fds[0];
1121 stream_data->u.stream.wakeup_fd = fds[1];
1122 *_stream_data = stream_data;
1123 return 0;
1124
1125 error:
1126 free(stream_data);
1127 error_alloc:
1128 return ret;
1129 }
1130
1131 /*
1132 * Protocol for LTTNG_UST_ABI_CHANNEL command:
1133 *
1134 * - send: struct ustcomm_ust_msg
1135 * - send: file descriptors and channel data
1136 * - receive: struct ustcomm_ust_reply
1137 *
1138 * TODO: At the next breaking protocol bump, we should indicate the total
1139 * command message length as part of a message header so that the protocol can
1140 * recover from invalid command errors.
1141 */
1142 int lttng_ust_ctl_send_channel_to_ust(int sock, int session_handle,
1143 struct lttng_ust_abi_object_data *channel_data)
1144 {
1145 struct ustcomm_ust_msg lum;
1146 struct ustcomm_ust_reply lur;
1147 int ret;
1148
1149 if (!channel_data)
1150 return -EINVAL;
1151
1152 memset(&lum, 0, sizeof(lum));
1153 lum.handle = session_handle;
1154 lum.cmd = LTTNG_UST_ABI_CHANNEL;
1155 lum.u.channel.len = channel_data->size;
1156 lum.u.channel.type = channel_data->u.channel.type;
1157 ret = ustcomm_send_app_msg(sock, &lum);
1158 if (ret)
1159 return ret;
1160
1161 ret = lttng_ust_ctl_send_channel(sock,
1162 channel_data->u.channel.type,
1163 channel_data->u.channel.data,
1164 channel_data->size,
1165 channel_data->u.channel.wakeup_fd,
1166 1);
1167 if (ret)
1168 return ret;
1169 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
1170 if (!ret) {
1171 channel_data->handle = lur.ret_val;
1172 } else if (ret == -EINVAL) {
1173 /*
1174 * Command unknown from remote end. The communication socket is
1175 * now out-of-sync and needs to be shutdown.
1176 */
1177 (void) ustcomm_shutdown_unix_sock(sock);
1178 }
1179 return ret;
1180 }
1181
1182 /*
1183 * Protocol for LTTNG_UST_ABI_STREAM command:
1184 *
1185 * - send: struct ustcomm_ust_msg
1186 * - send: file descriptors and stream data
1187 * - receive: struct ustcomm_ust_reply
1188 *
1189 * TODO: At the next breaking protocol bump, we should indicate the total
1190 * command message length as part of a message header so that the protocol can
1191 * recover from invalid command errors.
1192 */
1193 int lttng_ust_ctl_send_stream_to_ust(int sock,
1194 struct lttng_ust_abi_object_data *channel_data,
1195 struct lttng_ust_abi_object_data *stream_data)
1196 {
1197 struct ustcomm_ust_msg lum;
1198 struct ustcomm_ust_reply lur;
1199 int ret;
1200
1201 memset(&lum, 0, sizeof(lum));
1202 lum.handle = channel_data->handle;
1203 lum.cmd = LTTNG_UST_ABI_STREAM;
1204 lum.u.stream.len = stream_data->size;
1205 lum.u.stream.stream_nr = stream_data->u.stream.stream_nr;
1206 ret = ustcomm_send_app_msg(sock, &lum);
1207 if (ret)
1208 return ret;
1209
1210 assert(stream_data);
1211 assert(stream_data->type == LTTNG_UST_ABI_OBJECT_TYPE_STREAM);
1212
1213 ret = lttng_ust_ctl_send_stream(sock,
1214 stream_data->u.stream.stream_nr,
1215 stream_data->size,
1216 stream_data->u.stream.shm_fd,
1217 stream_data->u.stream.wakeup_fd, 1);
1218 if (ret)
1219 return ret;
1220 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
1221 if (ret == -EINVAL) {
1222 /*
1223 * Command unknown from remote end. The communication socket is
1224 * now out-of-sync and needs to be shutdown.
1225 */
1226 (void) ustcomm_shutdown_unix_sock(sock);
1227 }
1228 return ret;
1229 }
1230
1231 int lttng_ust_ctl_duplicate_ust_object_data(struct lttng_ust_abi_object_data **dest,
1232 struct lttng_ust_abi_object_data *src)
1233 {
1234 struct lttng_ust_abi_object_data *obj;
1235 int ret;
1236
1237 if (src->handle != -1) {
1238 ret = -EINVAL;
1239 goto error;
1240 }
1241
1242 obj = zmalloc(sizeof(*obj));
1243 if (!obj) {
1244 ret = -ENOMEM;
1245 goto error;
1246 }
1247
1248 obj->type = src->type;
1249 obj->handle = src->handle;
1250 obj->size = src->size;
1251
1252 switch (obj->type) {
1253 case LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL:
1254 {
1255 obj->u.channel.type = src->u.channel.type;
1256 if (src->u.channel.wakeup_fd >= 0) {
1257 obj->u.channel.wakeup_fd =
1258 dup(src->u.channel.wakeup_fd);
1259 if (obj->u.channel.wakeup_fd < 0) {
1260 ret = errno;
1261 goto chan_error_wakeup_fd;
1262 }
1263 } else {
1264 obj->u.channel.wakeup_fd =
1265 src->u.channel.wakeup_fd;
1266 }
1267 obj->u.channel.data = zmalloc(obj->size);
1268 if (!obj->u.channel.data) {
1269 ret = -ENOMEM;
1270 goto chan_error_alloc;
1271 }
1272 memcpy(obj->u.channel.data, src->u.channel.data, obj->size);
1273 break;
1274
1275 chan_error_alloc:
1276 if (src->u.channel.wakeup_fd >= 0) {
1277 int closeret;
1278
1279 closeret = close(obj->u.channel.wakeup_fd);
1280 if (closeret) {
1281 PERROR("close");
1282 }
1283 }
1284 chan_error_wakeup_fd:
1285 goto error_type;
1286
1287 }
1288
1289 case LTTNG_UST_ABI_OBJECT_TYPE_STREAM:
1290 {
1291 obj->u.stream.stream_nr = src->u.stream.stream_nr;
1292 if (src->u.stream.wakeup_fd >= 0) {
1293 obj->u.stream.wakeup_fd =
1294 dup(src->u.stream.wakeup_fd);
1295 if (obj->u.stream.wakeup_fd < 0) {
1296 ret = errno;
1297 goto stream_error_wakeup_fd;
1298 }
1299 } else {
1300 obj->u.stream.wakeup_fd =
1301 src->u.stream.wakeup_fd;
1302 }
1303
1304 if (src->u.stream.shm_fd >= 0) {
1305 obj->u.stream.shm_fd =
1306 dup(src->u.stream.shm_fd);
1307 if (obj->u.stream.shm_fd < 0) {
1308 ret = errno;
1309 goto stream_error_shm_fd;
1310 }
1311 } else {
1312 obj->u.stream.shm_fd =
1313 src->u.stream.shm_fd;
1314 }
1315 break;
1316
1317 stream_error_shm_fd:
1318 if (src->u.stream.wakeup_fd >= 0) {
1319 int closeret;
1320
1321 closeret = close(obj->u.stream.wakeup_fd);
1322 if (closeret) {
1323 PERROR("close");
1324 }
1325 }
1326 stream_error_wakeup_fd:
1327 goto error_type;
1328 }
1329
1330 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER:
1331 {
1332 obj->u.counter.data = zmalloc(obj->size);
1333 if (!obj->u.counter.data) {
1334 ret = -ENOMEM;
1335 goto error_type;
1336 }
1337 memcpy(obj->u.counter.data, src->u.counter.data, obj->size);
1338 break;
1339 }
1340
1341 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL:
1342 {
1343 if (src->u.counter_global.shm_fd >= 0) {
1344 obj->u.counter_global.shm_fd =
1345 dup(src->u.counter_global.shm_fd);
1346 if (obj->u.counter_global.shm_fd < 0) {
1347 ret = errno;
1348 goto error_type;
1349 }
1350 }
1351 break;
1352 }
1353
1354 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU:
1355 {
1356 obj->u.counter_cpu.cpu_nr = src->u.counter_cpu.cpu_nr;
1357 if (src->u.counter_cpu.shm_fd >= 0) {
1358 obj->u.counter_cpu.shm_fd =
1359 dup(src->u.counter_cpu.shm_fd);
1360 if (obj->u.counter_cpu.shm_fd < 0) {
1361 ret = errno;
1362 goto error_type;
1363 }
1364 }
1365 break;
1366 }
1367
1368 default:
1369 ret = -EINVAL;
1370 goto error_type;
1371 }
1372
1373 *dest = obj;
1374 return 0;
1375
1376 error_type:
1377 free(obj);
1378 error:
1379 return ret;
1380 }
1381
1382
1383 /* Buffer operations */
1384
1385 int lttng_ust_ctl_get_nr_stream_per_channel(void)
1386 {
1387 return num_possible_cpus();
1388 }
1389
1390 struct lttng_ust_ctl_consumer_channel *
1391 lttng_ust_ctl_create_channel(struct lttng_ust_ctl_consumer_channel_attr *attr,
1392 const int *stream_fds, int nr_stream_fds)
1393 {
1394 struct lttng_ust_ctl_consumer_channel *chan;
1395 const char *transport_name;
1396 struct lttng_transport *transport;
1397
1398 switch (attr->type) {
1399 case LTTNG_UST_ABI_CHAN_PER_CPU:
1400 if (attr->output == LTTNG_UST_ABI_MMAP) {
1401 if (attr->overwrite) {
1402 if (attr->read_timer_interval == 0) {
1403 transport_name = "relay-overwrite-mmap";
1404 } else {
1405 transport_name = "relay-overwrite-rt-mmap";
1406 }
1407 } else {
1408 if (attr->read_timer_interval == 0) {
1409 transport_name = "relay-discard-mmap";
1410 } else {
1411 transport_name = "relay-discard-rt-mmap";
1412 }
1413 }
1414 } else {
1415 return NULL;
1416 }
1417 break;
1418 case LTTNG_UST_ABI_CHAN_METADATA:
1419 if (attr->output == LTTNG_UST_ABI_MMAP)
1420 transport_name = "relay-metadata-mmap";
1421 else
1422 return NULL;
1423 break;
1424 default:
1425 transport_name = "<unknown>";
1426 return NULL;
1427 }
1428
1429 transport = lttng_ust_transport_find(transport_name);
1430 if (!transport) {
1431 DBG("LTTng transport %s not found\n",
1432 transport_name);
1433 return NULL;
1434 }
1435
1436 chan = zmalloc(sizeof(*chan));
1437 if (!chan)
1438 return NULL;
1439
1440 chan->chan = transport->ops.priv->channel_create(transport_name, NULL,
1441 attr->subbuf_size, attr->num_subbuf,
1442 attr->switch_timer_interval,
1443 attr->read_timer_interval,
1444 attr->uuid, attr->chan_id,
1445 stream_fds, nr_stream_fds,
1446 attr->blocking_timeout);
1447 if (!chan->chan) {
1448 goto chan_error;
1449 }
1450 chan->chan->ops = &transport->ops;
1451 memcpy(&chan->attr, attr, sizeof(chan->attr));
1452 chan->wait_fd = lttng_ust_ctl_channel_get_wait_fd(chan);
1453 chan->wakeup_fd = lttng_ust_ctl_channel_get_wakeup_fd(chan);
1454 return chan;
1455
1456 chan_error:
1457 free(chan);
1458 return NULL;
1459 }
1460
1461 void lttng_ust_ctl_destroy_channel(struct lttng_ust_ctl_consumer_channel *chan)
1462 {
1463 (void) lttng_ust_ctl_channel_close_wait_fd(chan);
1464 (void) lttng_ust_ctl_channel_close_wakeup_fd(chan);
1465 chan->chan->ops->priv->channel_destroy(chan->chan);
1466 free(chan);
1467 }
1468
1469 int lttng_ust_ctl_send_channel_to_sessiond(int sock,
1470 struct lttng_ust_ctl_consumer_channel *channel)
1471 {
1472 struct shm_object_table *table;
1473
1474 table = channel->chan->priv->rb_chan->handle->table;
1475 if (table->size <= 0)
1476 return -EINVAL;
1477 return lttng_ust_ctl_send_channel(sock,
1478 channel->attr.type,
1479 table->objects[0].memory_map,
1480 table->objects[0].memory_map_size,
1481 channel->wakeup_fd,
1482 0);
1483 }
1484
1485 int lttng_ust_ctl_send_stream_to_sessiond(int sock,
1486 struct lttng_ust_ctl_consumer_stream *stream)
1487 {
1488 if (!stream)
1489 return lttng_ust_ctl_send_stream(sock, -1U, -1U, -1, -1, 0);
1490
1491 return lttng_ust_ctl_send_stream(sock,
1492 stream->cpu,
1493 stream->memory_map_size,
1494 stream->shm_fd, stream->wakeup_fd,
1495 0);
1496 }
1497
1498 int lttng_ust_ctl_write_metadata_to_channel(
1499 struct lttng_ust_ctl_consumer_channel *channel,
1500 const char *metadata_str, /* NOT null-terminated */
1501 size_t len) /* metadata length */
1502 {
1503 struct lttng_ust_ring_buffer_ctx ctx;
1504 struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan;
1505 struct lttng_ust_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan;
1506 const char *str = metadata_str;
1507 int ret = 0, waitret;
1508 size_t reserve_len, pos;
1509
1510 for (pos = 0; pos < len; pos += reserve_len) {
1511 reserve_len = min_t(size_t,
1512 lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf),
1513 len - pos);
1514 lttng_ust_ring_buffer_ctx_init(&ctx, rb_chan, reserve_len, sizeof(char), NULL);
1515 /*
1516 * We don't care about metadata buffer's records lost
1517 * count, because we always retry here. Report error if
1518 * we need to bail out after timeout or being
1519 * interrupted.
1520 */
1521 waitret = wait_cond_interruptible_timeout(
1522 ({
1523 ret = lttng_chan_buf->ops->event_reserve(&ctx);
1524 ret != -ENOBUFS || !ret;
1525 }),
1526 LTTNG_METADATA_TIMEOUT_MSEC);
1527 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
1528 DBG("LTTng: Failure to write metadata to buffers (%s)\n",
1529 waitret == -EINTR ? "interrupted" :
1530 (ret == -ENOBUFS ? "timeout" : "I/O error"));
1531 if (waitret == -EINTR)
1532 ret = waitret;
1533 goto end;
1534 }
1535 lttng_chan_buf->ops->event_write(&ctx, &str[pos], reserve_len, 1);
1536 lttng_chan_buf->ops->event_commit(&ctx);
1537 }
1538 end:
1539 return ret;
1540 }
1541
1542 /*
1543 * Write at most one packet in the channel.
1544 * Returns the number of bytes written on success, < 0 on error.
1545 */
1546 ssize_t lttng_ust_ctl_write_one_packet_to_channel(
1547 struct lttng_ust_ctl_consumer_channel *channel,
1548 const char *metadata_str, /* NOT null-terminated */
1549 size_t len) /* metadata length */
1550 {
1551 struct lttng_ust_ring_buffer_ctx ctx;
1552 struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan;
1553 struct lttng_ust_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan;
1554 const char *str = metadata_str;
1555 ssize_t reserve_len;
1556 int ret;
1557
1558 reserve_len = min_t(ssize_t,
1559 lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf),
1560 len);
1561 lttng_ust_ring_buffer_ctx_init(&ctx, rb_chan, reserve_len, sizeof(char), NULL);
1562 ret = lttng_chan_buf->ops->event_reserve(&ctx);
1563 if (ret != 0) {
1564 DBG("LTTng: event reservation failed");
1565 assert(ret < 0);
1566 reserve_len = ret;
1567 goto end;
1568 }
1569 lttng_chan_buf->ops->event_write(&ctx, str, reserve_len, 1);
1570 lttng_chan_buf->ops->event_commit(&ctx);
1571
1572 end:
1573 return reserve_len;
1574 }
1575
1576 int lttng_ust_ctl_channel_close_wait_fd(struct lttng_ust_ctl_consumer_channel *consumer_chan)
1577 {
1578 struct lttng_ust_ring_buffer_channel *chan;
1579 int ret;
1580
1581 chan = consumer_chan->chan->priv->rb_chan;
1582 ret = ring_buffer_channel_close_wait_fd(&chan->backend.config,
1583 chan, chan->handle);
1584 if (!ret)
1585 consumer_chan->wait_fd = -1;
1586 return ret;
1587 }
1588
1589 int lttng_ust_ctl_channel_close_wakeup_fd(struct lttng_ust_ctl_consumer_channel *consumer_chan)
1590 {
1591 struct lttng_ust_ring_buffer_channel *chan;
1592 int ret;
1593
1594 chan = consumer_chan->chan->priv->rb_chan;
1595 ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
1596 chan, chan->handle);
1597 if (!ret)
1598 consumer_chan->wakeup_fd = -1;
1599 return ret;
1600 }
1601
1602 int lttng_ust_ctl_stream_close_wait_fd(struct lttng_ust_ctl_consumer_stream *stream)
1603 {
1604 struct lttng_ust_ring_buffer_channel *chan;
1605
1606 chan = stream->chan->chan->priv->rb_chan;
1607 return ring_buffer_stream_close_wait_fd(&chan->backend.config,
1608 chan, chan->handle, stream->cpu);
1609 }
1610
1611 int lttng_ust_ctl_stream_close_wakeup_fd(struct lttng_ust_ctl_consumer_stream *stream)
1612 {
1613 struct lttng_ust_ring_buffer_channel *chan;
1614
1615 chan = stream->chan->chan->priv->rb_chan;
1616 return ring_buffer_stream_close_wakeup_fd(&chan->backend.config,
1617 chan, chan->handle, stream->cpu);
1618 }
1619
1620 struct lttng_ust_ctl_consumer_stream *
1621 lttng_ust_ctl_create_stream(struct lttng_ust_ctl_consumer_channel *channel,
1622 int cpu)
1623 {
1624 struct lttng_ust_ctl_consumer_stream *stream;
1625 struct lttng_ust_shm_handle *handle;
1626 struct lttng_ust_ring_buffer_channel *rb_chan;
1627 int shm_fd, wait_fd, wakeup_fd;
1628 uint64_t memory_map_size;
1629 void *memory_map_addr;
1630 struct lttng_ust_ring_buffer *buf;
1631 int ret;
1632
1633 if (!channel)
1634 return NULL;
1635 rb_chan = channel->chan->priv->rb_chan;
1636 handle = rb_chan->handle;
1637 if (!handle)
1638 return NULL;
1639
1640 buf = channel_get_ring_buffer(&rb_chan->backend.config,
1641 rb_chan, cpu, handle, &shm_fd, &wait_fd,
1642 &wakeup_fd, &memory_map_size, &memory_map_addr);
1643 if (!buf)
1644 return NULL;
1645 ret = lib_ring_buffer_open_read(buf, handle);
1646 if (ret)
1647 return NULL;
1648
1649 stream = zmalloc(sizeof(*stream));
1650 if (!stream)
1651 goto alloc_error;
1652 stream->buf = buf;
1653 stream->chan = channel;
1654 stream->shm_fd = shm_fd;
1655 stream->wait_fd = wait_fd;
1656 stream->wakeup_fd = wakeup_fd;
1657 stream->memory_map_size = memory_map_size;
1658 stream->memory_map_addr = memory_map_addr;
1659 stream->cpu = cpu;
1660 return stream;
1661
1662 alloc_error:
1663 return NULL;
1664 }
1665
1666 void lttng_ust_ctl_destroy_stream(struct lttng_ust_ctl_consumer_stream *stream)
1667 {
1668 struct lttng_ust_ring_buffer *buf;
1669 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1670
1671 assert(stream);
1672 buf = stream->buf;
1673 consumer_chan = stream->chan;
1674 (void) lttng_ust_ctl_stream_close_wait_fd(stream);
1675 (void) lttng_ust_ctl_stream_close_wakeup_fd(stream);
1676 lib_ring_buffer_release_read(buf, consumer_chan->chan->priv->rb_chan->handle);
1677 free(stream);
1678 }
1679
1680 int lttng_ust_ctl_channel_get_wait_fd(struct lttng_ust_ctl_consumer_channel *chan)
1681 {
1682 if (!chan)
1683 return -EINVAL;
1684 return shm_get_wait_fd(chan->chan->priv->rb_chan->handle,
1685 &chan->chan->priv->rb_chan->handle->chan._ref);
1686 }
1687
1688 int lttng_ust_ctl_channel_get_wakeup_fd(struct lttng_ust_ctl_consumer_channel *chan)
1689 {
1690 if (!chan)
1691 return -EINVAL;
1692 return shm_get_wakeup_fd(chan->chan->priv->rb_chan->handle,
1693 &chan->chan->priv->rb_chan->handle->chan._ref);
1694 }
1695
1696 int lttng_ust_ctl_stream_get_wait_fd(struct lttng_ust_ctl_consumer_stream *stream)
1697 {
1698 struct lttng_ust_ring_buffer *buf;
1699 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1700
1701 if (!stream)
1702 return -EINVAL;
1703 buf = stream->buf;
1704 consumer_chan = stream->chan;
1705 return shm_get_wait_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref);
1706 }
1707
1708 int lttng_ust_ctl_stream_get_wakeup_fd(struct lttng_ust_ctl_consumer_stream *stream)
1709 {
1710 struct lttng_ust_ring_buffer *buf;
1711 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1712
1713 if (!stream)
1714 return -EINVAL;
1715 buf = stream->buf;
1716 consumer_chan = stream->chan;
1717 return shm_get_wakeup_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref);
1718 }
1719
1720 /* For mmap mode, readable without "get" operation */
1721
1722 void *lttng_ust_ctl_get_mmap_base(struct lttng_ust_ctl_consumer_stream *stream)
1723 {
1724 struct lttng_ust_ring_buffer *buf;
1725 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1726 struct lttng_ust_sigbus_range range;
1727 void *p;
1728
1729 if (!stream)
1730 return NULL;
1731 buf = stream->buf;
1732 consumer_chan = stream->chan;
1733 if (sigbus_begin())
1734 return NULL;
1735 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1736 stream->memory_map_size);
1737 p = shmp(consumer_chan->chan->priv->rb_chan->handle, buf->backend.memory_map);
1738 lttng_ust_sigbus_del_range(&range);
1739 sigbus_end();
1740 return p; /* Users of this pointer should check for sigbus. */
1741 }
1742
1743 /* returns the length to mmap. */
1744 int lttng_ust_ctl_get_mmap_len(struct lttng_ust_ctl_consumer_stream *stream,
1745 unsigned long *len)
1746 {
1747 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1748 unsigned long mmap_buf_len;
1749 struct lttng_ust_ring_buffer_channel *rb_chan;
1750
1751 if (!stream)
1752 return -EINVAL;
1753 consumer_chan = stream->chan;
1754 rb_chan = consumer_chan->chan->priv->rb_chan;
1755 if (rb_chan->backend.config.output != RING_BUFFER_MMAP)
1756 return -EINVAL;
1757 mmap_buf_len = rb_chan->backend.buf_size;
1758 if (rb_chan->backend.extra_reader_sb)
1759 mmap_buf_len += rb_chan->backend.subbuf_size;
1760 if (mmap_buf_len > INT_MAX)
1761 return -EFBIG;
1762 *len = mmap_buf_len;
1763 return 0;
1764 }
1765
1766 /* returns the maximum size for sub-buffers. */
1767 int lttng_ust_ctl_get_max_subbuf_size(struct lttng_ust_ctl_consumer_stream *stream,
1768 unsigned long *len)
1769 {
1770 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1771 struct lttng_ust_ring_buffer_channel *rb_chan;
1772
1773 if (!stream)
1774 return -EINVAL;
1775 consumer_chan = stream->chan;
1776 rb_chan = consumer_chan->chan->priv->rb_chan;
1777 *len = rb_chan->backend.subbuf_size;
1778 return 0;
1779 }
1780
1781 /*
1782 * For mmap mode, operate on the current packet (between get/put or
1783 * get_next/put_next).
1784 */
1785
1786 /* returns the offset of the subbuffer belonging to the mmap reader. */
1787 int lttng_ust_ctl_get_mmap_read_offset(struct lttng_ust_ctl_consumer_stream *stream,
1788 unsigned long *off)
1789 {
1790 struct lttng_ust_ring_buffer_channel *rb_chan;
1791 unsigned long sb_bindex;
1792 struct lttng_ust_ring_buffer *buf;
1793 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1794 struct lttng_ust_ring_buffer_backend_pages_shmp *barray_idx;
1795 struct lttng_ust_ring_buffer_backend_pages *pages;
1796 struct lttng_ust_sigbus_range range;
1797 int ret;
1798
1799 if (!stream)
1800 return -EINVAL;
1801 buf = stream->buf;
1802 consumer_chan = stream->chan;
1803 rb_chan = consumer_chan->chan->priv->rb_chan;
1804 if (rb_chan->backend.config.output != RING_BUFFER_MMAP)
1805 return -EINVAL;
1806
1807 if (sigbus_begin())
1808 return -EIO;
1809 ret = 0;
1810 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1811 stream->memory_map_size);
1812
1813 sb_bindex = subbuffer_id_get_index(&rb_chan->backend.config,
1814 buf->backend.buf_rsb.id);
1815 barray_idx = shmp_index(rb_chan->handle, buf->backend.array,
1816 sb_bindex);
1817 if (!barray_idx) {
1818 ret = -EINVAL;
1819 goto end;
1820 }
1821 pages = shmp(rb_chan->handle, barray_idx->shmp);
1822 if (!pages) {
1823 ret = -EINVAL;
1824 goto end;
1825 }
1826 *off = pages->mmap_offset;
1827 end:
1828 lttng_ust_sigbus_del_range(&range);
1829 sigbus_end();
1830 return ret;
1831 }
1832
1833 /* returns the size of the current sub-buffer, without padding (for mmap). */
1834 int lttng_ust_ctl_get_subbuf_size(struct lttng_ust_ctl_consumer_stream *stream,
1835 unsigned long *len)
1836 {
1837 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1838 struct lttng_ust_ring_buffer_channel *rb_chan;
1839 struct lttng_ust_ring_buffer *buf;
1840 struct lttng_ust_sigbus_range range;
1841
1842 if (!stream)
1843 return -EINVAL;
1844
1845 buf = stream->buf;
1846 consumer_chan = stream->chan;
1847 rb_chan = consumer_chan->chan->priv->rb_chan;
1848 if (sigbus_begin())
1849 return -EIO;
1850 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1851 stream->memory_map_size);
1852 *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf,
1853 rb_chan->handle);
1854 lttng_ust_sigbus_del_range(&range);
1855 sigbus_end();
1856 return 0;
1857 }
1858
1859 /* returns the size of the current sub-buffer, without padding (for mmap). */
1860 int lttng_ust_ctl_get_padded_subbuf_size(struct lttng_ust_ctl_consumer_stream *stream,
1861 unsigned long *len)
1862 {
1863 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1864 struct lttng_ust_ring_buffer_channel *rb_chan;
1865 struct lttng_ust_ring_buffer *buf;
1866 struct lttng_ust_sigbus_range range;
1867
1868 if (!stream)
1869 return -EINVAL;
1870 buf = stream->buf;
1871 consumer_chan = stream->chan;
1872 rb_chan = consumer_chan->chan->priv->rb_chan;
1873 if (sigbus_begin())
1874 return -EIO;
1875 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1876 stream->memory_map_size);
1877 *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf,
1878 rb_chan->handle);
1879 *len = LTTNG_UST_PAGE_ALIGN(*len);
1880 lttng_ust_sigbus_del_range(&range);
1881 sigbus_end();
1882 return 0;
1883 }
1884
1885 /* Get exclusive read access to the next sub-buffer that can be read. */
1886 int lttng_ust_ctl_get_next_subbuf(struct lttng_ust_ctl_consumer_stream *stream)
1887 {
1888 struct lttng_ust_ring_buffer *buf;
1889 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1890 struct lttng_ust_sigbus_range range;
1891 int ret;
1892
1893 if (!stream)
1894 return -EINVAL;
1895 buf = stream->buf;
1896 consumer_chan = stream->chan;
1897 if (sigbus_begin())
1898 return -EIO;
1899 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1900 stream->memory_map_size);
1901 ret = lib_ring_buffer_get_next_subbuf(buf,
1902 consumer_chan->chan->priv->rb_chan->handle);
1903 lttng_ust_sigbus_del_range(&range);
1904 sigbus_end();
1905 return ret;
1906 }
1907
1908 /* Release exclusive sub-buffer access, move consumer forward. */
1909 int lttng_ust_ctl_put_next_subbuf(struct lttng_ust_ctl_consumer_stream *stream)
1910 {
1911 struct lttng_ust_ring_buffer *buf;
1912 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1913 struct lttng_ust_sigbus_range range;
1914
1915 if (!stream)
1916 return -EINVAL;
1917 buf = stream->buf;
1918 consumer_chan = stream->chan;
1919 if (sigbus_begin())
1920 return -EIO;
1921 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1922 stream->memory_map_size);
1923 lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle);
1924 lttng_ust_sigbus_del_range(&range);
1925 sigbus_end();
1926 return 0;
1927 }
1928
1929 /* snapshot */
1930
1931 /* Get a snapshot of the current ring buffer producer and consumer positions */
1932 int lttng_ust_ctl_snapshot(struct lttng_ust_ctl_consumer_stream *stream)
1933 {
1934 struct lttng_ust_ring_buffer *buf;
1935 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1936 struct lttng_ust_sigbus_range range;
1937 int ret;
1938
1939 if (!stream)
1940 return -EINVAL;
1941 buf = stream->buf;
1942 consumer_chan = stream->chan;
1943 if (sigbus_begin())
1944 return -EIO;
1945 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1946 stream->memory_map_size);
1947 ret = lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
1948 &buf->prod_snapshot, consumer_chan->chan->priv->rb_chan->handle);
1949 lttng_ust_sigbus_del_range(&range);
1950 sigbus_end();
1951 return ret;
1952 }
1953
1954 /*
1955 * Get a snapshot of the current ring buffer producer and consumer positions
1956 * even if the consumed and produced positions are contained within the same
1957 * subbuffer.
1958 */
1959 int lttng_ust_ctl_snapshot_sample_positions(struct lttng_ust_ctl_consumer_stream *stream)
1960 {
1961 struct lttng_ust_ring_buffer *buf;
1962 struct lttng_ust_ctl_consumer_channel *consumer_chan;
1963 struct lttng_ust_sigbus_range range;
1964 int ret;
1965
1966 if (!stream)
1967 return -EINVAL;
1968 buf = stream->buf;
1969 consumer_chan = stream->chan;
1970 if (sigbus_begin())
1971 return -EIO;
1972 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
1973 stream->memory_map_size);
1974 ret = lib_ring_buffer_snapshot_sample_positions(buf,
1975 &buf->cons_snapshot, &buf->prod_snapshot,
1976 consumer_chan->chan->priv->rb_chan->handle);
1977 lttng_ust_sigbus_del_range(&range);
1978 sigbus_end();
1979 return ret;
1980 }
1981
1982 /* Get the consumer position (iteration start) */
1983 int lttng_ust_ctl_snapshot_get_consumed(struct lttng_ust_ctl_consumer_stream *stream,
1984 unsigned long *pos)
1985 {
1986 struct lttng_ust_ring_buffer *buf;
1987
1988 if (!stream)
1989 return -EINVAL;
1990 buf = stream->buf;
1991 *pos = buf->cons_snapshot;
1992 return 0;
1993 }
1994
1995 /* Get the producer position (iteration end) */
1996 int lttng_ust_ctl_snapshot_get_produced(struct lttng_ust_ctl_consumer_stream *stream,
1997 unsigned long *pos)
1998 {
1999 struct lttng_ust_ring_buffer *buf;
2000
2001 if (!stream)
2002 return -EINVAL;
2003 buf = stream->buf;
2004 *pos = buf->prod_snapshot;
2005 return 0;
2006 }
2007
2008 /* Get exclusive read access to the specified sub-buffer position */
2009 int lttng_ust_ctl_get_subbuf(struct lttng_ust_ctl_consumer_stream *stream,
2010 unsigned long *pos)
2011 {
2012 struct lttng_ust_ring_buffer *buf;
2013 struct lttng_ust_ctl_consumer_channel *consumer_chan;
2014 struct lttng_ust_sigbus_range range;
2015 int ret;
2016
2017 if (!stream)
2018 return -EINVAL;
2019 buf = stream->buf;
2020 consumer_chan = stream->chan;
2021 if (sigbus_begin())
2022 return -EIO;
2023 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2024 stream->memory_map_size);
2025 ret = lib_ring_buffer_get_subbuf(buf, *pos,
2026 consumer_chan->chan->priv->rb_chan->handle);
2027 lttng_ust_sigbus_del_range(&range);
2028 sigbus_end();
2029 return ret;
2030 }
2031
2032 /* Release exclusive sub-buffer access */
2033 int lttng_ust_ctl_put_subbuf(struct lttng_ust_ctl_consumer_stream *stream)
2034 {
2035 struct lttng_ust_ring_buffer *buf;
2036 struct lttng_ust_ctl_consumer_channel *consumer_chan;
2037 struct lttng_ust_sigbus_range range;
2038
2039 if (!stream)
2040 return -EINVAL;
2041 buf = stream->buf;
2042 consumer_chan = stream->chan;
2043 if (sigbus_begin())
2044 return -EIO;
2045 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2046 stream->memory_map_size);
2047 lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle);
2048 lttng_ust_sigbus_del_range(&range);
2049 sigbus_end();
2050 return 0;
2051 }
2052
2053 int lttng_ust_ctl_flush_buffer(struct lttng_ust_ctl_consumer_stream *stream,
2054 int producer_active)
2055 {
2056 struct lttng_ust_ring_buffer *buf;
2057 struct lttng_ust_ctl_consumer_channel *consumer_chan;
2058 struct lttng_ust_sigbus_range range;
2059
2060 assert(stream);
2061 buf = stream->buf;
2062 consumer_chan = stream->chan;
2063 if (sigbus_begin())
2064 return -EIO;
2065 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2066 stream->memory_map_size);
2067 lib_ring_buffer_switch_slow(buf,
2068 producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
2069 consumer_chan->chan->priv->rb_chan->handle);
2070 lttng_ust_sigbus_del_range(&range);
2071 sigbus_end();
2072 return 0;
2073 }
2074
2075 int lttng_ust_ctl_clear_buffer(struct lttng_ust_ctl_consumer_stream *stream)
2076 {
2077 struct lttng_ust_ring_buffer *buf;
2078 struct lttng_ust_ctl_consumer_channel *consumer_chan;
2079 struct lttng_ust_sigbus_range range;
2080
2081 assert(stream);
2082 buf = stream->buf;
2083 consumer_chan = stream->chan;
2084 if (sigbus_begin())
2085 return -EIO;
2086 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2087 stream->memory_map_size);
2088 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE,
2089 consumer_chan->chan->priv->rb_chan->handle);
2090 lib_ring_buffer_clear_reader(buf, consumer_chan->chan->priv->rb_chan->handle);
2091 lttng_ust_sigbus_del_range(&range);
2092 sigbus_end();
2093 return 0;
2094 }
2095
2096 static
2097 struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb(
2098 struct lttng_ust_ring_buffer *buf __attribute__((unused)),
2099 struct lttng_ust_ring_buffer_channel *chan)
2100 {
2101 const struct lttng_ust_ring_buffer_config *config;
2102 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2103
2104 config = &chan->backend.config;
2105 if (!config->cb_ptr)
2106 return NULL;
2107 client_cb = caa_container_of(config->cb_ptr,
2108 struct lttng_ust_client_lib_ring_buffer_client_cb,
2109 parent);
2110 return client_cb;
2111 }
2112
2113 int lttng_ust_ctl_get_timestamp_begin(struct lttng_ust_ctl_consumer_stream *stream,
2114 uint64_t *timestamp_begin)
2115 {
2116 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2117 struct lttng_ust_ring_buffer_channel *chan;
2118 struct lttng_ust_ring_buffer *buf;
2119 struct lttng_ust_sigbus_range range;
2120 int ret;
2121
2122 if (!stream || !timestamp_begin)
2123 return -EINVAL;
2124 buf = stream->buf;
2125 chan = stream->chan->chan->priv->rb_chan;
2126 client_cb = get_client_cb(buf, chan);
2127 if (!client_cb)
2128 return -ENOSYS;
2129 if (sigbus_begin())
2130 return -EIO;
2131 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2132 stream->memory_map_size);
2133 ret = client_cb->timestamp_begin(buf, chan, timestamp_begin);
2134 lttng_ust_sigbus_del_range(&range);
2135 sigbus_end();
2136 return ret;
2137 }
2138
2139 int lttng_ust_ctl_get_timestamp_end(struct lttng_ust_ctl_consumer_stream *stream,
2140 uint64_t *timestamp_end)
2141 {
2142 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2143 struct lttng_ust_ring_buffer_channel *chan;
2144 struct lttng_ust_ring_buffer *buf;
2145 struct lttng_ust_sigbus_range range;
2146 int ret;
2147
2148 if (!stream || !timestamp_end)
2149 return -EINVAL;
2150 buf = stream->buf;
2151 chan = stream->chan->chan->priv->rb_chan;
2152 client_cb = get_client_cb(buf, chan);
2153 if (!client_cb)
2154 return -ENOSYS;
2155 if (sigbus_begin())
2156 return -EIO;
2157 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2158 stream->memory_map_size);
2159 ret = client_cb->timestamp_end(buf, chan, timestamp_end);
2160 lttng_ust_sigbus_del_range(&range);
2161 sigbus_end();
2162 return ret;
2163 }
2164
2165 int lttng_ust_ctl_get_events_discarded(struct lttng_ust_ctl_consumer_stream *stream,
2166 uint64_t *events_discarded)
2167 {
2168 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2169 struct lttng_ust_ring_buffer_channel *chan;
2170 struct lttng_ust_ring_buffer *buf;
2171 struct lttng_ust_sigbus_range range;
2172 int ret;
2173
2174 if (!stream || !events_discarded)
2175 return -EINVAL;
2176 buf = stream->buf;
2177 chan = stream->chan->chan->priv->rb_chan;
2178 client_cb = get_client_cb(buf, chan);
2179 if (!client_cb)
2180 return -ENOSYS;
2181 if (sigbus_begin())
2182 return -EIO;
2183 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2184 stream->memory_map_size);
2185 ret = client_cb->events_discarded(buf, chan, events_discarded);
2186 lttng_ust_sigbus_del_range(&range);
2187 sigbus_end();
2188 return ret;
2189 }
2190
2191 int lttng_ust_ctl_get_content_size(struct lttng_ust_ctl_consumer_stream *stream,
2192 uint64_t *content_size)
2193 {
2194 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2195 struct lttng_ust_ring_buffer_channel *chan;
2196 struct lttng_ust_ring_buffer *buf;
2197 struct lttng_ust_sigbus_range range;
2198 int ret;
2199
2200 if (!stream || !content_size)
2201 return -EINVAL;
2202 buf = stream->buf;
2203 chan = stream->chan->chan->priv->rb_chan;
2204 client_cb = get_client_cb(buf, chan);
2205 if (!client_cb)
2206 return -ENOSYS;
2207 if (sigbus_begin())
2208 return -EIO;
2209 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2210 stream->memory_map_size);
2211 ret = client_cb->content_size(buf, chan, content_size);
2212 lttng_ust_sigbus_del_range(&range);
2213 sigbus_end();
2214 return ret;
2215 }
2216
2217 int lttng_ust_ctl_get_packet_size(struct lttng_ust_ctl_consumer_stream *stream,
2218 uint64_t *packet_size)
2219 {
2220 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2221 struct lttng_ust_ring_buffer_channel *chan;
2222 struct lttng_ust_ring_buffer *buf;
2223 struct lttng_ust_sigbus_range range;
2224 int ret;
2225
2226 if (!stream || !packet_size)
2227 return -EINVAL;
2228 buf = stream->buf;
2229 chan = stream->chan->chan->priv->rb_chan;
2230 client_cb = get_client_cb(buf, chan);
2231 if (!client_cb)
2232 return -ENOSYS;
2233 if (sigbus_begin())
2234 return -EIO;
2235 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2236 stream->memory_map_size);
2237 ret = client_cb->packet_size(buf, chan, packet_size);
2238 lttng_ust_sigbus_del_range(&range);
2239 sigbus_end();
2240 return ret;
2241 }
2242
2243 int lttng_ust_ctl_get_stream_id(struct lttng_ust_ctl_consumer_stream *stream,
2244 uint64_t *stream_id)
2245 {
2246 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2247 struct lttng_ust_ring_buffer_channel *chan;
2248 struct lttng_ust_ring_buffer *buf;
2249 struct lttng_ust_sigbus_range range;
2250 int ret;
2251
2252 if (!stream || !stream_id)
2253 return -EINVAL;
2254 buf = stream->buf;
2255 chan = stream->chan->chan->priv->rb_chan;
2256 client_cb = get_client_cb(buf, chan);
2257 if (!client_cb)
2258 return -ENOSYS;
2259 if (sigbus_begin())
2260 return -EIO;
2261 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2262 stream->memory_map_size);
2263 ret = client_cb->stream_id(buf, chan, stream_id);
2264 lttng_ust_sigbus_del_range(&range);
2265 sigbus_end();
2266 return ret;
2267 }
2268
2269 int lttng_ust_ctl_get_current_timestamp(struct lttng_ust_ctl_consumer_stream *stream,
2270 uint64_t *ts)
2271 {
2272 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2273 struct lttng_ust_ring_buffer_channel *chan;
2274 struct lttng_ust_ring_buffer *buf;
2275 struct lttng_ust_sigbus_range range;
2276 int ret;
2277
2278 if (!stream || !ts)
2279 return -EINVAL;
2280 buf = stream->buf;
2281 chan = stream->chan->chan->priv->rb_chan;
2282 client_cb = get_client_cb(buf, chan);
2283 if (!client_cb || !client_cb->current_timestamp)
2284 return -ENOSYS;
2285 if (sigbus_begin())
2286 return -EIO;
2287 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2288 stream->memory_map_size);
2289 ret = client_cb->current_timestamp(buf, chan, ts);
2290 lttng_ust_sigbus_del_range(&range);
2291 sigbus_end();
2292 return ret;
2293 }
2294
2295 int lttng_ust_ctl_get_sequence_number(struct lttng_ust_ctl_consumer_stream *stream,
2296 uint64_t *seq)
2297 {
2298 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2299 struct lttng_ust_ring_buffer_channel *chan;
2300 struct lttng_ust_ring_buffer *buf;
2301 struct lttng_ust_sigbus_range range;
2302 int ret;
2303
2304 if (!stream || !seq)
2305 return -EINVAL;
2306 buf = stream->buf;
2307 chan = stream->chan->chan->priv->rb_chan;
2308 client_cb = get_client_cb(buf, chan);
2309 if (!client_cb || !client_cb->sequence_number)
2310 return -ENOSYS;
2311 if (sigbus_begin())
2312 return -EIO;
2313 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2314 stream->memory_map_size);
2315 ret = client_cb->sequence_number(buf, chan, seq);
2316 lttng_ust_sigbus_del_range(&range);
2317 sigbus_end();
2318 return ret;
2319 }
2320
2321 int lttng_ust_ctl_get_instance_id(struct lttng_ust_ctl_consumer_stream *stream,
2322 uint64_t *id)
2323 {
2324 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
2325 struct lttng_ust_ring_buffer_channel *chan;
2326 struct lttng_ust_ring_buffer *buf;
2327 struct lttng_ust_sigbus_range range;
2328 int ret;
2329
2330 if (!stream || !id)
2331 return -EINVAL;
2332 buf = stream->buf;
2333 chan = stream->chan->chan->priv->rb_chan;
2334 client_cb = get_client_cb(buf, chan);
2335 if (!client_cb)
2336 return -ENOSYS;
2337 if (sigbus_begin())
2338 return -EIO;
2339 lttng_ust_sigbus_add_range(&range, stream->memory_map_addr,
2340 stream->memory_map_size);
2341 ret = client_cb->instance_id(buf, chan, id);
2342 lttng_ust_sigbus_del_range(&range);
2343 sigbus_end();
2344 return ret;
2345 }
2346
2347 #ifdef HAVE_LINUX_PERF_EVENT_H
2348
2349 int lttng_ust_ctl_has_perf_counters(void)
2350 {
2351 return 1;
2352 }
2353
2354 #else
2355
2356 int lttng_ust_ctl_has_perf_counters(void)
2357 {
2358 return 0;
2359 }
2360
2361 #endif
2362
2363 #ifdef __linux__
2364 /*
2365 * Override application pid/uid/gid with unix socket credentials. If
2366 * the application announced a pid matching our view, it means it is
2367 * within the same pid namespace, so expose the ppid provided by the
2368 * application.
2369 */
2370 static
2371 int get_cred(int sock,
2372 const struct lttng_ust_ctl_reg_msg *reg_msg,
2373 uint32_t *pid,
2374 uint32_t *ppid,
2375 uint32_t *uid,
2376 uint32_t *gid)
2377 {
2378 struct ucred ucred;
2379 socklen_t ucred_len = sizeof(struct ucred);
2380 int ret;
2381
2382 ret = getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &ucred, &ucred_len);
2383 if (ret) {
2384 return -LTTNG_UST_ERR_PEERCRED;
2385 }
2386 DBG("Unix socket peercred [ pid: %u, uid: %u, gid: %u ], "
2387 "application registered claiming [ pid: %u, ppid: %u, uid: %u, gid: %u ]",
2388 ucred.pid, ucred.uid, ucred.gid,
2389 reg_msg->pid, reg_msg->ppid, reg_msg->uid, reg_msg->gid);
2390 if (!ucred.pid) {
2391 ERR("Unix socket credential pid=0. Refusing application in distinct, non-nested pid namespace.");
2392 return -LTTNG_UST_ERR_PEERCRED_PID;
2393 }
2394 *pid = ucred.pid;
2395 *uid = ucred.uid;
2396 *gid = ucred.gid;
2397 if (ucred.pid == reg_msg->pid) {
2398 *ppid = reg_msg->ppid;
2399 } else {
2400 *ppid = 0;
2401 }
2402 return 0;
2403 }
2404 #elif defined(__FreeBSD__)
2405 #include <sys/ucred.h>
2406 #include <sys/un.h>
2407
2408 /*
2409 * Override application uid/gid with unix socket credentials. Use the
2410 * first group of the cr_groups.
2411 */
2412 static
2413 int get_cred(int sock,
2414 const struct lttng_ust_ctl_reg_msg *reg_msg,
2415 uint32_t *pid,
2416 uint32_t *ppid,
2417 uint32_t *uid,
2418 uint32_t *gid)
2419 {
2420 struct xucred xucred;
2421 socklen_t xucred_len = sizeof(struct xucred);
2422 int ret;
2423
2424 ret = getsockopt(sock, SOL_LOCAL, LOCAL_PEERCRED, &xucred, &xucred_len);
2425 if (ret) {
2426 return -LTTNG_UST_ERR_PEERCRED;
2427 }
2428 if (xucred.cr_version != XUCRED_VERSION || xucred.cr_ngroups < 1) {
2429 return -LTTNG_UST_ERR_PEERCRED;
2430 }
2431 DBG("Unix socket peercred [ pid: %u, uid: %u, gid: %u ], "
2432 "application registered claiming [ pid: %u, ppid: %u, uid: %u, gid: %u ]",
2433 xucred.cr_pid, xucred.cr_uid, xucred.cr_groups[0],
2434 reg_msg->pid, reg_msg->ppid, reg_msg->uid, reg_msg->gid);
2435 *pid = xucred.cr_pid;
2436 *uid = xucred.cr_uid;
2437 *gid = xucred.cr_groups[0];
2438 if (xucred.cr_pid == reg_msg->pid) {
2439 *ppid = reg_msg->ppid;
2440 } else {
2441 *ppid = 0;
2442 }
2443 return 0;
2444 }
2445 #else
2446 #warning "Using insecure fallback: trusting user id provided by registered applications. Please consider implementing use of unix socket credentials on your platform."
2447 static
2448 int get_cred(int sock,
2449 const struct lttng_ust_ctl_reg_msg *reg_msg,
2450 uint32_t *pid,
2451 uint32_t *ppid,
2452 uint32_t *uid,
2453 uint32_t *gid)
2454 {
2455 DBG("Application registered claiming [ pid: %u, ppid: %d, uid: %u, gid: %u ]",
2456 reg_msg->pid, reg_msg->ppid, reg_msg->uid, reg_msg->gid);
2457 *pid = reg_msg->pid;
2458 *ppid = reg_msg->ppid;
2459 *uid = reg_msg->uid;
2460 *gid = reg_msg->gid;
2461 return 0;
2462 }
2463 #endif
2464
2465 /*
2466 * Returns 0 on success, negative error value on error.
2467 */
2468 int lttng_ust_ctl_recv_reg_msg(int sock,
2469 enum lttng_ust_ctl_socket_type *type,
2470 uint32_t *major,
2471 uint32_t *minor,
2472 uint32_t *pid,
2473 uint32_t *ppid,
2474 uint32_t *uid,
2475 uint32_t *gid,
2476 uint32_t *bits_per_long,
2477 uint32_t *uint8_t_alignment,
2478 uint32_t *uint16_t_alignment,
2479 uint32_t *uint32_t_alignment,
2480 uint32_t *uint64_t_alignment,
2481 uint32_t *long_alignment,
2482 int *byte_order,
2483 char *name)
2484 {
2485 ssize_t len;
2486 struct lttng_ust_ctl_reg_msg reg_msg;
2487
2488 len = ustcomm_recv_unix_sock(sock, &reg_msg, sizeof(reg_msg));
2489 if (len > 0 && len != sizeof(reg_msg))
2490 return -EIO;
2491 if (len == 0)
2492 return -EPIPE;
2493 if (len < 0)
2494 return len;
2495
2496 if (reg_msg.magic == LTTNG_UST_ABI_COMM_MAGIC) {
2497 *byte_order = LTTNG_UST_BYTE_ORDER == LTTNG_UST_BIG_ENDIAN ?
2498 LTTNG_UST_BIG_ENDIAN : LTTNG_UST_LITTLE_ENDIAN;
2499 } else if (reg_msg.magic == lttng_ust_bswap_32(LTTNG_UST_ABI_COMM_MAGIC)) {
2500 *byte_order = LTTNG_UST_BYTE_ORDER == LTTNG_UST_BIG_ENDIAN ?
2501 LTTNG_UST_LITTLE_ENDIAN : LTTNG_UST_BIG_ENDIAN;
2502 } else {
2503 return -LTTNG_UST_ERR_INVAL_MAGIC;
2504 }
2505 switch (reg_msg.socket_type) {
2506 case 0: *type = LTTNG_UST_CTL_SOCKET_CMD;
2507 break;
2508 case 1: *type = LTTNG_UST_CTL_SOCKET_NOTIFY;
2509 break;
2510 default:
2511 return -LTTNG_UST_ERR_INVAL_SOCKET_TYPE;
2512 }
2513 *major = reg_msg.major;
2514 *minor = reg_msg.minor;
2515 *bits_per_long = reg_msg.bits_per_long;
2516 *uint8_t_alignment = reg_msg.uint8_t_alignment;
2517 *uint16_t_alignment = reg_msg.uint16_t_alignment;
2518 *uint32_t_alignment = reg_msg.uint32_t_alignment;
2519 *uint64_t_alignment = reg_msg.uint64_t_alignment;
2520 *long_alignment = reg_msg.long_alignment;
2521 memcpy(name, reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
2522 if (reg_msg.major < LTTNG_UST_ABI_MAJOR_VERSION_OLDEST_COMPATIBLE ||
2523 reg_msg.major > LTTNG_UST_ABI_MAJOR_VERSION) {
2524 return -LTTNG_UST_ERR_UNSUP_MAJOR;
2525 }
2526 return get_cred(sock, &reg_msg, pid, ppid, uid, gid);
2527 }
2528
2529 int lttng_ust_ctl_recv_notify(int sock, enum lttng_ust_ctl_notify_cmd *notify_cmd)
2530 {
2531 struct ustcomm_notify_hdr header;
2532 ssize_t len;
2533
2534 len = ustcomm_recv_unix_sock(sock, &header, sizeof(header));
2535 if (len > 0 && len != sizeof(header))
2536 return -EIO;
2537 if (len == 0)
2538 return -EPIPE;
2539 if (len < 0)
2540 return len;
2541 switch (header.notify_cmd) {
2542 case 0:
2543 *notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_EVENT;
2544 break;
2545 case 1:
2546 *notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL;
2547 break;
2548 case 2:
2549 *notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_ENUM;
2550 break;
2551 default:
2552 return -EINVAL;
2553 }
2554 return 0;
2555 }
2556
2557 /*
2558 * Returns 0 on success, negative error value on error.
2559 */
2560 int lttng_ust_ctl_recv_register_event(int sock,
2561 int *session_objd,
2562 int *channel_objd,
2563 char *event_name,
2564 int *loglevel,
2565 char **signature,
2566 size_t *nr_fields,
2567 struct lttng_ust_ctl_field **fields,
2568 char **model_emf_uri)
2569 {
2570 ssize_t len;
2571 struct ustcomm_notify_event_msg msg;
2572 size_t signature_len, fields_len, model_emf_uri_len;
2573 char *a_sign = NULL, *a_model_emf_uri = NULL;
2574 struct lttng_ust_ctl_field *a_fields = NULL;
2575
2576 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2577 if (len > 0 && len != sizeof(msg))
2578 return -EIO;
2579 if (len == 0)
2580 return -EPIPE;
2581 if (len < 0)
2582 return len;
2583
2584 *session_objd = msg.session_objd;
2585 *channel_objd = msg.channel_objd;
2586 strncpy(event_name, msg.event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
2587 event_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
2588 *loglevel = msg.loglevel;
2589 signature_len = msg.signature_len;
2590 fields_len = msg.fields_len;
2591
2592 if (fields_len % sizeof(*a_fields) != 0) {
2593 return -EINVAL;
2594 }
2595
2596 model_emf_uri_len = msg.model_emf_uri_len;
2597
2598 /* recv signature. contains at least \0. */
2599 a_sign = zmalloc(signature_len);
2600 if (!a_sign)
2601 return -ENOMEM;
2602 len = ustcomm_recv_unix_sock(sock, a_sign, signature_len);
2603 if (len > 0 && len != signature_len) {
2604 len = -EIO;
2605 goto signature_error;
2606 }
2607 if (len == 0) {
2608 len = -EPIPE;
2609 goto signature_error;
2610 }
2611 if (len < 0) {
2612 goto signature_error;
2613 }
2614 /* Enforce end of string */
2615 a_sign[signature_len - 1] = '\0';
2616
2617 /* recv fields */
2618 if (fields_len) {
2619 a_fields = zmalloc(fields_len);
2620 if (!a_fields) {
2621 len = -ENOMEM;
2622 goto signature_error;
2623 }
2624 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2625 if (len > 0 && len != fields_len) {
2626 len = -EIO;
2627 goto fields_error;
2628 }
2629 if (len == 0) {
2630 len = -EPIPE;
2631 goto fields_error;
2632 }
2633 if (len < 0) {
2634 goto fields_error;
2635 }
2636 }
2637
2638 if (model_emf_uri_len) {
2639 /* recv model_emf_uri_len */
2640 a_model_emf_uri = zmalloc(model_emf_uri_len);
2641 if (!a_model_emf_uri) {
2642 len = -ENOMEM;
2643 goto fields_error;
2644 }
2645 len = ustcomm_recv_unix_sock(sock, a_model_emf_uri,
2646 model_emf_uri_len);
2647 if (len > 0 && len != model_emf_uri_len) {
2648 len = -EIO;
2649 goto model_error;
2650 }
2651 if (len == 0) {
2652 len = -EPIPE;
2653 goto model_error;
2654 }
2655 if (len < 0) {
2656 goto model_error;
2657 }
2658 /* Enforce end of string */
2659 a_model_emf_uri[model_emf_uri_len - 1] = '\0';
2660 }
2661
2662 *signature = a_sign;
2663 *nr_fields = fields_len / sizeof(*a_fields);
2664 *fields = a_fields;
2665 *model_emf_uri = a_model_emf_uri;
2666
2667 return 0;
2668
2669 model_error:
2670 free(a_model_emf_uri);
2671 fields_error:
2672 free(a_fields);
2673 signature_error:
2674 free(a_sign);
2675 return len;
2676 }
2677
2678 /*
2679 * Returns 0 on success, negative error value on error.
2680 */
2681 int lttng_ust_ctl_reply_register_event(int sock,
2682 uint32_t id,
2683 int ret_code)
2684 {
2685 ssize_t len;
2686 struct {
2687 struct ustcomm_notify_hdr header;
2688 struct ustcomm_notify_event_reply r;
2689 } reply;
2690
2691 memset(&reply, 0, sizeof(reply));
2692 reply.header.notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_EVENT;
2693 reply.r.ret_code = ret_code;
2694 reply.r.event_id = id;
2695 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2696 if (len > 0 && len != sizeof(reply))
2697 return -EIO;
2698 if (len < 0)
2699 return len;
2700 return 0;
2701 }
2702
2703 /*
2704 * Returns 0 on success, negative UST or system error value on error.
2705 */
2706 int lttng_ust_ctl_recv_register_enum(int sock,
2707 int *session_objd,
2708 char *enum_name,
2709 struct lttng_ust_ctl_enum_entry **entries,
2710 size_t *nr_entries)
2711 {
2712 ssize_t len;
2713 struct ustcomm_notify_enum_msg msg;
2714 size_t entries_len;
2715 struct lttng_ust_ctl_enum_entry *a_entries = NULL;
2716
2717 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2718 if (len > 0 && len != sizeof(msg))
2719 return -EIO;
2720 if (len == 0)
2721 return -EPIPE;
2722 if (len < 0)
2723 return len;
2724
2725 *session_objd = msg.session_objd;
2726 strncpy(enum_name, msg.enum_name, LTTNG_UST_ABI_SYM_NAME_LEN);
2727 enum_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
2728 entries_len = msg.entries_len;
2729
2730 if (entries_len % sizeof(*a_entries) != 0) {
2731 return -EINVAL;
2732 }
2733
2734 /* recv entries */
2735 if (entries_len) {
2736 a_entries = zmalloc(entries_len);
2737 if (!a_entries)
2738 return -ENOMEM;
2739 len = ustcomm_recv_unix_sock(sock, a_entries, entries_len);
2740 if (len > 0 && len != entries_len) {
2741 len = -EIO;
2742 goto entries_error;
2743 }
2744 if (len == 0) {
2745 len = -EPIPE;
2746 goto entries_error;
2747 }
2748 if (len < 0) {
2749 goto entries_error;
2750 }
2751 }
2752 *nr_entries = entries_len / sizeof(*a_entries);
2753 *entries = a_entries;
2754
2755 return 0;
2756
2757 entries_error:
2758 free(a_entries);
2759 return len;
2760 }
2761
2762 /*
2763 * Returns 0 on success, negative error value on error.
2764 */
2765 int lttng_ust_ctl_reply_register_enum(int sock,
2766 uint64_t id,
2767 int ret_code)
2768 {
2769 ssize_t len;
2770 struct {
2771 struct ustcomm_notify_hdr header;
2772 struct ustcomm_notify_enum_reply r;
2773 } reply;
2774
2775 memset(&reply, 0, sizeof(reply));
2776 reply.header.notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_ENUM;
2777 reply.r.ret_code = ret_code;
2778 reply.r.enum_id = id;
2779 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2780 if (len > 0 && len != sizeof(reply))
2781 return -EIO;
2782 if (len < 0)
2783 return len;
2784 return 0;
2785 }
2786
2787 /*
2788 * Returns 0 on success, negative UST or system error value on error.
2789 */
2790 int lttng_ust_ctl_recv_register_channel(int sock,
2791 int *session_objd, /* session descriptor (output) */
2792 int *channel_objd, /* channel descriptor (output) */
2793 size_t *nr_fields,
2794 struct lttng_ust_ctl_field **fields)
2795 {
2796 ssize_t len;
2797 struct ustcomm_notify_channel_msg msg;
2798 size_t fields_len;
2799 struct lttng_ust_ctl_field *a_fields;
2800
2801 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2802 if (len > 0 && len != sizeof(msg))
2803 return -EIO;
2804 if (len == 0)
2805 return -EPIPE;
2806 if (len < 0)
2807 return len;
2808
2809 *session_objd = msg.session_objd;
2810 *channel_objd = msg.channel_objd;
2811 fields_len = msg.ctx_fields_len;
2812
2813 if (fields_len % sizeof(*a_fields) != 0) {
2814 return -EINVAL;
2815 }
2816
2817 /* recv fields */
2818 if (fields_len) {
2819 a_fields = zmalloc(fields_len);
2820 if (!a_fields) {
2821 len = -ENOMEM;
2822 goto alloc_error;
2823 }
2824 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2825 if (len > 0 && len != fields_len) {
2826 len = -EIO;
2827 goto fields_error;
2828 }
2829 if (len == 0) {
2830 len = -EPIPE;
2831 goto fields_error;
2832 }
2833 if (len < 0) {
2834 goto fields_error;
2835 }
2836 *fields = a_fields;
2837 } else {
2838 *fields = NULL;
2839 }
2840 *nr_fields = fields_len / sizeof(*a_fields);
2841 return 0;
2842
2843 fields_error:
2844 free(a_fields);
2845 alloc_error:
2846 return len;
2847 }
2848
2849 /*
2850 * Returns 0 on success, negative error value on error.
2851 */
2852 int lttng_ust_ctl_reply_register_channel(int sock,
2853 uint32_t chan_id,
2854 enum lttng_ust_ctl_channel_header header_type,
2855 int ret_code)
2856 {
2857 ssize_t len;
2858 struct {
2859 struct ustcomm_notify_hdr header;
2860 struct ustcomm_notify_channel_reply r;
2861 } reply;
2862
2863 memset(&reply, 0, sizeof(reply));
2864 reply.header.notify_cmd = LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL;
2865 reply.r.ret_code = ret_code;
2866 reply.r.chan_id = chan_id;
2867 switch (header_type) {
2868 case LTTNG_UST_CTL_CHANNEL_HEADER_COMPACT:
2869 reply.r.header_type = 1;
2870 break;
2871 case LTTNG_UST_CTL_CHANNEL_HEADER_LARGE:
2872 reply.r.header_type = 2;
2873 break;
2874 default:
2875 reply.r.header_type = 0;
2876 break;
2877 }
2878 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2879 if (len > 0 && len != sizeof(reply))
2880 return -EIO;
2881 if (len < 0)
2882 return len;
2883 return 0;
2884 }
2885
2886 /* Regenerate the statedump. */
2887 int lttng_ust_ctl_regenerate_statedump(int sock, int handle)
2888 {
2889 struct ustcomm_ust_msg lum;
2890 struct ustcomm_ust_reply lur;
2891 int ret;
2892
2893 memset(&lum, 0, sizeof(lum));
2894 lum.handle = handle;
2895 lum.cmd = LTTNG_UST_ABI_SESSION_STATEDUMP;
2896 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
2897 if (ret)
2898 return ret;
2899 DBG("Regenerated statedump for handle %u", handle);
2900 return 0;
2901 }
2902
2903 /* counter operations */
2904
2905 int lttng_ust_ctl_get_nr_cpu_per_counter(void)
2906 {
2907 return num_possible_cpus();
2908 }
2909
2910 struct lttng_ust_ctl_daemon_counter *
2911 lttng_ust_ctl_create_counter(size_t nr_dimensions,
2912 const struct lttng_ust_ctl_counter_dimension *dimensions,
2913 int64_t global_sum_step,
2914 int global_counter_fd,
2915 int nr_counter_cpu_fds,
2916 const int *counter_cpu_fds,
2917 enum lttng_ust_ctl_counter_bitness bitness,
2918 enum lttng_ust_ctl_counter_arithmetic arithmetic,
2919 uint32_t alloc_flags,
2920 bool coalesce_hits)
2921 {
2922 const char *transport_name;
2923 struct lttng_ust_ctl_daemon_counter *counter;
2924 struct lttng_counter_transport *transport;
2925 struct lttng_counter_dimension ust_dim[LTTNG_COUNTER_DIMENSION_MAX];
2926 size_t i;
2927
2928 if (nr_dimensions > LTTNG_COUNTER_DIMENSION_MAX)
2929 return NULL;
2930 /* Currently, only per-cpu allocation is supported. */
2931 switch (alloc_flags) {
2932 case LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU:
2933 break;
2934
2935 case LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU | LTTNG_UST_CTL_COUNTER_ALLOC_GLOBAL:
2936 case LTTNG_UST_CTL_COUNTER_ALLOC_GLOBAL:
2937 default:
2938 return NULL;
2939 }
2940 switch (bitness) {
2941 case LTTNG_UST_CTL_COUNTER_BITNESS_32:
2942 switch (arithmetic) {
2943 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR:
2944 transport_name = "counter-per-cpu-32-modular";
2945 break;
2946 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION:
2947 transport_name = "counter-per-cpu-32-saturation";
2948 break;
2949 default:
2950 return NULL;
2951 }
2952 break;
2953 case LTTNG_UST_CTL_COUNTER_BITNESS_64:
2954 switch (arithmetic) {
2955 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR:
2956 transport_name = "counter-per-cpu-64-modular";
2957 break;
2958 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION:
2959 transport_name = "counter-per-cpu-64-saturation";
2960 break;
2961 default:
2962 return NULL;
2963 }
2964 break;
2965 default:
2966 return NULL;
2967 }
2968
2969 transport = lttng_counter_transport_find(transport_name);
2970 if (!transport) {
2971 DBG("LTTng transport %s not found\n",
2972 transport_name);
2973 return NULL;
2974 }
2975
2976 counter = zmalloc(sizeof(*counter));
2977 if (!counter)
2978 return NULL;
2979 counter->attr = zmalloc(sizeof(*counter->attr));
2980 if (!counter->attr)
2981 goto free_counter;
2982 counter->attr->bitness = bitness;
2983 counter->attr->arithmetic = arithmetic;
2984 counter->attr->nr_dimensions = nr_dimensions;
2985 counter->attr->global_sum_step = global_sum_step;
2986 counter->attr->coalesce_hits = coalesce_hits;
2987 for (i = 0; i < nr_dimensions; i++)
2988 counter->attr->dimensions[i] = dimensions[i];
2989
2990 for (i = 0; i < nr_dimensions; i++) {
2991 ust_dim[i].size = dimensions[i].size;
2992 ust_dim[i].underflow_index = dimensions[i].underflow_index;
2993 ust_dim[i].overflow_index = dimensions[i].overflow_index;
2994 ust_dim[i].has_underflow = dimensions[i].has_underflow;
2995 ust_dim[i].has_overflow = dimensions[i].has_overflow;
2996 }
2997 counter->counter = transport->ops.counter_create(nr_dimensions,
2998 ust_dim, global_sum_step, global_counter_fd,
2999 nr_counter_cpu_fds, counter_cpu_fds, true);
3000 if (!counter->counter)
3001 goto free_attr;
3002 counter->ops = &transport->ops;
3003 return counter;
3004
3005 free_attr:
3006 free(counter->attr);
3007 free_counter:
3008 free(counter);
3009 return NULL;
3010 }
3011
3012 int lttng_ust_ctl_create_counter_data(struct lttng_ust_ctl_daemon_counter *counter,
3013 struct lttng_ust_abi_object_data **_counter_data)
3014 {
3015 struct lttng_ust_abi_object_data *counter_data;
3016 struct lttng_ust_abi_counter_conf counter_conf = {0};
3017 size_t i;
3018 int ret;
3019
3020 switch (counter->attr->arithmetic) {
3021 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR:
3022 counter_conf.arithmetic = LTTNG_UST_ABI_COUNTER_ARITHMETIC_MODULAR;
3023 break;
3024 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION:
3025 counter_conf.arithmetic = LTTNG_UST_ABI_COUNTER_ARITHMETIC_SATURATION;
3026 break;
3027 default:
3028 return -EINVAL;
3029 }
3030 switch (counter->attr->bitness) {
3031 case LTTNG_UST_CTL_COUNTER_BITNESS_32:
3032 counter_conf.bitness = LTTNG_UST_ABI_COUNTER_BITNESS_32;
3033 break;
3034 case LTTNG_UST_CTL_COUNTER_BITNESS_64:
3035 counter_conf.bitness = LTTNG_UST_ABI_COUNTER_BITNESS_64;
3036 break;
3037 default:
3038 return -EINVAL;
3039 }
3040 counter_conf.number_dimensions = counter->attr->nr_dimensions;
3041 counter_conf.global_sum_step = counter->attr->global_sum_step;
3042 counter_conf.coalesce_hits = counter->attr->coalesce_hits;
3043 for (i = 0; i < counter->attr->nr_dimensions; i++) {
3044 counter_conf.dimensions[i].size = counter->attr->dimensions[i].size;
3045 counter_conf.dimensions[i].underflow_index = counter->attr->dimensions[i].underflow_index;
3046 counter_conf.dimensions[i].overflow_index = counter->attr->dimensions[i].overflow_index;
3047 counter_conf.dimensions[i].has_underflow = counter->attr->dimensions[i].has_underflow;
3048 counter_conf.dimensions[i].has_overflow = counter->attr->dimensions[i].has_overflow;
3049 }
3050
3051 counter_data = zmalloc(sizeof(*counter_data));
3052 if (!counter_data) {
3053 ret = -ENOMEM;
3054 goto error_alloc;
3055 }
3056 counter_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER;
3057 counter_data->handle = -1;
3058
3059 counter_data->size = sizeof(counter_conf);
3060 counter_data->u.counter.data = zmalloc(sizeof(counter_conf));
3061 if (!counter_data->u.counter.data) {
3062 ret = -ENOMEM;
3063 goto error_alloc_data;
3064 }
3065
3066 memcpy(counter_data->u.counter.data, &counter_conf, sizeof(counter_conf));
3067 *_counter_data = counter_data;
3068
3069 return 0;
3070
3071 error_alloc_data:
3072 free(counter_data);
3073 error_alloc:
3074 return ret;
3075 }
3076
3077 int lttng_ust_ctl_create_counter_global_data(struct lttng_ust_ctl_daemon_counter *counter,
3078 struct lttng_ust_abi_object_data **_counter_global_data)
3079 {
3080 struct lttng_ust_abi_object_data *counter_global_data;
3081 int ret, fd;
3082 size_t len;
3083
3084 if (lttng_counter_get_global_shm(counter->counter, &fd, &len))
3085 return -EINVAL;
3086 counter_global_data = zmalloc(sizeof(*counter_global_data));
3087 if (!counter_global_data) {
3088 ret = -ENOMEM;
3089 goto error_alloc;
3090 }
3091 counter_global_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL;
3092 counter_global_data->handle = -1;
3093 counter_global_data->size = len;
3094 counter_global_data->u.counter_global.shm_fd = fd;
3095 *_counter_global_data = counter_global_data;
3096 return 0;
3097
3098 error_alloc:
3099 return ret;
3100 }
3101
3102 int lttng_ust_ctl_create_counter_cpu_data(struct lttng_ust_ctl_daemon_counter *counter, int cpu,
3103 struct lttng_ust_abi_object_data **_counter_cpu_data)
3104 {
3105 struct lttng_ust_abi_object_data *counter_cpu_data;
3106 int ret, fd;
3107 size_t len;
3108
3109 if (lttng_counter_get_cpu_shm(counter->counter, cpu, &fd, &len))
3110 return -EINVAL;
3111 counter_cpu_data = zmalloc(sizeof(*counter_cpu_data));
3112 if (!counter_cpu_data) {
3113 ret = -ENOMEM;
3114 goto error_alloc;
3115 }
3116 counter_cpu_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU;
3117 counter_cpu_data->handle = -1;
3118 counter_cpu_data->size = len;
3119 counter_cpu_data->u.counter_cpu.shm_fd = fd;
3120 counter_cpu_data->u.counter_cpu.cpu_nr = cpu;
3121 *_counter_cpu_data = counter_cpu_data;
3122 return 0;
3123
3124 error_alloc:
3125 return ret;
3126 }
3127
3128 void lttng_ust_ctl_destroy_counter(struct lttng_ust_ctl_daemon_counter *counter)
3129 {
3130 counter->ops->counter_destroy(counter->counter);
3131 free(counter->attr);
3132 free(counter);
3133 }
3134
3135 /*
3136 * Protocol for LTTNG_UST_ABI_COUNTER command:
3137 *
3138 * - send: struct ustcomm_ust_msg
3139 * - receive: struct ustcomm_ust_reply
3140 * - send: counter data
3141 * - receive: struct ustcomm_ust_reply (actual command return code)
3142 */
3143 int lttng_ust_ctl_send_counter_data_to_ust(int sock, int parent_handle,
3144 struct lttng_ust_abi_object_data *counter_data)
3145 {
3146 struct ustcomm_ust_msg lum;
3147 struct ustcomm_ust_reply lur;
3148 int ret;
3149 size_t size;
3150 ssize_t len;
3151
3152 if (!counter_data)
3153 return -EINVAL;
3154
3155 size = counter_data->size;
3156 memset(&lum, 0, sizeof(lum));
3157 lum.handle = parent_handle;
3158 lum.cmd = LTTNG_UST_ABI_COUNTER;
3159 lum.u.counter.len = size;
3160 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
3161 if (ret)
3162 return ret;
3163
3164 /* Send counter data */
3165 len = ustcomm_send_unix_sock(sock, counter_data->u.counter.data, size);
3166 if (len != size) {
3167 if (len < 0)
3168 return len;
3169 else
3170 return -EIO;
3171 }
3172
3173 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
3174 if (!ret) {
3175 counter_data->handle = lur.ret_val;
3176 }
3177 return ret;
3178 }
3179
3180 /*
3181 * Protocol for LTTNG_UST_ABI_COUNTER_GLOBAL command:
3182 *
3183 * - send: struct ustcomm_ust_msg
3184 * - receive: struct ustcomm_ust_reply
3185 * - send: file descriptor
3186 * - receive: struct ustcomm_ust_reply (actual command return code)
3187 */
3188 int lttng_ust_ctl_send_counter_global_data_to_ust(int sock,
3189 struct lttng_ust_abi_object_data *counter_data,
3190 struct lttng_ust_abi_object_data *counter_global_data)
3191 {
3192 struct ustcomm_ust_msg lum;
3193 struct ustcomm_ust_reply lur;
3194 int ret, shm_fd[1];
3195 size_t size;
3196 ssize_t len;
3197
3198 if (!counter_data || !counter_global_data)
3199 return -EINVAL;
3200
3201 size = counter_global_data->size;
3202 memset(&lum, 0, sizeof(lum));
3203 lum.handle = counter_data->handle; /* parent handle */
3204 lum.cmd = LTTNG_UST_ABI_COUNTER_GLOBAL;
3205 lum.u.counter_global.len = size;
3206 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
3207 if (ret)
3208 return ret;
3209
3210 shm_fd[0] = counter_global_data->u.counter_global.shm_fd;
3211 len = ustcomm_send_fds_unix_sock(sock, shm_fd, 1);
3212 if (len <= 0) {
3213 if (len < 0)
3214 return len;
3215 else
3216 return -EIO;
3217 }
3218
3219 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
3220 if (!ret) {
3221 counter_global_data->handle = lur.ret_val;
3222 }
3223 return ret;
3224 }
3225
3226 /*
3227 * Protocol for LTTNG_UST_ABI_COUNTER_CPU command:
3228 *
3229 * - send: struct ustcomm_ust_msg
3230 * - receive: struct ustcomm_ust_reply
3231 * - send: file descriptor
3232 * - receive: struct ustcomm_ust_reply (actual command return code)
3233 */
3234 int lttng_ust_ctl_send_counter_cpu_data_to_ust(int sock,
3235 struct lttng_ust_abi_object_data *counter_data,
3236 struct lttng_ust_abi_object_data *counter_cpu_data)
3237 {
3238 struct ustcomm_ust_msg lum;
3239 struct ustcomm_ust_reply lur;
3240 int ret, shm_fd[1];
3241 size_t size;
3242 ssize_t len;
3243
3244 if (!counter_data || !counter_cpu_data)
3245 return -EINVAL;
3246
3247 size = counter_cpu_data->size;
3248 memset(&lum, 0, sizeof(lum));
3249 lum.handle = counter_data->handle; /* parent handle */
3250 lum.cmd = LTTNG_UST_ABI_COUNTER_CPU;
3251 lum.u.counter_cpu.len = size;
3252 lum.u.counter_cpu.cpu_nr = counter_cpu_data->u.counter_cpu.cpu_nr;
3253 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
3254 if (ret)
3255 return ret;
3256
3257 shm_fd[0] = counter_cpu_data->u.counter_global.shm_fd;
3258 len = ustcomm_send_fds_unix_sock(sock, shm_fd, 1);
3259 if (len <= 0) {
3260 if (len < 0)
3261 return len;
3262 else
3263 return -EIO;
3264 }
3265
3266 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
3267 if (!ret) {
3268 counter_cpu_data->handle = lur.ret_val;
3269 }
3270 return ret;
3271 }
3272
3273 int lttng_ust_ctl_counter_read(struct lttng_ust_ctl_daemon_counter *counter,
3274 const size_t *dimension_indexes,
3275 int cpu, int64_t *value,
3276 bool *overflow, bool *underflow)
3277 {
3278 return counter->ops->counter_read(counter->counter, dimension_indexes, cpu,
3279 value, overflow, underflow);
3280 }
3281
3282 int lttng_ust_ctl_counter_aggregate(struct lttng_ust_ctl_daemon_counter *counter,
3283 const size_t *dimension_indexes,
3284 int64_t *value,
3285 bool *overflow, bool *underflow)
3286 {
3287 return counter->ops->counter_aggregate(counter->counter, dimension_indexes,
3288 value, overflow, underflow);
3289 }
3290
3291 int lttng_ust_ctl_counter_clear(struct lttng_ust_ctl_daemon_counter *counter,
3292 const size_t *dimension_indexes)
3293 {
3294 return counter->ops->counter_clear(counter->counter, dimension_indexes);
3295 }
3296
3297 static
3298 void lttng_ust_ctl_ctor(void)
3299 __attribute__((constructor));
3300 static
3301 void lttng_ust_ctl_ctor(void)
3302 {
3303 /*
3304 * Call the liblttng-ust-common constructor to ensure it runs first.
3305 */
3306 lttng_ust_common_ctor();
3307
3308 lttng_ust_ring_buffer_clients_init();
3309 lttng_ust_counter_clients_init();
3310 lib_ringbuffer_signal_init();
3311 }
3312
3313 static
3314 void lttng_ust_ctl_exit(void)
3315 __attribute__((destructor));
3316 static
3317 void lttng_ust_ctl_exit(void)
3318 {
3319 lttng_ust_counter_clients_exit();
3320 lttng_ust_ring_buffer_clients_exit();
3321 }
LTTng 2.0 Userspace Tracer
This page took 0.096956 seconds and 4 git commands to generate.