2 * SPDX-License-Identifier: GPL-2.0-only
4 * Copyright (C) 2011 EfficiOS Inc.
5 * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 #include <sys/types.h>
13 #include <sys/socket.h>
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>
23 #include "common/logging.h"
24 #include "common/ustcomm.h"
25 #include "common/macros.h"
26 #include "common/align.h"
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"
37 #include "common/smp.h"
38 #include "common/counter/counter.h"
41 * Number of milliseconds to retry before failing metadata writes on
42 * buffer full condition. (10 seconds)
44 #define LTTNG_METADATA_TIMEOUT_MSEC 10000
47 * Channel representation within consumer.
49 struct lttng_ust_ctl_consumer_channel
{
50 struct lttng_ust_channel_buffer
*chan
; /* lttng channel buffers */
52 /* initial attributes */
53 struct lttng_ust_ctl_consumer_channel_attr attr
;
54 int wait_fd
; /* monitor close() */
55 int wakeup_fd
; /* monitor close() */
59 * Stream representation within consumer.
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
;
66 uint64_t memory_map_size
;
67 void *memory_map_addr
;
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
];
81 * Counter representation within daemon.
83 struct lttng_ust_ctl_daemon_counter
{
84 struct lttng_ust_channel_counter
*counter
;
85 const struct lttng_ust_channel_counter_ops
*ops
;
86 struct lttng_ust_ctl_counter_attr
*attr
; /* initial attributes */
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.
94 #define sigbus_begin() \
96 assert(!lttng_ust_sigbus_state.jmp_ready); \
97 if (!lttng_ust_sigbus_state.head.next) { \
99 * Lazy init because static list initialisation is \
100 * problematic for TLS variable. \
102 CDS_INIT_LIST_HEAD(<tng_ust_sigbus_state.head); \
104 if (sigsetjmp(lttng_ust_sigbus_state.sj_env, 1)) { \
106 CMM_STORE_SHARED(lttng_ust_sigbus_state.jmp_ready, 0); \
110 CMM_STORE_SHARED(lttng_ust_sigbus_state.jmp_ready, 1); \
114 static void sigbus_end(void)
116 assert(lttng_ust_sigbus_state
.jmp_ready
);
118 CMM_STORE_SHARED(lttng_ust_sigbus_state
.jmp_ready
, 0);
122 void lttng_ust_sigbus_add_range(struct lttng_ust_sigbus_range
*range
, void *start
, size_t len
)
124 range
->start
= start
;
125 range
->end
= (char *)start
+ len
;
126 cds_list_add_rcu(&range
->node
, <tng_ust_sigbus_state
.head
);
131 void lttng_ust_sigbus_del_range(struct lttng_ust_sigbus_range
*range
)
134 cds_list_del_rcu(&range
->node
);
137 void lttng_ust_ctl_sigbus_handle(void *addr
)
139 struct lttng_ust_sigbus_range
*range
;
141 if (!CMM_LOAD_SHARED(lttng_ust_sigbus_state
.jmp_ready
))
143 cds_list_for_each_entry_rcu(range
, <tng_ust_sigbus_state
.head
, node
) {
144 if (addr
< range
->start
|| addr
>= range
->end
)
146 siglongjmp(lttng_ust_sigbus_state
.sj_env
, 1);
150 int lttng_ust_ctl_release_handle(int sock
, int handle
)
152 struct ustcomm_ust_msg lum
;
153 struct ustcomm_ust_reply lur
;
155 if (sock
< 0 || handle
< 0)
157 memset(&lum
, 0, sizeof(lum
));
159 lum
.cmd
= LTTNG_UST_ABI_RELEASE
;
160 return ustcomm_send_app_cmd(sock
, &lum
, &lur
);
164 * If sock is negative, it means we don't have to notify the other side
165 * (e.g. application has already vanished).
167 int lttng_ust_ctl_release_object(int sock
, struct lttng_ust_abi_object_data
*data
)
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
);
182 data
->u
.channel
.wakeup_fd
= -1;
184 free(data
->u
.channel
.data
);
185 data
->u
.channel
.data
= NULL
;
187 case LTTNG_UST_ABI_OBJECT_TYPE_STREAM
:
188 if (data
->u
.stream
.shm_fd
>= 0) {
189 ret
= close(data
->u
.stream
.shm_fd
);
194 data
->u
.stream
.shm_fd
= -1;
196 if (data
->u
.stream
.wakeup_fd
>= 0) {
197 ret
= close(data
->u
.stream
.wakeup_fd
);
202 data
->u
.stream
.wakeup_fd
= -1;
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 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_EVENT
:
211 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER
:
212 free(data
->u
.counter
.data
);
213 data
->u
.counter
.data
= NULL
;
215 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL
:
216 if (data
->u
.counter_global
.shm_fd
>= 0) {
217 ret
= close(data
->u
.counter_global
.shm_fd
);
222 data
->u
.counter_global
.shm_fd
= -1;
225 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU
:
226 if (data
->u
.counter_cpu
.shm_fd
>= 0) {
227 ret
= close(data
->u
.counter_cpu
.shm_fd
);
232 data
->u
.counter_cpu
.shm_fd
= -1;
238 return lttng_ust_ctl_release_handle(sock
, data
->handle
);
242 * Send registration done packet to the application.
244 int lttng_ust_ctl_register_done(int sock
)
246 struct ustcomm_ust_msg lum
;
247 struct ustcomm_ust_reply lur
;
250 DBG("Sending register done command to %d", sock
);
251 memset(&lum
, 0, sizeof(lum
));
252 lum
.handle
= LTTNG_UST_ABI_ROOT_HANDLE
;
253 lum
.cmd
= LTTNG_UST_ABI_REGISTER_DONE
;
254 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
261 * returns session handle.
263 int lttng_ust_ctl_create_session(int sock
)
265 struct ustcomm_ust_msg lum
;
266 struct ustcomm_ust_reply lur
;
267 int ret
, session_handle
;
270 memset(&lum
, 0, sizeof(lum
));
271 lum
.handle
= LTTNG_UST_ABI_ROOT_HANDLE
;
272 lum
.cmd
= LTTNG_UST_ABI_SESSION
;
273 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
276 session_handle
= lur
.ret_val
;
277 DBG("received session handle %u", session_handle
);
278 return session_handle
;
281 int lttng_ust_ctl_create_event(int sock
, struct lttng_ust_abi_event
*ev
,
282 struct lttng_ust_abi_object_data
*channel_data
,
283 struct lttng_ust_abi_object_data
**_event_data
)
285 struct ustcomm_ust_msg lum
;
286 struct ustcomm_ust_reply lur
;
287 struct lttng_ust_abi_object_data
*event_data
;
290 if (!channel_data
|| !_event_data
)
293 event_data
= zmalloc(sizeof(*event_data
));
296 event_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_EVENT
;
297 memset(&lum
, 0, sizeof(lum
));
298 lum
.handle
= channel_data
->handle
;
299 lum
.cmd
= LTTNG_UST_ABI_EVENT
;
300 strncpy(lum
.u
.event
.name
, ev
->name
,
301 LTTNG_UST_ABI_SYM_NAME_LEN
);
302 lum
.u
.event
.instrumentation
= ev
->instrumentation
;
303 lum
.u
.event
.loglevel_type
= ev
->loglevel_type
;
304 lum
.u
.event
.loglevel
= ev
->loglevel
;
305 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
310 event_data
->handle
= lur
.ret_val
;
311 DBG("received event handle %u", event_data
->handle
);
312 *_event_data
= event_data
;
317 * Protocol for LTTNG_UST_ABI_CONTEXT command:
319 * - send: struct ustcomm_ust_msg
320 * - send: var len ctx_name
321 * - receive: struct ustcomm_ust_reply
323 * TODO: At the next breaking protocol bump, we should indicate the total
324 * command message length as part of a message header so that the protocol can
325 * recover from invalid command errors.
327 int lttng_ust_ctl_add_context(int sock
, struct lttng_ust_context_attr
*ctx
,
328 struct lttng_ust_abi_object_data
*obj_data
,
329 struct lttng_ust_abi_object_data
**_context_data
)
331 struct ustcomm_ust_msg lum
;
332 struct ustcomm_ust_reply lur
;
333 struct lttng_ust_abi_object_data
*context_data
= NULL
;
338 if (!obj_data
|| !_context_data
) {
343 context_data
= zmalloc(sizeof(*context_data
));
348 context_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_CONTEXT
;
349 memset(&lum
, 0, sizeof(lum
));
350 lum
.handle
= obj_data
->handle
;
351 lum
.cmd
= LTTNG_UST_ABI_CONTEXT
;
353 lum
.u
.context
.ctx
= ctx
->ctx
;
355 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
356 lum
.u
.context
.u
.perf_counter
= ctx
->u
.perf_counter
;
358 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
360 size_t provider_name_len
= strlen(
361 ctx
->u
.app_ctx
.provider_name
) + 1;
362 size_t ctx_name_len
= strlen(ctx
->u
.app_ctx
.ctx_name
) + 1;
364 lum
.u
.context
.u
.app_ctx
.provider_name_len
= provider_name_len
;
365 lum
.u
.context
.u
.app_ctx
.ctx_name_len
= ctx_name_len
;
367 len
= provider_name_len
+ ctx_name_len
;
373 memcpy(buf
, ctx
->u
.app_ctx
.provider_name
,
375 memcpy(buf
+ provider_name_len
, ctx
->u
.app_ctx
.ctx_name
,
382 ret
= ustcomm_send_app_msg(sock
, &lum
);
386 /* send var len ctx_name */
387 ret
= ustcomm_send_unix_sock(sock
, buf
, len
);
396 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
398 if (ret
== -EINVAL
) {
400 * Command unknown from remote end. The communication socket is
401 * now out-of-sync and needs to be shutdown.
403 (void) ustcomm_shutdown_unix_sock(sock
);
407 context_data
->handle
= -1;
408 DBG("Context created successfully");
409 *_context_data
= context_data
;
418 * Protocol for LTTNG_UST_ABI_FILTER command:
420 * - send: struct ustcomm_ust_msg
421 * - send: var len bytecode
422 * - receive: struct ustcomm_ust_reply
424 * TODO: At the next breaking protocol bump, we should indicate the total
425 * command message length as part of a message header so that the protocol can
426 * recover from invalid command errors.
428 int lttng_ust_ctl_set_filter(int sock
, struct lttng_ust_abi_filter_bytecode
*bytecode
,
429 struct lttng_ust_abi_object_data
*obj_data
)
431 struct ustcomm_ust_msg lum
;
432 struct ustcomm_ust_reply lur
;
438 memset(&lum
, 0, sizeof(lum
));
439 lum
.handle
= obj_data
->handle
;
440 lum
.cmd
= LTTNG_UST_ABI_FILTER
;
441 lum
.u
.filter
.data_size
= bytecode
->len
;
442 lum
.u
.filter
.reloc_offset
= bytecode
->reloc_offset
;
443 lum
.u
.filter
.seqnum
= bytecode
->seqnum
;
445 ret
= ustcomm_send_app_msg(sock
, &lum
);
448 /* send var len bytecode */
449 ret
= ustcomm_send_unix_sock(sock
, bytecode
->data
,
454 if (ret
!= bytecode
->len
)
456 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
457 if (ret
== -EINVAL
) {
459 * Command unknown from remote end. The communication socket is
460 * now out-of-sync and needs to be shutdown.
462 (void) ustcomm_shutdown_unix_sock(sock
);
468 * Protocol for LTTNG_UST_ABI_CAPTURE command:
470 * - send: struct ustcomm_ust_msg
471 * - receive: struct ustcomm_ust_reply
472 * - send: var len bytecode
473 * - receive: struct ustcomm_ust_reply (actual command return code)
475 int lttng_ust_ctl_set_capture(int sock
, struct lttng_ust_abi_capture_bytecode
*bytecode
,
476 struct lttng_ust_abi_object_data
*obj_data
)
478 struct ustcomm_ust_msg lum
;
479 struct ustcomm_ust_reply lur
;
485 memset(&lum
, 0, sizeof(lum
));
486 lum
.handle
= obj_data
->handle
;
487 lum
.cmd
= LTTNG_UST_ABI_CAPTURE
;
488 lum
.u
.capture
.data_size
= bytecode
->len
;
489 lum
.u
.capture
.reloc_offset
= bytecode
->reloc_offset
;
490 lum
.u
.capture
.seqnum
= bytecode
->seqnum
;
492 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
495 /* send var len bytecode */
496 ret
= ustcomm_send_unix_sock(sock
, bytecode
->data
,
501 if (ret
!= bytecode
->len
)
503 return ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
507 * Protocol for LTTNG_UST_ABI_EXCLUSION command:
509 * - send: struct ustcomm_ust_msg
510 * - send: var len exclusion names
511 * - receive: struct ustcomm_ust_reply
513 * TODO: At the next breaking protocol bump, we should indicate the total
514 * command message length as part of a message header so that the protocol can
515 * recover from invalid command errors.
517 int lttng_ust_ctl_set_exclusion(int sock
, struct lttng_ust_abi_event_exclusion
*exclusion
,
518 struct lttng_ust_abi_object_data
*obj_data
)
520 struct ustcomm_ust_msg lum
;
521 struct ustcomm_ust_reply lur
;
528 memset(&lum
, 0, sizeof(lum
));
529 lum
.handle
= obj_data
->handle
;
530 lum
.cmd
= LTTNG_UST_ABI_EXCLUSION
;
531 lum
.u
.exclusion
.count
= exclusion
->count
;
533 ret
= ustcomm_send_app_msg(sock
, &lum
);
538 /* send var len exclusion names */
539 ret
= ustcomm_send_unix_sock(sock
,
541 exclusion
->count
* LTTNG_UST_ABI_SYM_NAME_LEN
);
545 if (ret
!= exclusion
->count
* LTTNG_UST_ABI_SYM_NAME_LEN
) {
548 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
549 if (ret
== -EINVAL
) {
551 * Command unknown from remote end. The communication socket is
552 * now out-of-sync and needs to be shutdown.
554 (void) ustcomm_shutdown_unix_sock(sock
);
559 /* Enable event, channel and session ioctl */
560 int lttng_ust_ctl_enable(int sock
, struct lttng_ust_abi_object_data
*object
)
562 struct ustcomm_ust_msg lum
;
563 struct ustcomm_ust_reply lur
;
569 memset(&lum
, 0, sizeof(lum
));
570 lum
.handle
= object
->handle
;
571 lum
.cmd
= LTTNG_UST_ABI_ENABLE
;
572 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
575 DBG("enabled handle %u", object
->handle
);
579 /* Disable event, channel and session ioctl */
580 int lttng_ust_ctl_disable(int sock
, struct lttng_ust_abi_object_data
*object
)
582 struct ustcomm_ust_msg lum
;
583 struct ustcomm_ust_reply lur
;
589 memset(&lum
, 0, sizeof(lum
));
590 lum
.handle
= object
->handle
;
591 lum
.cmd
= LTTNG_UST_ABI_DISABLE
;
592 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
595 DBG("disable handle %u", object
->handle
);
599 int lttng_ust_ctl_start_session(int sock
, int handle
)
601 struct lttng_ust_abi_object_data obj
;
604 return lttng_ust_ctl_enable(sock
, &obj
);
607 int lttng_ust_ctl_stop_session(int sock
, int handle
)
609 struct lttng_ust_abi_object_data obj
;
612 return lttng_ust_ctl_disable(sock
, &obj
);
616 * Protocol for LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE command:
618 * - send: struct ustcomm_ust_msg
619 * - receive: struct ustcomm_ust_reply
620 * - send: file descriptor
621 * - receive: struct ustcomm_ust_reply (actual command return code)
623 int lttng_ust_ctl_create_event_notifier_group(int sock
, int pipe_fd
,
624 struct lttng_ust_abi_object_data
**_event_notifier_group_data
)
626 struct lttng_ust_abi_object_data
*event_notifier_group_data
;
627 struct ustcomm_ust_msg lum
;
628 struct ustcomm_ust_reply lur
;
632 if (!_event_notifier_group_data
)
635 event_notifier_group_data
= zmalloc(sizeof(*event_notifier_group_data
));
636 if (!event_notifier_group_data
)
639 event_notifier_group_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER_GROUP
;
641 memset(&lum
, 0, sizeof(lum
));
642 lum
.handle
= LTTNG_UST_ABI_ROOT_HANDLE
;
643 lum
.cmd
= LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE
;
645 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
649 /* Send event_notifier notification pipe. */
650 len
= ustcomm_send_fds_unix_sock(sock
, &pipe_fd
, 1);
656 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
660 event_notifier_group_data
->handle
= lur
.ret_val
;
661 DBG("received event_notifier group handle %d", event_notifier_group_data
->handle
);
663 *_event_notifier_group_data
= event_notifier_group_data
;
668 free(event_notifier_group_data
);
675 * Protocol for LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE command:
677 * - send: struct ustcomm_ust_msg
678 * - receive: struct ustcomm_ust_reply
679 * - send: struct lttng_ust_abi_event_notifier
680 * - receive: struct ustcomm_ust_reply (actual command return code)
682 int lttng_ust_ctl_create_event_notifier(int sock
, struct lttng_ust_abi_event_notifier
*event_notifier
,
683 struct lttng_ust_abi_object_data
*event_notifier_group
,
684 struct lttng_ust_abi_object_data
**_event_notifier_data
)
686 struct ustcomm_ust_msg lum
= {};
687 struct ustcomm_ust_reply lur
;
688 struct lttng_ust_abi_object_data
*event_notifier_data
;
692 if (!event_notifier_group
|| !_event_notifier_data
)
695 event_notifier_data
= zmalloc(sizeof(*event_notifier_data
));
696 if (!event_notifier_data
)
699 event_notifier_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER
;
701 lum
.handle
= event_notifier_group
->handle
;
702 lum
.cmd
= LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE
;
703 lum
.u
.var_len_cmd
.cmd_len
= sizeof(*event_notifier
);
705 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
707 free(event_notifier_data
);
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
);
719 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
721 free(event_notifier_data
);
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
;
731 int lttng_ust_ctl_tracepoint_list(int sock
)
733 struct ustcomm_ust_msg lum
;
734 struct ustcomm_ust_reply lur
;
735 int ret
, tp_list_handle
;
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
);
743 tp_list_handle
= lur
.ret_val
;
744 DBG("received tracepoint list handle %u", tp_list_handle
);
745 return tp_list_handle
;
748 int lttng_ust_ctl_tracepoint_list_get(int sock
, int tp_list_handle
,
749 struct lttng_ust_abi_tracepoint_iter
*iter
)
751 struct ustcomm_ust_msg lum
;
752 struct ustcomm_ust_reply lur
;
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
);
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
));
771 int lttng_ust_ctl_tracepoint_field_list(int sock
)
773 struct ustcomm_ust_msg lum
;
774 struct ustcomm_ust_reply lur
;
775 int ret
, tp_field_list_handle
;
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
);
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
;
788 int lttng_ust_ctl_tracepoint_field_list_get(int sock
, int tp_field_list_handle
,
789 struct lttng_ust_abi_field_iter
*iter
)
791 struct ustcomm_ust_msg lum
;
792 struct ustcomm_ust_reply lur
;
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
);
805 len
= ustcomm_recv_unix_sock(sock
, iter
, sizeof(*iter
));
806 if (len
!= sizeof(*iter
)) {
809 DBG("received tracepoint field list entry event_name %s event_loglevel %d field_name %s field_type %d",
817 int lttng_ust_ctl_tracer_version(int sock
, struct lttng_ust_abi_tracer_version
*v
)
819 struct ustcomm_ust_msg lum
;
820 struct ustcomm_ust_reply lur
;
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
);
832 memcpy(v
, &lur
.u
.version
, sizeof(*v
));
833 DBG("received tracer version");
837 int lttng_ust_ctl_wait_quiescent(int sock
)
839 struct ustcomm_ust_msg lum
;
840 struct ustcomm_ust_reply lur
;
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
);
849 DBG("waited for quiescent state");
853 int lttng_ust_ctl_calibrate(int sock
__attribute__((unused
)),
854 struct lttng_ust_abi_calibrate
*calibrate
)
862 int lttng_ust_ctl_sock_flush_buffer(int sock
, struct lttng_ust_abi_object_data
*object
)
864 struct ustcomm_ust_msg lum
;
865 struct ustcomm_ust_reply lur
;
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
);
877 DBG("flushed buffer handle %u", object
->handle
);
882 int lttng_ust_ctl_send_channel(int sock
,
883 enum lttng_ust_abi_chan_type type
,
893 len
= ustcomm_send_unix_sock(sock
, &size
, sizeof(size
));
894 if (len
!= sizeof(size
)) {
901 /* Send channel type */
902 len
= ustcomm_send_unix_sock(sock
, &type
, sizeof(type
));
903 if (len
!= sizeof(type
)) {
911 /* Send channel data */
912 len
= ustcomm_send_unix_sock(sock
, data
, size
);
921 len
= ustcomm_send_fds_unix_sock(sock
, &wakeup_fd
, 1);
932 int lttng_ust_ctl_send_stream(int sock
,
934 uint64_t memory_map_size
,
935 int shm_fd
, int wakeup_fd
,
943 /* finish iteration */
946 len
= ustcomm_send_unix_sock(sock
, &v
, sizeof(v
));
947 if (len
!= sizeof(v
)) {
957 len
= ustcomm_send_unix_sock(sock
, &memory_map_size
,
958 sizeof(memory_map_size
));
959 if (len
!= sizeof(memory_map_size
)) {
967 len
= ustcomm_send_unix_sock(sock
, &stream_nr
,
969 if (len
!= sizeof(stream_nr
)) {
977 /* Send shm fd and wakeup fd */
980 len
= ustcomm_send_fds_unix_sock(sock
, fds
, 2);
990 int lttng_ust_ctl_recv_channel_from_consumer(int sock
,
991 struct lttng_ust_abi_object_data
**_channel_data
)
993 struct lttng_ust_abi_object_data
*channel_data
;
998 channel_data
= zmalloc(sizeof(*channel_data
));
1003 channel_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL
;
1004 channel_data
->handle
= -1;
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
)) {
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
)) {
1028 /* recv channel data */
1029 channel_data
->u
.channel
.data
= zmalloc(channel_data
->size
);
1030 if (!channel_data
->u
.channel
.data
) {
1034 len
= ustcomm_recv_unix_sock(sock
, channel_data
->u
.channel
.data
,
1035 channel_data
->size
);
1036 if (len
!= channel_data
->size
) {
1041 goto error_recv_data
;
1043 /* recv wakeup fd */
1044 len
= ustcomm_recv_fds_unix_sock(sock
, &wakeup_fd
, 1);
1048 goto error_recv_data
;
1051 goto error_recv_data
;
1054 channel_data
->u
.channel
.wakeup_fd
= wakeup_fd
;
1055 *_channel_data
= channel_data
;
1059 free(channel_data
->u
.channel
.data
);
1066 int lttng_ust_ctl_recv_stream_from_consumer(int sock
,
1067 struct lttng_ust_abi_object_data
**_stream_data
)
1069 struct lttng_ust_abi_object_data
*stream_data
;
1074 stream_data
= zmalloc(sizeof(*stream_data
));
1080 stream_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_STREAM
;
1081 stream_data
->handle
= -1;
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
)) {
1093 if (stream_data
->size
== -1) {
1094 ret
= -LTTNG_UST_ERR_NOENT
;
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
)) {
1109 /* recv shm fd and wakeup fd */
1110 len
= ustcomm_recv_fds_unix_sock(sock
, fds
, 2);
1120 stream_data
->u
.stream
.shm_fd
= fds
[0];
1121 stream_data
->u
.stream
.wakeup_fd
= fds
[1];
1122 *_stream_data
= stream_data
;
1132 * Protocol for LTTNG_UST_ABI_CHANNEL command:
1134 * - send: struct ustcomm_ust_msg
1135 * - send: file descriptors and channel data
1136 * - receive: struct ustcomm_ust_reply
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.
1142 int lttng_ust_ctl_send_channel_to_ust(int sock
, int session_handle
,
1143 struct lttng_ust_abi_object_data
*channel_data
)
1145 struct ustcomm_ust_msg lum
;
1146 struct ustcomm_ust_reply lur
;
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
);
1161 ret
= lttng_ust_ctl_send_channel(sock
,
1162 channel_data
->u
.channel
.type
,
1163 channel_data
->u
.channel
.data
,
1165 channel_data
->u
.channel
.wakeup_fd
,
1169 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
1171 channel_data
->handle
= lur
.ret_val
;
1172 } else if (ret
== -EINVAL
) {
1174 * Command unknown from remote end. The communication socket is
1175 * now out-of-sync and needs to be shutdown.
1177 (void) ustcomm_shutdown_unix_sock(sock
);
1183 * Protocol for LTTNG_UST_ABI_STREAM command:
1185 * - send: struct ustcomm_ust_msg
1186 * - send: file descriptors and stream data
1187 * - receive: struct ustcomm_ust_reply
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.
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
)
1197 struct ustcomm_ust_msg lum
;
1198 struct ustcomm_ust_reply lur
;
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
);
1210 assert(stream_data
);
1211 assert(stream_data
->type
== LTTNG_UST_ABI_OBJECT_TYPE_STREAM
);
1213 ret
= lttng_ust_ctl_send_stream(sock
,
1214 stream_data
->u
.stream
.stream_nr
,
1216 stream_data
->u
.stream
.shm_fd
,
1217 stream_data
->u
.stream
.wakeup_fd
, 1);
1220 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
1221 if (ret
== -EINVAL
) {
1223 * Command unknown from remote end. The communication socket is
1224 * now out-of-sync and needs to be shutdown.
1226 (void) ustcomm_shutdown_unix_sock(sock
);
1231 int lttng_ust_ctl_duplicate_ust_object_data(struct lttng_ust_abi_object_data
**dest
,
1232 struct lttng_ust_abi_object_data
*src
)
1234 struct lttng_ust_abi_object_data
*obj
;
1237 if (src
->handle
!= -1) {
1242 obj
= zmalloc(sizeof(*obj
));
1248 obj
->type
= src
->type
;
1249 obj
->handle
= src
->handle
;
1250 obj
->size
= src
->size
;
1252 switch (obj
->type
) {
1253 case LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL
:
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) {
1261 goto chan_error_wakeup_fd
;
1264 obj
->u
.channel
.wakeup_fd
=
1265 src
->u
.channel
.wakeup_fd
;
1267 obj
->u
.channel
.data
= zmalloc(obj
->size
);
1268 if (!obj
->u
.channel
.data
) {
1270 goto chan_error_alloc
;
1272 memcpy(obj
->u
.channel
.data
, src
->u
.channel
.data
, obj
->size
);
1276 if (src
->u
.channel
.wakeup_fd
>= 0) {
1279 closeret
= close(obj
->u
.channel
.wakeup_fd
);
1284 chan_error_wakeup_fd
:
1289 case LTTNG_UST_ABI_OBJECT_TYPE_STREAM
:
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) {
1297 goto stream_error_wakeup_fd
;
1300 obj
->u
.stream
.wakeup_fd
=
1301 src
->u
.stream
.wakeup_fd
;
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) {
1309 goto stream_error_shm_fd
;
1312 obj
->u
.stream
.shm_fd
=
1313 src
->u
.stream
.shm_fd
;
1317 stream_error_shm_fd
:
1318 if (src
->u
.stream
.wakeup_fd
>= 0) {
1321 closeret
= close(obj
->u
.stream
.wakeup_fd
);
1326 stream_error_wakeup_fd
:
1330 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER
:
1332 obj
->u
.counter
.data
= zmalloc(obj
->size
);
1333 if (!obj
->u
.counter
.data
) {
1337 memcpy(obj
->u
.counter
.data
, src
->u
.counter
.data
, obj
->size
);
1341 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL
:
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) {
1354 case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU
:
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) {
1383 /* Buffer operations */
1385 int lttng_ust_ctl_get_nr_stream_per_channel(void)
1387 return get_possible_cpus_array_len();
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
)
1394 struct lttng_ust_ctl_consumer_channel
*chan
;
1395 const char *transport_name
;
1396 struct lttng_transport
*transport
;
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";
1405 transport_name
= "relay-overwrite-rt-mmap";
1408 if (attr
->read_timer_interval
== 0) {
1409 transport_name
= "relay-discard-mmap";
1411 transport_name
= "relay-discard-rt-mmap";
1418 case LTTNG_UST_ABI_CHAN_METADATA
:
1419 if (attr
->output
== LTTNG_UST_ABI_MMAP
)
1420 transport_name
= "relay-metadata-mmap";
1425 transport_name
= "<unknown>";
1429 transport
= lttng_ust_transport_find(transport_name
);
1431 DBG("LTTng transport %s not found\n",
1436 chan
= zmalloc(sizeof(*chan
));
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
);
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
);
1461 void lttng_ust_ctl_destroy_channel(struct lttng_ust_ctl_consumer_channel
*chan
)
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
);
1469 int lttng_ust_ctl_send_channel_to_sessiond(int sock
,
1470 struct lttng_ust_ctl_consumer_channel
*channel
)
1472 struct shm_object_table
*table
;
1474 table
= channel
->chan
->priv
->rb_chan
->handle
->table
;
1475 if (table
->size
<= 0)
1477 return lttng_ust_ctl_send_channel(sock
,
1479 table
->objects
[0].memory_map
,
1480 table
->objects
[0].memory_map_size
,
1485 int lttng_ust_ctl_send_stream_to_sessiond(int sock
,
1486 struct lttng_ust_ctl_consumer_stream
*stream
)
1489 return lttng_ust_ctl_send_stream(sock
, -1U, -1U, -1, -1, 0);
1491 return lttng_ust_ctl_send_stream(sock
,
1493 stream
->memory_map_size
,
1494 stream
->shm_fd
, stream
->wakeup_fd
,
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 */
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
;
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
),
1514 lttng_ust_ring_buffer_ctx_init(&ctx
, rb_chan
, reserve_len
, sizeof(char), NULL
);
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
1521 waitret
= wait_cond_interruptible_timeout(
1523 ret
= lttng_chan_buf
->ops
->event_reserve(&ctx
);
1524 ret
!= -ENOBUFS
|| !ret
;
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
)
1535 lttng_chan_buf
->ops
->event_write(&ctx
, &str
[pos
], reserve_len
, 1);
1536 lttng_chan_buf
->ops
->event_commit(&ctx
);
1543 * Write at most one packet in the channel.
1544 * Returns the number of bytes written on success, < 0 on error.
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 */
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
;
1558 reserve_len
= min_t(ssize_t
,
1559 lttng_chan_buf
->ops
->priv
->packet_avail_size(lttng_chan_buf
),
1561 lttng_ust_ring_buffer_ctx_init(&ctx
, rb_chan
, reserve_len
, sizeof(char), NULL
);
1562 ret
= lttng_chan_buf
->ops
->event_reserve(&ctx
);
1564 DBG("LTTng: event reservation failed");
1569 lttng_chan_buf
->ops
->event_write(&ctx
, str
, reserve_len
, 1);
1570 lttng_chan_buf
->ops
->event_commit(&ctx
);
1576 int lttng_ust_ctl_channel_close_wait_fd(struct lttng_ust_ctl_consumer_channel
*consumer_chan
)
1578 struct lttng_ust_ring_buffer_channel
*chan
;
1581 chan
= consumer_chan
->chan
->priv
->rb_chan
;
1582 ret
= ring_buffer_channel_close_wait_fd(&chan
->backend
.config
,
1583 chan
, chan
->handle
);
1585 consumer_chan
->wait_fd
= -1;
1589 int lttng_ust_ctl_channel_close_wakeup_fd(struct lttng_ust_ctl_consumer_channel
*consumer_chan
)
1591 struct lttng_ust_ring_buffer_channel
*chan
;
1594 chan
= consumer_chan
->chan
->priv
->rb_chan
;
1595 ret
= ring_buffer_channel_close_wakeup_fd(&chan
->backend
.config
,
1596 chan
, chan
->handle
);
1598 consumer_chan
->wakeup_fd
= -1;
1602 int lttng_ust_ctl_stream_close_wait_fd(struct lttng_ust_ctl_consumer_stream
*stream
)
1604 struct lttng_ust_ring_buffer_channel
*chan
;
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
);
1611 int lttng_ust_ctl_stream_close_wakeup_fd(struct lttng_ust_ctl_consumer_stream
*stream
)
1613 struct lttng_ust_ring_buffer_channel
*chan
;
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
);
1620 struct lttng_ust_ctl_consumer_stream
*
1621 lttng_ust_ctl_create_stream(struct lttng_ust_ctl_consumer_channel
*channel
,
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
;
1635 rb_chan
= channel
->chan
->priv
->rb_chan
;
1636 handle
= rb_chan
->handle
;
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
);
1645 ret
= lib_ring_buffer_open_read(buf
, handle
);
1649 stream
= zmalloc(sizeof(*stream
));
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
;
1666 void lttng_ust_ctl_destroy_stream(struct lttng_ust_ctl_consumer_stream
*stream
)
1668 struct lttng_ust_ring_buffer
*buf
;
1669 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
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
);
1680 int lttng_ust_ctl_channel_get_wait_fd(struct lttng_ust_ctl_consumer_channel
*chan
)
1684 return shm_get_wait_fd(chan
->chan
->priv
->rb_chan
->handle
,
1685 &chan
->chan
->priv
->rb_chan
->handle
->chan
._ref
);
1688 int lttng_ust_ctl_channel_get_wakeup_fd(struct lttng_ust_ctl_consumer_channel
*chan
)
1692 return shm_get_wakeup_fd(chan
->chan
->priv
->rb_chan
->handle
,
1693 &chan
->chan
->priv
->rb_chan
->handle
->chan
._ref
);
1696 int lttng_ust_ctl_stream_get_wait_fd(struct lttng_ust_ctl_consumer_stream
*stream
)
1698 struct lttng_ust_ring_buffer
*buf
;
1699 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1704 consumer_chan
= stream
->chan
;
1705 return shm_get_wait_fd(consumer_chan
->chan
->priv
->rb_chan
->handle
, &buf
->self
._ref
);
1708 int lttng_ust_ctl_stream_get_wakeup_fd(struct lttng_ust_ctl_consumer_stream
*stream
)
1710 struct lttng_ust_ring_buffer
*buf
;
1711 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1716 consumer_chan
= stream
->chan
;
1717 return shm_get_wakeup_fd(consumer_chan
->chan
->priv
->rb_chan
->handle
, &buf
->self
._ref
);
1720 /* For mmap mode, readable without "get" operation */
1722 void *lttng_ust_ctl_get_mmap_base(struct lttng_ust_ctl_consumer_stream
*stream
)
1724 struct lttng_ust_ring_buffer
*buf
;
1725 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1726 struct lttng_ust_sigbus_range range
;
1732 consumer_chan
= stream
->chan
;
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
);
1740 return p
; /* Users of this pointer should check for sigbus. */
1743 /* returns the length to mmap. */
1744 int lttng_ust_ctl_get_mmap_len(struct lttng_ust_ctl_consumer_stream
*stream
,
1747 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1748 unsigned long mmap_buf_len
;
1749 struct lttng_ust_ring_buffer_channel
*rb_chan
;
1753 consumer_chan
= stream
->chan
;
1754 rb_chan
= consumer_chan
->chan
->priv
->rb_chan
;
1755 if (rb_chan
->backend
.config
.output
!= RING_BUFFER_MMAP
)
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
)
1762 *len
= mmap_buf_len
;
1766 /* returns the maximum size for sub-buffers. */
1767 int lttng_ust_ctl_get_max_subbuf_size(struct lttng_ust_ctl_consumer_stream
*stream
,
1770 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1771 struct lttng_ust_ring_buffer_channel
*rb_chan
;
1775 consumer_chan
= stream
->chan
;
1776 rb_chan
= consumer_chan
->chan
->priv
->rb_chan
;
1777 *len
= rb_chan
->backend
.subbuf_size
;
1782 * For mmap mode, operate on the current packet (between get/put or
1783 * get_next/put_next).
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
,
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
;
1802 consumer_chan
= stream
->chan
;
1803 rb_chan
= consumer_chan
->chan
->priv
->rb_chan
;
1804 if (rb_chan
->backend
.config
.output
!= RING_BUFFER_MMAP
)
1810 lttng_ust_sigbus_add_range(&range
, stream
->memory_map_addr
,
1811 stream
->memory_map_size
);
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
,
1821 pages
= shmp(rb_chan
->handle
, barray_idx
->shmp
);
1826 *off
= pages
->mmap_offset
;
1828 lttng_ust_sigbus_del_range(&range
);
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
,
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
;
1846 consumer_chan
= stream
->chan
;
1847 rb_chan
= consumer_chan
->chan
->priv
->rb_chan
;
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
,
1854 lttng_ust_sigbus_del_range(&range
);
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
,
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
;
1871 consumer_chan
= stream
->chan
;
1872 rb_chan
= consumer_chan
->chan
->priv
->rb_chan
;
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
,
1879 *len
= LTTNG_UST_PAGE_ALIGN(*len
);
1880 lttng_ust_sigbus_del_range(&range
);
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
)
1888 struct lttng_ust_ring_buffer
*buf
;
1889 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1890 struct lttng_ust_sigbus_range range
;
1896 consumer_chan
= stream
->chan
;
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
);
1908 /* Release exclusive sub-buffer access, move consumer forward. */
1909 int lttng_ust_ctl_put_next_subbuf(struct lttng_ust_ctl_consumer_stream
*stream
)
1911 struct lttng_ust_ring_buffer
*buf
;
1912 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1913 struct lttng_ust_sigbus_range range
;
1918 consumer_chan
= stream
->chan
;
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
);
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
)
1934 struct lttng_ust_ring_buffer
*buf
;
1935 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1936 struct lttng_ust_sigbus_range range
;
1942 consumer_chan
= stream
->chan
;
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
);
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
1959 int lttng_ust_ctl_snapshot_sample_positions(struct lttng_ust_ctl_consumer_stream
*stream
)
1961 struct lttng_ust_ring_buffer
*buf
;
1962 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
1963 struct lttng_ust_sigbus_range range
;
1969 consumer_chan
= stream
->chan
;
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
);
1982 /* Get the consumer position (iteration start) */
1983 int lttng_ust_ctl_snapshot_get_consumed(struct lttng_ust_ctl_consumer_stream
*stream
,
1986 struct lttng_ust_ring_buffer
*buf
;
1991 *pos
= buf
->cons_snapshot
;
1995 /* Get the producer position (iteration end) */
1996 int lttng_ust_ctl_snapshot_get_produced(struct lttng_ust_ctl_consumer_stream
*stream
,
1999 struct lttng_ust_ring_buffer
*buf
;
2004 *pos
= buf
->prod_snapshot
;
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
,
2012 struct lttng_ust_ring_buffer
*buf
;
2013 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
2014 struct lttng_ust_sigbus_range range
;
2020 consumer_chan
= stream
->chan
;
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
);
2032 /* Release exclusive sub-buffer access */
2033 int lttng_ust_ctl_put_subbuf(struct lttng_ust_ctl_consumer_stream
*stream
)
2035 struct lttng_ust_ring_buffer
*buf
;
2036 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
2037 struct lttng_ust_sigbus_range range
;
2042 consumer_chan
= stream
->chan
;
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
);
2053 int lttng_ust_ctl_flush_buffer(struct lttng_ust_ctl_consumer_stream
*stream
,
2054 int producer_active
)
2056 struct lttng_ust_ring_buffer
*buf
;
2057 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
2058 struct lttng_ust_sigbus_range range
;
2062 consumer_chan
= stream
->chan
;
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
);
2075 int lttng_ust_ctl_clear_buffer(struct lttng_ust_ctl_consumer_stream
*stream
)
2077 struct lttng_ust_ring_buffer
*buf
;
2078 struct lttng_ust_ctl_consumer_channel
*consumer_chan
;
2079 struct lttng_ust_sigbus_range range
;
2083 consumer_chan
= stream
->chan
;
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
);
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
)
2101 const struct lttng_ust_ring_buffer_config
*config
;
2102 struct lttng_ust_client_lib_ring_buffer_client_cb
*client_cb
;
2104 config
= &chan
->backend
.config
;
2105 if (!config
->cb_ptr
)
2107 client_cb
= caa_container_of(config
->cb_ptr
,
2108 struct lttng_ust_client_lib_ring_buffer_client_cb
,
2113 int lttng_ust_ctl_get_timestamp_begin(struct lttng_ust_ctl_consumer_stream
*stream
,
2114 uint64_t *timestamp_begin
)
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
;
2122 if (!stream
|| !timestamp_begin
)
2125 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2126 client_cb
= get_client_cb(buf
, chan
);
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
);
2139 int lttng_ust_ctl_get_timestamp_end(struct lttng_ust_ctl_consumer_stream
*stream
,
2140 uint64_t *timestamp_end
)
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
;
2148 if (!stream
|| !timestamp_end
)
2151 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2152 client_cb
= get_client_cb(buf
, chan
);
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
);
2165 int lttng_ust_ctl_get_events_discarded(struct lttng_ust_ctl_consumer_stream
*stream
,
2166 uint64_t *events_discarded
)
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
;
2174 if (!stream
|| !events_discarded
)
2177 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2178 client_cb
= get_client_cb(buf
, chan
);
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
);
2191 int lttng_ust_ctl_get_content_size(struct lttng_ust_ctl_consumer_stream
*stream
,
2192 uint64_t *content_size
)
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
;
2200 if (!stream
|| !content_size
)
2203 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2204 client_cb
= get_client_cb(buf
, chan
);
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
);
2217 int lttng_ust_ctl_get_packet_size(struct lttng_ust_ctl_consumer_stream
*stream
,
2218 uint64_t *packet_size
)
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
;
2226 if (!stream
|| !packet_size
)
2229 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2230 client_cb
= get_client_cb(buf
, chan
);
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
);
2243 int lttng_ust_ctl_get_stream_id(struct lttng_ust_ctl_consumer_stream
*stream
,
2244 uint64_t *stream_id
)
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
;
2252 if (!stream
|| !stream_id
)
2255 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2256 client_cb
= get_client_cb(buf
, chan
);
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
);
2269 int lttng_ust_ctl_get_current_timestamp(struct lttng_ust_ctl_consumer_stream
*stream
,
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
;
2281 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2282 client_cb
= get_client_cb(buf
, chan
);
2283 if (!client_cb
|| !client_cb
->current_timestamp
)
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
);
2295 int lttng_ust_ctl_get_sequence_number(struct lttng_ust_ctl_consumer_stream
*stream
,
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
;
2304 if (!stream
|| !seq
)
2307 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2308 client_cb
= get_client_cb(buf
, chan
);
2309 if (!client_cb
|| !client_cb
->sequence_number
)
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
);
2321 int lttng_ust_ctl_get_instance_id(struct lttng_ust_ctl_consumer_stream
*stream
,
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
;
2333 chan
= stream
->chan
->chan
->priv
->rb_chan
;
2334 client_cb
= get_client_cb(buf
, chan
);
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
);
2347 #ifdef HAVE_LINUX_PERF_EVENT_H
2349 int lttng_ust_ctl_has_perf_counters(void)
2356 int lttng_ust_ctl_has_perf_counters(void)
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
2371 int get_cred(int sock
,
2372 const struct lttng_ust_ctl_reg_msg
*reg_msg
,
2379 socklen_t ucred_len
= sizeof(struct ucred
);
2382 ret
= getsockopt(sock
, SOL_SOCKET
, SO_PEERCRED
, &ucred
, &ucred_len
);
2384 return -LTTNG_UST_ERR_PEERCRED
;
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
);
2391 ERR("Unix socket credential pid=0. Refusing application in distinct, non-nested pid namespace.");
2392 return -LTTNG_UST_ERR_PEERCRED_PID
;
2397 if (ucred
.pid
== reg_msg
->pid
) {
2398 *ppid
= reg_msg
->ppid
;
2404 #elif defined(__FreeBSD__)
2405 #include <sys/ucred.h>
2409 * Override application uid/gid with unix socket credentials. Use the
2410 * first group of the cr_groups.
2413 int get_cred(int sock
,
2414 const struct lttng_ust_ctl_reg_msg
*reg_msg
,
2420 struct xucred xucred
;
2421 socklen_t xucred_len
= sizeof(struct xucred
);
2424 ret
= getsockopt(sock
, SOL_LOCAL
, LOCAL_PEERCRED
, &xucred
, &xucred_len
);
2426 return -LTTNG_UST_ERR_PEERCRED
;
2428 if (xucred
.cr_version
!= XUCRED_VERSION
|| xucred
.cr_ngroups
< 1) {
2429 return -LTTNG_UST_ERR_PEERCRED
;
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
;
2446 #warning "Using insecure fallback: trusting user id provided by registered applications. Please consider implementing use of unix socket credentials on your platform."
2448 int get_cred(int sock
,
2449 const struct lttng_ust_ctl_reg_msg
*reg_msg
,
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
;
2466 * Returns 0 on success, negative error value on error.
2468 int lttng_ust_ctl_recv_reg_msg(int sock
,
2469 enum lttng_ust_ctl_socket_type
*type
,
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
,
2486 struct lttng_ust_ctl_reg_msg reg_msg
;
2488 len
= ustcomm_recv_unix_sock(sock
, ®_msg
, sizeof(reg_msg
));
2489 if (len
> 0 && len
!= sizeof(reg_msg
))
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
;
2503 return -LTTNG_UST_ERR_INVAL_MAGIC
;
2505 switch (reg_msg
.socket_type
) {
2506 case 0: *type
= LTTNG_UST_CTL_SOCKET_CMD
;
2508 case 1: *type
= LTTNG_UST_CTL_SOCKET_NOTIFY
;
2511 return -LTTNG_UST_ERR_INVAL_SOCKET_TYPE
;
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
;
2526 return get_cred(sock
, ®_msg
, pid
, ppid
, uid
, gid
);
2529 int lttng_ust_ctl_recv_notify(int sock
, enum lttng_ust_ctl_notify_cmd
*notify_cmd
)
2531 struct ustcomm_notify_hdr header
;
2534 len
= ustcomm_recv_unix_sock(sock
, &header
, sizeof(header
));
2535 if (len
> 0 && len
!= sizeof(header
))
2541 switch (header
.notify_cmd
) {
2543 *notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_EVENT
;
2546 *notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL
;
2549 *notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_ENUM
;
2552 *notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_KEY
;
2561 * Returns 0 on success, negative error value on error.
2563 int lttng_ust_ctl_recv_register_event(int sock
,
2570 struct lttng_ust_ctl_field
**fields
,
2571 char **model_emf_uri
,
2572 uint64_t *user_token
)
2575 struct ustcomm_notify_event_msg msg
;
2576 size_t signature_len
, fields_len
, model_emf_uri_len
;
2577 char *a_sign
= NULL
, *a_model_emf_uri
= NULL
;
2578 struct lttng_ust_ctl_field
*a_fields
= NULL
;
2580 len
= ustcomm_recv_unix_sock(sock
, &msg
, sizeof(msg
));
2581 if (len
> 0 && len
!= sizeof(msg
))
2588 *session_objd
= msg
.session_objd
;
2589 *channel_objd
= msg
.channel_objd
;
2590 strncpy(event_name
, msg
.event_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
2591 event_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
2592 *loglevel
= msg
.loglevel
;
2593 signature_len
= msg
.signature_len
;
2594 fields_len
= msg
.fields_len
;
2595 *user_token
= msg
.user_token
;
2597 if (fields_len
% sizeof(*a_fields
) != 0) {
2601 model_emf_uri_len
= msg
.model_emf_uri_len
;
2603 /* recv signature. contains at least \0. */
2604 a_sign
= zmalloc(signature_len
);
2607 len
= ustcomm_recv_unix_sock(sock
, a_sign
, signature_len
);
2608 if (len
> 0 && len
!= signature_len
) {
2610 goto signature_error
;
2614 goto signature_error
;
2617 goto signature_error
;
2619 /* Enforce end of string */
2620 a_sign
[signature_len
- 1] = '\0';
2624 a_fields
= zmalloc(fields_len
);
2627 goto signature_error
;
2629 len
= ustcomm_recv_unix_sock(sock
, a_fields
, fields_len
);
2630 if (len
> 0 && len
!= fields_len
) {
2643 if (model_emf_uri_len
) {
2644 /* recv model_emf_uri_len */
2645 a_model_emf_uri
= zmalloc(model_emf_uri_len
);
2646 if (!a_model_emf_uri
) {
2650 len
= ustcomm_recv_unix_sock(sock
, a_model_emf_uri
,
2652 if (len
> 0 && len
!= model_emf_uri_len
) {
2663 /* Enforce end of string */
2664 a_model_emf_uri
[model_emf_uri_len
- 1] = '\0';
2667 *signature
= a_sign
;
2668 *nr_fields
= fields_len
/ sizeof(*a_fields
);
2670 *model_emf_uri
= a_model_emf_uri
;
2675 free(a_model_emf_uri
);
2684 * Returns 0 on success, negative error value on error.
2686 int lttng_ust_ctl_reply_register_event(int sock
,
2692 struct ustcomm_notify_hdr header
;
2693 struct ustcomm_notify_event_reply r
;
2696 memset(&reply
, 0, sizeof(reply
));
2697 reply
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_EVENT
;
2698 reply
.r
.ret_code
= ret_code
;
2700 len
= ustcomm_send_unix_sock(sock
, &reply
, sizeof(reply
));
2701 if (len
> 0 && len
!= sizeof(reply
))
2709 * Returns 0 on success, negative UST or system error value on error.
2711 int lttng_ust_ctl_recv_register_key(int sock
,
2712 int *session_objd
, /* session descriptor (output) */
2713 int *map_objd
, /* map descriptor (output) */
2714 uint32_t *dimension
, /*
2715 * Against which dimension is
2716 * this key expressed. (output)
2718 uint64_t **dimension_indexes
, /*
2721 * allocated, must be
2723 * caller if function
2725 * Contains @dimension
2728 char **key_string
, /*
2729 * key string (output,
2730 * dynamically allocated, must
2731 * be free(3)'d by the caller if
2732 * function returns success.)
2734 uint64_t *user_token
)
2737 struct ustcomm_notify_key_msg msg
;
2738 size_t dimension_indexes_len
, key_string_len
;
2739 uint64_t *a_dimension_indexes
= NULL
;
2740 char *a_key_string
= NULL
;
2742 len
= ustcomm_recv_unix_sock(sock
, &msg
, sizeof(msg
));
2743 if (len
> 0 && len
!= sizeof(msg
))
2750 *session_objd
= msg
.session_objd
;
2751 *map_objd
= msg
.map_objd
;
2752 *dimension
= msg
.dimension
;
2753 dimension_indexes_len
= msg
.dimension
* sizeof(uint64_t);
2754 key_string_len
= msg
.key_string_len
;
2755 *user_token
= msg
.user_token
;
2757 if (dimension_indexes_len
) {
2758 /* recv dimension_indexes */
2759 a_dimension_indexes
= zmalloc(dimension_indexes_len
);
2760 if (!a_dimension_indexes
) {
2764 len
= ustcomm_recv_unix_sock(sock
, a_dimension_indexes
, dimension_indexes_len
);
2765 if (len
> 0 && len
!= dimension_indexes_len
) {
2778 if (key_string_len
) {
2779 /* recv key_string */
2780 a_key_string
= zmalloc(key_string_len
);
2781 if (!a_key_string
) {
2785 len
= ustcomm_recv_unix_sock(sock
, a_key_string
, key_string_len
);
2786 if (len
> 0 && len
!= key_string_len
) {
2797 /* Enforce end of string */
2798 a_key_string
[key_string_len
- 1] = '\0';
2801 *dimension_indexes
= a_dimension_indexes
;
2802 *key_string
= a_key_string
;
2807 free(a_dimension_indexes
);
2812 * Returns 0 on success, negative error value on error.
2814 int lttng_ust_ctl_reply_register_key(int sock
,
2815 uint64_t index
, /* Index within dimension (input) */
2816 int ret_code
) /* return code. 0 ok, negative error */
2820 struct ustcomm_notify_hdr header
;
2821 struct ustcomm_notify_key_reply r
;
2824 memset(&reply
, 0, sizeof(reply
));
2825 reply
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_KEY
;
2826 reply
.r
.ret_code
= ret_code
;
2827 reply
.r
.index
= index
;
2828 len
= ustcomm_send_unix_sock(sock
, &reply
, sizeof(reply
));
2829 if (len
> 0 && len
!= sizeof(reply
))
2837 * Returns 0 on success, negative UST or system error value on error.
2839 int lttng_ust_ctl_recv_register_enum(int sock
,
2842 struct lttng_ust_ctl_enum_entry
**entries
,
2846 struct ustcomm_notify_enum_msg msg
;
2848 struct lttng_ust_ctl_enum_entry
*a_entries
= NULL
;
2850 len
= ustcomm_recv_unix_sock(sock
, &msg
, sizeof(msg
));
2851 if (len
> 0 && len
!= sizeof(msg
))
2858 *session_objd
= msg
.session_objd
;
2859 strncpy(enum_name
, msg
.enum_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
2860 enum_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
2861 entries_len
= msg
.entries_len
;
2863 if (entries_len
% sizeof(*a_entries
) != 0) {
2869 a_entries
= zmalloc(entries_len
);
2872 len
= ustcomm_recv_unix_sock(sock
, a_entries
, entries_len
);
2873 if (len
> 0 && len
!= entries_len
) {
2885 *nr_entries
= entries_len
/ sizeof(*a_entries
);
2886 *entries
= a_entries
;
2896 * Returns 0 on success, negative error value on error.
2898 int lttng_ust_ctl_reply_register_enum(int sock
,
2904 struct ustcomm_notify_hdr header
;
2905 struct ustcomm_notify_enum_reply r
;
2908 memset(&reply
, 0, sizeof(reply
));
2909 reply
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_ENUM
;
2910 reply
.r
.ret_code
= ret_code
;
2911 reply
.r
.enum_id
= id
;
2912 len
= ustcomm_send_unix_sock(sock
, &reply
, sizeof(reply
));
2913 if (len
> 0 && len
!= sizeof(reply
))
2921 * Returns 0 on success, negative UST or system error value on error.
2923 int lttng_ust_ctl_recv_register_channel(int sock
,
2924 int *session_objd
, /* session descriptor (output) */
2925 int *channel_objd
, /* channel descriptor (output) */
2927 struct lttng_ust_ctl_field
**fields
)
2930 struct ustcomm_notify_channel_msg msg
;
2932 struct lttng_ust_ctl_field
*a_fields
;
2934 len
= ustcomm_recv_unix_sock(sock
, &msg
, sizeof(msg
));
2935 if (len
> 0 && len
!= sizeof(msg
))
2942 *session_objd
= msg
.session_objd
;
2943 *channel_objd
= msg
.channel_objd
;
2944 fields_len
= msg
.ctx_fields_len
;
2946 if (fields_len
% sizeof(*a_fields
) != 0) {
2952 a_fields
= zmalloc(fields_len
);
2957 len
= ustcomm_recv_unix_sock(sock
, a_fields
, fields_len
);
2958 if (len
> 0 && len
!= fields_len
) {
2973 *nr_fields
= fields_len
/ sizeof(*a_fields
);
2983 * Returns 0 on success, negative error value on error.
2985 int lttng_ust_ctl_reply_register_channel(int sock
,
2987 enum lttng_ust_ctl_channel_header header_type
,
2992 struct ustcomm_notify_hdr header
;
2993 struct ustcomm_notify_channel_reply r
;
2996 memset(&reply
, 0, sizeof(reply
));
2997 reply
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL
;
2998 reply
.r
.ret_code
= ret_code
;
2999 reply
.r
.chan_id
= chan_id
;
3000 switch (header_type
) {
3001 case LTTNG_UST_CTL_CHANNEL_HEADER_COMPACT
:
3002 reply
.r
.header_type
= 1;
3004 case LTTNG_UST_CTL_CHANNEL_HEADER_LARGE
:
3005 reply
.r
.header_type
= 2;
3008 reply
.r
.header_type
= 0;
3011 len
= ustcomm_send_unix_sock(sock
, &reply
, sizeof(reply
));
3012 if (len
> 0 && len
!= sizeof(reply
))
3019 /* Regenerate the statedump. */
3020 int lttng_ust_ctl_regenerate_statedump(int sock
, int handle
)
3022 struct ustcomm_ust_msg lum
;
3023 struct ustcomm_ust_reply lur
;
3026 memset(&lum
, 0, sizeof(lum
));
3027 lum
.handle
= handle
;
3028 lum
.cmd
= LTTNG_UST_ABI_SESSION_STATEDUMP
;
3029 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3032 DBG("Regenerated statedump for handle %u", handle
);
3036 /* counter operations */
3038 int lttng_ust_ctl_get_nr_cpu_per_counter(void)
3040 return get_possible_cpus_array_len();
3043 struct lttng_ust_ctl_daemon_counter
*
3044 lttng_ust_ctl_create_counter(size_t nr_dimensions
,
3045 const struct lttng_ust_ctl_counter_dimension
*dimensions
,
3046 int64_t global_sum_step
,
3047 int global_counter_fd
,
3048 int nr_counter_cpu_fds
,
3049 const int *counter_cpu_fds
,
3050 enum lttng_ust_ctl_counter_bitness bitness
,
3051 enum lttng_ust_ctl_counter_arithmetic arithmetic
,
3052 uint32_t alloc_flags
,
3055 const char *transport_name
;
3056 struct lttng_ust_ctl_daemon_counter
*counter
;
3057 struct lttng_counter_transport
*transport
;
3058 struct lttng_counter_dimension ust_dim
[LTTNG_COUNTER_DIMENSION_MAX
];
3061 if (nr_dimensions
> LTTNG_COUNTER_DIMENSION_MAX
)
3063 /* Currently, only per-cpu allocation is supported. */
3064 switch (alloc_flags
) {
3065 case LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU
:
3068 case LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU
| LTTNG_UST_CTL_COUNTER_ALLOC_GLOBAL
:
3069 case LTTNG_UST_CTL_COUNTER_ALLOC_GLOBAL
:
3074 case LTTNG_UST_CTL_COUNTER_BITNESS_32
:
3075 switch (arithmetic
) {
3076 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR
:
3077 transport_name
= "counter-per-cpu-32-modular";
3079 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION
:
3080 transport_name
= "counter-per-cpu-32-saturation";
3086 case LTTNG_UST_CTL_COUNTER_BITNESS_64
:
3087 switch (arithmetic
) {
3088 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR
:
3089 transport_name
= "counter-per-cpu-64-modular";
3091 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION
:
3092 transport_name
= "counter-per-cpu-64-saturation";
3102 transport
= lttng_counter_transport_find(transport_name
);
3104 DBG("LTTng transport %s not found\n",
3109 counter
= zmalloc(sizeof(*counter
));
3112 counter
->attr
= zmalloc(sizeof(*counter
->attr
));
3115 counter
->attr
->bitness
= bitness
;
3116 counter
->attr
->arithmetic
= arithmetic
;
3117 counter
->attr
->nr_dimensions
= nr_dimensions
;
3118 counter
->attr
->global_sum_step
= global_sum_step
;
3119 counter
->attr
->coalesce_hits
= coalesce_hits
;
3120 for (i
= 0; i
< nr_dimensions
; i
++)
3121 counter
->attr
->dimensions
[i
] = dimensions
[i
];
3123 for (i
= 0; i
< nr_dimensions
; i
++) {
3124 ust_dim
[i
].size
= dimensions
[i
].size
;
3125 ust_dim
[i
].underflow_index
= dimensions
[i
].underflow_index
;
3126 ust_dim
[i
].overflow_index
= dimensions
[i
].overflow_index
;
3127 ust_dim
[i
].has_underflow
= dimensions
[i
].has_underflow
;
3128 ust_dim
[i
].has_overflow
= dimensions
[i
].has_overflow
;
3129 switch (dimensions
[i
].key_type
) {
3130 case LTTNG_UST_CTL_KEY_TYPE_TOKENS
:
3131 ust_dim
[i
].key_type
= LTTNG_KEY_TYPE_TOKENS
;
3133 case LTTNG_UST_CTL_KEY_TYPE_INTEGER
: /* Fall-through */
3138 counter
->counter
= transport
->ops
.priv
->counter_create(nr_dimensions
,
3139 ust_dim
, global_sum_step
, global_counter_fd
,
3140 nr_counter_cpu_fds
, counter_cpu_fds
, true);
3141 if (!counter
->counter
)
3143 counter
->ops
= &transport
->ops
;
3147 free(counter
->attr
);
3153 int lttng_ust_ctl_create_counter_data(struct lttng_ust_ctl_daemon_counter
*counter
,
3154 struct lttng_ust_abi_object_data
**_counter_data
)
3156 struct lttng_ust_abi_counter_conf
*counter_conf
= NULL
;
3157 struct lttng_ust_abi_counter_dimension
*dimension
;
3158 uint32_t conf_len
= sizeof(struct lttng_ust_abi_counter_conf
) +
3159 sizeof(struct lttng_ust_abi_counter_dimension
);
3160 struct lttng_ust_abi_object_data
*counter_data
;
3163 if (counter
->attr
->nr_dimensions
!= 1) {
3167 counter_conf
= zmalloc(conf_len
);
3168 if (!counter_conf
) {
3172 counter_conf
->len
= sizeof(struct lttng_ust_abi_counter_conf
);
3173 counter_conf
->flags
|= counter
->attr
->coalesce_hits
? LTTNG_UST_ABI_COUNTER_CONF_FLAG_COALESCE_HITS
: 0;
3174 switch (counter
->attr
->arithmetic
) {
3175 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR
:
3176 counter_conf
->arithmetic
= LTTNG_UST_ABI_COUNTER_ARITHMETIC_MODULAR
;
3178 case LTTNG_UST_CTL_COUNTER_ARITHMETIC_SATURATION
:
3179 counter_conf
->arithmetic
= LTTNG_UST_ABI_COUNTER_ARITHMETIC_SATURATION
;
3185 switch (counter
->attr
->bitness
) {
3186 case LTTNG_UST_CTL_COUNTER_BITNESS_32
:
3187 counter_conf
->bitness
= LTTNG_UST_ABI_COUNTER_BITNESS_32
;
3189 case LTTNG_UST_CTL_COUNTER_BITNESS_64
:
3190 counter_conf
->bitness
= LTTNG_UST_ABI_COUNTER_BITNESS_64
;
3195 counter_conf
->global_sum_step
= counter
->attr
->global_sum_step
;
3197 counter_conf
->number_dimensions
= 1;
3198 counter_conf
->elem_len
= sizeof(struct lttng_ust_abi_counter_dimension
);
3200 dimension
= (struct lttng_ust_abi_counter_dimension
*)((char *)counter_conf
+ sizeof(struct lttng_ust_abi_counter_conf
));
3201 dimension
->flags
|= counter
->attr
->dimensions
[0].has_underflow
? LTTNG_UST_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW
: 0;
3202 dimension
->flags
|= counter
->attr
->dimensions
[0].has_overflow
? LTTNG_UST_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW
: 0;
3203 dimension
->size
= counter
->attr
->dimensions
[0].size
;
3204 dimension
->underflow_index
= counter
->attr
->dimensions
[0].underflow_index
;
3205 dimension
->overflow_index
= counter
->attr
->dimensions
[0].overflow_index
;
3206 switch (counter
->attr
->dimensions
[0].key_type
) {
3207 case LTTNG_UST_CTL_KEY_TYPE_TOKENS
:
3208 dimension
->key_type
= LTTNG_UST_ABI_KEY_TYPE_TOKENS
;
3210 case LTTNG_UST_CTL_KEY_TYPE_INTEGER
: /* Fall-through */
3216 counter_data
= zmalloc(sizeof(*counter_data
));
3217 if (!counter_data
) {
3221 counter_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_COUNTER
;
3222 counter_data
->handle
= -1;
3223 counter_data
->size
= conf_len
;
3224 counter_data
->u
.counter
.data
= counter_conf
;
3225 *_counter_data
= counter_data
;
3234 int lttng_ust_ctl_create_counter_global_data(struct lttng_ust_ctl_daemon_counter
*counter
,
3235 struct lttng_ust_abi_object_data
**_counter_global_data
)
3237 struct lttng_ust_abi_object_data
*counter_global_data
;
3241 if (lttng_counter_get_global_shm(counter
->counter
->priv
->counter
, &fd
, &len
))
3243 counter_global_data
= zmalloc(sizeof(*counter_global_data
));
3244 if (!counter_global_data
) {
3248 counter_global_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL
;
3249 counter_global_data
->handle
= -1;
3250 counter_global_data
->size
= len
;
3251 counter_global_data
->u
.counter_global
.shm_fd
= fd
;
3252 *_counter_global_data
= counter_global_data
;
3259 int lttng_ust_ctl_create_counter_cpu_data(struct lttng_ust_ctl_daemon_counter
*counter
, int cpu
,
3260 struct lttng_ust_abi_object_data
**_counter_cpu_data
)
3262 struct lttng_ust_abi_object_data
*counter_cpu_data
;
3266 if (lttng_counter_get_cpu_shm(counter
->counter
->priv
->counter
, cpu
, &fd
, &len
))
3268 counter_cpu_data
= zmalloc(sizeof(*counter_cpu_data
));
3269 if (!counter_cpu_data
) {
3273 counter_cpu_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU
;
3274 counter_cpu_data
->handle
= -1;
3275 counter_cpu_data
->size
= len
;
3276 counter_cpu_data
->u
.counter_cpu
.shm_fd
= fd
;
3277 counter_cpu_data
->u
.counter_cpu
.cpu_nr
= cpu
;
3278 *_counter_cpu_data
= counter_cpu_data
;
3285 void lttng_ust_ctl_destroy_counter(struct lttng_ust_ctl_daemon_counter
*counter
)
3287 counter
->ops
->priv
->counter_destroy(counter
->counter
);
3288 free(counter
->attr
);
3293 * Protocol for LTTNG_UST_ABI_OLD_COUNTER command:
3295 * - send: struct ustcomm_ust_msg
3296 * - receive: struct ustcomm_ust_reply
3297 * - send: counter data
3298 * - receive: struct ustcomm_ust_reply (actual command return code)
3301 int lttng_ust_ctl_send_old_counter_data_to_ust(int sock
, int parent_handle
,
3302 struct lttng_ust_abi_object_data
*counter_data
)
3304 const struct lttng_ust_abi_counter_conf
*counter_conf
= counter_data
->u
.counter
.data
;
3305 const struct lttng_ust_abi_counter_dimension
*dimension
;
3306 struct lttng_ust_abi_old_counter_conf old_counter_conf
= {};
3307 struct ustcomm_ust_msg lum
= {};
3308 struct ustcomm_ust_reply lur
;
3316 if (counter_conf
->number_dimensions
!= 1)
3318 old_counter_conf
.coalesce_hits
= (counter_conf
->flags
& LTTNG_UST_ABI_COUNTER_CONF_FLAG_COALESCE_HITS
) ? 1 : 0;
3319 old_counter_conf
.arithmetic
= counter_conf
->arithmetic
;
3320 old_counter_conf
.bitness
= counter_conf
->bitness
;
3321 old_counter_conf
.global_sum_step
= counter_conf
->global_sum_step
;
3323 dimension
= (struct lttng_ust_abi_counter_dimension
*)((char *)counter_conf
+ sizeof(struct lttng_ust_abi_counter_conf
));
3324 old_counter_conf
.number_dimensions
= 1;
3325 old_counter_conf
.dimensions
[0].size
= dimension
->size
;
3326 old_counter_conf
.dimensions
[0].has_underflow
= (dimension
->flags
& LTTNG_UST_ABI_COUNTER_DIMENSION_FLAG_UNDERFLOW
) ? 1 : 0;
3327 old_counter_conf
.dimensions
[0].has_overflow
= (dimension
->flags
& LTTNG_UST_ABI_COUNTER_DIMENSION_FLAG_OVERFLOW
) ? 1 : 0;
3328 old_counter_conf
.dimensions
[0].underflow_index
= dimension
->underflow_index
;
3329 old_counter_conf
.dimensions
[0].overflow_index
= dimension
->overflow_index
;
3330 if (dimension
->key_type
!= LTTNG_UST_ABI_KEY_TYPE_TOKENS
)
3333 size
= sizeof(old_counter_conf
);
3334 lum
.handle
= parent_handle
;
3335 lum
.cmd
= LTTNG_UST_ABI_OLD_COUNTER
;
3336 lum
.u
.counter_old
.len
= size
;
3337 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3341 /* Send counter data */
3342 len
= ustcomm_send_unix_sock(sock
, &old_counter_conf
, size
);
3350 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3352 counter_data
->handle
= lur
.ret_val
;
3358 * Protocol for LTTNG_UST_ABI_OLD_COUNTER_GLOBAL command:
3360 * - send: struct ustcomm_ust_msg
3361 * - receive: struct ustcomm_ust_reply
3362 * - send: file descriptor
3363 * - receive: struct ustcomm_ust_reply (actual command return code)
3366 int lttng_ust_ctl_send_old_counter_global_data_to_ust(int sock
,
3367 struct lttng_ust_abi_object_data
*counter_data
,
3368 struct lttng_ust_abi_object_data
*counter_global_data
)
3370 struct ustcomm_ust_msg lum
= {};
3371 struct ustcomm_ust_reply lur
;
3376 if (!counter_data
|| !counter_global_data
)
3379 size
= counter_global_data
->size
;
3380 lum
.handle
= counter_data
->handle
; /* parent handle */
3381 lum
.cmd
= LTTNG_UST_ABI_OLD_COUNTER_GLOBAL
;
3382 lum
.u
.counter_global_old
.len
= size
;
3383 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3387 shm_fd
[0] = counter_global_data
->u
.counter_global
.shm_fd
;
3388 len
= ustcomm_send_fds_unix_sock(sock
, shm_fd
, 1);
3396 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3398 counter_global_data
->handle
= lur
.ret_val
;
3404 * Protocol for LTTNG_UST_ABI_OLD_COUNTER_CPU command:
3406 * - send: struct ustcomm_ust_msg
3407 * - receive: struct ustcomm_ust_reply
3408 * - send: file descriptor
3409 * - receive: struct ustcomm_ust_reply (actual command return code)
3412 int lttng_ust_ctl_send_old_counter_cpu_data_to_ust(int sock
,
3413 struct lttng_ust_abi_object_data
*counter_data
,
3414 struct lttng_ust_abi_object_data
*counter_cpu_data
)
3416 struct ustcomm_ust_msg lum
= {};
3417 struct ustcomm_ust_reply lur
;
3422 if (!counter_data
|| !counter_cpu_data
)
3425 size
= counter_cpu_data
->size
;
3426 lum
.handle
= counter_data
->handle
; /* parent handle */
3427 lum
.cmd
= LTTNG_UST_ABI_OLD_COUNTER_CPU
;
3428 lum
.u
.counter_cpu_old
.len
= size
;
3429 lum
.u
.counter_cpu_old
.cpu_nr
= counter_cpu_data
->u
.counter_cpu
.cpu_nr
;
3430 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3434 shm_fd
[0] = counter_cpu_data
->u
.counter_global
.shm_fd
;
3435 len
= ustcomm_send_fds_unix_sock(sock
, shm_fd
, 1);
3443 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3445 counter_cpu_data
->handle
= lur
.ret_val
;
3451 * Protocol for LTTNG_UST_ABI_COUNTER command:
3453 * - send: struct ustcomm_ust_msg
3454 * - receive: struct ustcomm_ust_reply
3455 * - send: counter data
3456 * - receive: struct ustcomm_ust_reply (actual command return code)
3458 int lttng_ust_ctl_send_counter_data_to_ust(int sock
, int parent_handle
,
3459 struct lttng_ust_abi_object_data
*counter_data
)
3461 struct ustcomm_ust_msg lum
= {};
3462 struct ustcomm_ust_reply lur
;
3470 size
= counter_data
->size
;
3471 lum
.handle
= parent_handle
;
3472 lum
.cmd
= LTTNG_UST_ABI_COUNTER
;
3473 lum
.u
.var_len_cmd
.cmd_len
= size
;
3474 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3475 if (ret
== -LTTNG_UST_ERR_INVAL
) {
3476 return lttng_ust_ctl_send_old_counter_data_to_ust(sock
, parent_handle
, counter_data
);
3482 /* Send var len cmd */
3483 len
= ustcomm_send_unix_sock(sock
, counter_data
->u
.counter
.data
, size
);
3491 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3493 counter_data
->handle
= lur
.ret_val
;
3499 * Protocol for LTTNG_UST_ABI_COUNTER_GLOBAL command:
3501 * - send: struct ustcomm_ust_msg
3502 * - receive: struct ustcomm_ust_reply
3503 * - send: file descriptor
3504 * - receive: struct ustcomm_ust_reply (actual command return code)
3506 int lttng_ust_ctl_send_counter_global_data_to_ust(int sock
,
3507 struct lttng_ust_abi_object_data
*counter_data
,
3508 struct lttng_ust_abi_object_data
*counter_global_data
)
3510 struct lttng_ust_abi_counter_global counter_global
= {};
3511 struct ustcomm_ust_msg lum
= {};
3512 struct ustcomm_ust_reply lur
;
3517 if (!counter_data
|| !counter_global_data
)
3520 size
= counter_global_data
->size
;
3521 lum
.handle
= counter_data
->handle
; /* parent handle */
3522 lum
.cmd
= LTTNG_UST_ABI_COUNTER_GLOBAL
;
3523 lum
.u
.var_len_cmd
.cmd_len
= sizeof(struct lttng_ust_abi_counter_global
);
3524 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3525 if (ret
== -LTTNG_UST_ERR_INVAL
) {
3526 return lttng_ust_ctl_send_old_counter_global_data_to_ust(sock
, counter_data
, counter_global_data
);
3532 counter_global
.len
= sizeof(struct lttng_ust_abi_counter_global
);
3533 counter_global
.shm_len
= size
;
3535 /* Send var len cmd */
3536 len
= ustcomm_send_unix_sock(sock
, &counter_global
, sizeof(struct lttng_ust_abi_counter_global
));
3537 if (len
!= sizeof(struct lttng_ust_abi_counter_global
)) {
3544 shm_fd
[0] = counter_global_data
->u
.counter_global
.shm_fd
;
3545 len
= ustcomm_send_fds_unix_sock(sock
, shm_fd
, 1);
3553 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3555 counter_global_data
->handle
= lur
.ret_val
;
3561 * Protocol for LTTNG_UST_ABI_COUNTER_CPU command:
3563 * - send: struct ustcomm_ust_msg
3564 * - receive: struct ustcomm_ust_reply
3565 * - send: file descriptor
3566 * - receive: struct ustcomm_ust_reply (actual command return code)
3568 int lttng_ust_ctl_send_counter_cpu_data_to_ust(int sock
,
3569 struct lttng_ust_abi_object_data
*counter_data
,
3570 struct lttng_ust_abi_object_data
*counter_cpu_data
)
3572 struct lttng_ust_abi_counter_cpu counter_cpu
= {};
3573 struct ustcomm_ust_msg lum
= {};
3574 struct ustcomm_ust_reply lur
;
3579 if (!counter_data
|| !counter_cpu_data
)
3582 size
= counter_cpu_data
->size
;
3583 lum
.handle
= counter_data
->handle
; /* parent handle */
3584 lum
.cmd
= LTTNG_UST_ABI_COUNTER_CPU
;
3585 lum
.u
.var_len_cmd
.cmd_len
= sizeof(struct lttng_ust_abi_counter_cpu
);
3586 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3587 if (ret
== -LTTNG_UST_ERR_INVAL
) {
3588 return lttng_ust_ctl_send_old_counter_cpu_data_to_ust(sock
, counter_data
, counter_cpu_data
);
3594 counter_cpu
.len
= sizeof(struct lttng_ust_abi_counter_cpu
);
3595 counter_cpu
.shm_len
= size
;
3596 counter_cpu
.cpu_nr
= counter_cpu_data
->u
.counter_cpu
.cpu_nr
;
3598 /* Send var len cmd */
3599 len
= ustcomm_send_unix_sock(sock
, &counter_cpu
, sizeof(struct lttng_ust_abi_counter_cpu
));
3600 if (len
!= sizeof(struct lttng_ust_abi_counter_cpu
)) {
3607 shm_fd
[0] = counter_cpu_data
->u
.counter_global
.shm_fd
;
3608 len
= ustcomm_send_fds_unix_sock(sock
, shm_fd
, 1);
3616 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3618 counter_cpu_data
->handle
= lur
.ret_val
;
3623 int lttng_ust_ctl_counter_read(struct lttng_ust_ctl_daemon_counter
*counter
,
3624 const size_t *dimension_indexes
,
3625 int cpu
, int64_t *value
,
3626 bool *overflow
, bool *underflow
)
3628 return counter
->ops
->priv
->counter_read(counter
->counter
, dimension_indexes
, cpu
,
3629 value
, overflow
, underflow
);
3632 int lttng_ust_ctl_counter_aggregate(struct lttng_ust_ctl_daemon_counter
*counter
,
3633 const size_t *dimension_indexes
,
3635 bool *overflow
, bool *underflow
)
3637 return counter
->ops
->priv
->counter_aggregate(counter
->counter
, dimension_indexes
,
3638 value
, overflow
, underflow
);
3641 int lttng_ust_ctl_counter_clear(struct lttng_ust_ctl_daemon_counter
*counter
,
3642 const size_t *dimension_indexes
)
3644 return counter
->ops
->priv
->counter_clear(counter
->counter
, dimension_indexes
);
3648 * Protocol for LTTNG_UST_COUNTER_EVENT command:
3650 * - send: struct ustcomm_ust_msg
3651 * - receive: struct ustcomm_ust_reply
3652 * - send: struct lttng_ust_counter_event
3653 * - receive: struct ustcomm_ust_reply (actual command return code)
3655 int lttng_ust_ctl_counter_create_event(int sock
,
3656 struct lttng_ust_abi_counter_event
*counter_event
,
3657 size_t counter_event_len
,
3658 struct lttng_ust_abi_object_data
*counter_data
,
3659 struct lttng_ust_abi_object_data
**_counter_event_data
)
3661 struct ustcomm_ust_msg lum
= {};
3662 struct ustcomm_ust_reply lur
;
3663 struct lttng_ust_abi_object_data
*counter_event_data
;
3667 if (!counter_data
|| !_counter_event_data
)
3670 counter_event_data
= zmalloc(sizeof(*counter_event_data
));
3671 if (!counter_event_data
)
3673 counter_event_data
->type
= LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_EVENT
;
3674 lum
.handle
= counter_data
->handle
;
3675 lum
.cmd
= LTTNG_UST_ABI_COUNTER_EVENT
;
3676 lum
.u
.var_len_cmd
.cmd_len
= counter_event_len
;
3677 ret
= ustcomm_send_app_cmd(sock
, &lum
, &lur
);
3679 free(counter_event_data
);
3683 /* Send var len cmd */
3684 len
= ustcomm_send_unix_sock(sock
, counter_event
, counter_event_len
);
3685 if (len
!= counter_event_len
) {
3686 free(counter_event_data
);
3692 ret
= ustcomm_recv_app_reply(sock
, &lur
, lum
.handle
, lum
.cmd
);
3694 free(counter_event_data
);
3697 counter_event_data
->handle
= lur
.ret_val
;
3698 DBG("received counter event handle %u", counter_event_data
->handle
);
3699 *_counter_event_data
= counter_event_data
;
3703 int lttng_ust_ctl_get_version(uint32_t *major
, uint32_t *minor
,
3704 uint32_t *patchlevel
) {
3705 *major
= LTTNG_UST_MAJOR_VERSION
;
3706 *minor
= LTTNG_UST_MINOR_VERSION
;
3707 *patchlevel
= LTTNG_UST_PATCHLEVEL_VERSION
;
3712 void lttng_ust_ctl_ctor(void)
3713 __attribute__((constructor
));
3715 void lttng_ust_ctl_ctor(void)
3718 * Call the liblttng-ust-common constructor to ensure it runs first.
3720 lttng_ust_common_ctor();
3722 lttng_ust_ring_buffer_clients_init();
3723 lttng_ust_counter_clients_init();
3724 lib_ringbuffer_signal_init();
3728 void lttng_ust_ctl_exit(void)
3729 __attribute__((destructor
));
3731 void lttng_ust_ctl_exit(void)
3733 lttng_ust_counter_clients_exit();
3734 lttng_ust_ring_buffer_clients_exit();