2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include <common/common.h>
25 #include <common/defaults.h>
26 #include <common/sessiond-comm/sessiond-comm.h>
29 #include "lttng-sessiond.h"
37 * Return allocated channel attributes.
39 struct lttng_channel
*channel_new_default_attr(int dom
,
40 enum lttng_buffer_type type
)
42 struct lttng_channel
*chan
;
43 const char *channel_name
= DEFAULT_CHANNEL_NAME
;
44 struct lttng_channel_extended
*extended_attr
= NULL
;
46 chan
= zmalloc(sizeof(struct lttng_channel
));
48 PERROR("zmalloc channel init");
52 extended_attr
= zmalloc(sizeof(struct lttng_channel_extended
));
54 PERROR("zmalloc channel extended init");
58 chan
->attr
.extended
.ptr
= extended_attr
;
60 /* Same for all domains. */
61 chan
->attr
.overwrite
= DEFAULT_CHANNEL_OVERWRITE
;
62 chan
->attr
.tracefile_size
= DEFAULT_CHANNEL_TRACEFILE_SIZE
;
63 chan
->attr
.tracefile_count
= DEFAULT_CHANNEL_TRACEFILE_COUNT
;
66 case LTTNG_DOMAIN_KERNEL
:
67 assert(type
== LTTNG_BUFFER_GLOBAL
);
68 chan
->attr
.subbuf_size
=
69 default_get_kernel_channel_subbuf_size();
70 chan
->attr
.num_subbuf
= DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM
;
71 chan
->attr
.output
= DEFAULT_KERNEL_CHANNEL_OUTPUT
;
72 chan
->attr
.switch_timer_interval
= DEFAULT_KERNEL_CHANNEL_SWITCH_TIMER
;
73 chan
->attr
.read_timer_interval
= DEFAULT_KERNEL_CHANNEL_READ_TIMER
;
74 chan
->attr
.live_timer_interval
= DEFAULT_KERNEL_CHANNEL_LIVE_TIMER
;
75 extended_attr
->blocking_timeout
= DEFAULT_KERNEL_CHANNEL_BLOCKING_TIMEOUT
;
76 extended_attr
->monitor_timer_interval
=
77 DEFAULT_KERNEL_CHANNEL_MONITOR_TIMER
;
79 case LTTNG_DOMAIN_JUL
:
80 channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
82 case LTTNG_DOMAIN_LOG4J
:
83 channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
85 case LTTNG_DOMAIN_PYTHON
:
86 channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
88 case LTTNG_DOMAIN_UST
:
91 case LTTNG_BUFFER_PER_UID
:
92 chan
->attr
.subbuf_size
= default_get_ust_uid_channel_subbuf_size();
93 chan
->attr
.num_subbuf
= DEFAULT_UST_UID_CHANNEL_SUBBUF_NUM
;
94 chan
->attr
.output
= DEFAULT_UST_UID_CHANNEL_OUTPUT
;
95 chan
->attr
.switch_timer_interval
=
96 DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER
;
97 chan
->attr
.read_timer_interval
=
98 DEFAULT_UST_UID_CHANNEL_READ_TIMER
;
99 chan
->attr
.live_timer_interval
=
100 DEFAULT_UST_UID_CHANNEL_LIVE_TIMER
;
101 extended_attr
->blocking_timeout
= DEFAULT_UST_UID_CHANNEL_BLOCKING_TIMEOUT
;
102 extended_attr
->monitor_timer_interval
=
103 DEFAULT_UST_UID_CHANNEL_MONITOR_TIMER
;
105 case LTTNG_BUFFER_PER_PID
:
107 chan
->attr
.subbuf_size
= default_get_ust_pid_channel_subbuf_size();
108 chan
->attr
.num_subbuf
= DEFAULT_UST_PID_CHANNEL_SUBBUF_NUM
;
109 chan
->attr
.output
= DEFAULT_UST_PID_CHANNEL_OUTPUT
;
110 chan
->attr
.switch_timer_interval
=
111 DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER
;
112 chan
->attr
.read_timer_interval
=
113 DEFAULT_UST_PID_CHANNEL_READ_TIMER
;
114 chan
->attr
.live_timer_interval
=
115 DEFAULT_UST_PID_CHANNEL_LIVE_TIMER
;
116 extended_attr
->blocking_timeout
= DEFAULT_UST_PID_CHANNEL_BLOCKING_TIMEOUT
;
117 extended_attr
->monitor_timer_interval
=
118 DEFAULT_UST_PID_CHANNEL_MONITOR_TIMER
;
123 goto error
; /* Not implemented */
126 if (snprintf(chan
->name
, sizeof(chan
->name
), "%s",
128 PERROR("snprintf default channel name");
140 void channel_attr_destroy(struct lttng_channel
*channel
)
145 free(channel
->attr
.extended
.ptr
);
150 * Disable kernel channel of the kernel session.
152 int channel_kernel_disable(struct ltt_kernel_session
*ksession
,
156 struct ltt_kernel_channel
*kchan
;
159 assert(channel_name
);
161 kchan
= trace_kernel_get_channel_by_name(channel_name
, ksession
);
163 ret
= LTTNG_ERR_KERN_CHAN_NOT_FOUND
;
167 /* Only if channel is enabled disable it. */
168 if (kchan
->enabled
== 1) {
169 ret
= kernel_disable_channel(kchan
);
170 if (ret
< 0 && ret
!= -EEXIST
) {
171 ret
= LTTNG_ERR_KERN_CHAN_DISABLE_FAIL
;
183 * Enable kernel channel of the kernel session.
185 int channel_kernel_enable(struct ltt_kernel_session
*ksession
,
186 struct ltt_kernel_channel
*kchan
)
193 if (kchan
->enabled
== 0) {
194 ret
= kernel_enable_channel(kchan
);
196 ret
= LTTNG_ERR_KERN_CHAN_ENABLE_FAIL
;
200 ret
= LTTNG_ERR_KERN_CHAN_EXIST
;
210 static int channel_validate(struct lttng_channel
*attr
)
213 * The ringbuffer (both in user space and kernel) behaves badly
214 * in overwrite mode and with less than 2 subbuffers so block it
215 * right away and send back an invalid attribute error.
217 if (attr
->attr
.overwrite
&& attr
->attr
.num_subbuf
< 2) {
223 static int channel_validate_kernel(struct lttng_channel
*attr
)
225 /* Kernel channels do not support blocking timeout. */
226 if (((struct lttng_channel_extended
*)attr
->attr
.extended
.ptr
)->blocking_timeout
) {
233 * Create kernel channel of the kernel session and notify kernel thread.
235 int channel_kernel_create(struct ltt_kernel_session
*ksession
,
236 struct lttng_channel
*attr
, int kernel_pipe
)
239 struct lttng_channel
*defattr
= NULL
;
243 /* Creating channel attributes if needed */
245 defattr
= channel_new_default_attr(LTTNG_DOMAIN_KERNEL
,
246 LTTNG_BUFFER_GLOBAL
);
247 if (defattr
== NULL
) {
248 ret
= LTTNG_ERR_FATAL
;
255 * Set the overwrite mode for this channel based on the session
256 * type unless the client explicitly overrides the channel mode.
258 if (attr
->attr
.overwrite
== DEFAULT_CHANNEL_OVERWRITE
) {
259 attr
->attr
.overwrite
= !!ksession
->snapshot_mode
;
262 /* Enforce mmap output for snapshot sessions. */
263 if (ksession
->snapshot_mode
) {
264 attr
->attr
.output
= LTTNG_EVENT_MMAP
;
267 /* Validate common channel properties. */
268 if (channel_validate(attr
) < 0) {
269 ret
= LTTNG_ERR_INVALID
;
273 if (channel_validate_kernel(attr
) < 0) {
274 ret
= LTTNG_ERR_INVALID
;
278 /* Channel not found, creating it */
279 ret
= kernel_create_channel(ksession
, attr
);
281 ret
= LTTNG_ERR_KERN_CHAN_FAIL
;
285 /* Notify kernel thread that there is a new channel */
286 ret
= notify_thread_pipe(kernel_pipe
);
288 ret
= LTTNG_ERR_FATAL
;
294 channel_attr_destroy(defattr
);
299 * Enable UST channel for session and domain.
301 int channel_ust_enable(struct ltt_ust_session
*usess
,
302 struct ltt_ust_channel
*uchan
)
309 /* If already enabled, everything is OK */
310 if (uchan
->enabled
) {
311 DBG3("Channel %s already enabled. Skipping", uchan
->name
);
312 ret
= LTTNG_ERR_UST_CHAN_EXIST
;
316 DBG2("Channel %s enabled successfully", uchan
->name
);
319 if (!usess
->active
) {
321 * The channel will be activated against the apps
322 * when the session is started as part of the
323 * application channel "synchronize" operation.
328 DBG2("Channel %s being enabled in UST domain", uchan
->name
);
331 * Enable channel for UST global domain on all applications. Ignore return
332 * value here since whatever error we got, it means that the channel was
333 * not created on one or many registered applications and we can not report
334 * this to the user yet. However, at this stage, the channel was
335 * successfully created on the session daemon side so the enable-channel
336 * command is a success.
338 (void) ust_app_enable_channel_glb(usess
, uchan
);
346 * Create UST channel for session and domain.
348 int channel_ust_create(struct ltt_ust_session
*usess
,
349 struct lttng_channel
*attr
, enum lttng_buffer_type type
)
352 struct ltt_ust_channel
*uchan
= NULL
;
353 struct lttng_channel
*defattr
= NULL
;
354 enum lttng_domain_type domain
= LTTNG_DOMAIN_UST
;
355 bool chan_published
= false;
359 /* Creating channel attributes if needed */
361 defattr
= channel_new_default_attr(LTTNG_DOMAIN_UST
, type
);
362 if (defattr
== NULL
) {
363 ret
= LTTNG_ERR_FATAL
;
369 * HACK: Set the channel's subdomain (JUL, Log4j, Python, etc.)
370 * based on the default name.
372 if (!strcmp(attr
->name
, DEFAULT_JUL_CHANNEL_NAME
)) {
373 domain
= LTTNG_DOMAIN_JUL
;
374 } else if (!strcmp(attr
->name
, DEFAULT_LOG4J_CHANNEL_NAME
)) {
375 domain
= LTTNG_DOMAIN_LOG4J
;
376 } else if (!strcmp(attr
->name
, DEFAULT_PYTHON_CHANNEL_NAME
)) {
377 domain
= LTTNG_DOMAIN_PYTHON
;
382 * Set the overwrite mode for this channel based on the session
383 * type unless the client explicitly overrides the channel mode.
385 if (attr
->attr
.overwrite
== DEFAULT_CHANNEL_OVERWRITE
) {
386 attr
->attr
.overwrite
= !!usess
->snapshot_mode
;
389 /* Enforce mmap output for snapshot sessions. */
390 if (usess
->snapshot_mode
) {
391 attr
->attr
.output
= LTTNG_EVENT_MMAP
;
394 /* Validate common channel properties. */
395 if (channel_validate(attr
) < 0) {
396 ret
= LTTNG_ERR_INVALID
;
401 * Validate UST buffer size and number of buffers: must both be power of 2
402 * and nonzero. We validate right here for UST, because applications will
403 * not report the error to the user (unlike kernel tracing).
405 if (!attr
->attr
.subbuf_size
||
406 (attr
->attr
.subbuf_size
& (attr
->attr
.subbuf_size
- 1))) {
407 ret
= LTTNG_ERR_INVALID
;
412 * Invalid subbuffer size if it's lower then the page size.
414 if (attr
->attr
.subbuf_size
< page_size
) {
415 ret
= LTTNG_ERR_INVALID
;
419 if (!attr
->attr
.num_subbuf
||
420 (attr
->attr
.num_subbuf
& (attr
->attr
.num_subbuf
- 1))) {
421 ret
= LTTNG_ERR_INVALID
;
425 if (attr
->attr
.output
!= LTTNG_EVENT_MMAP
) {
426 ret
= LTTNG_ERR_NOT_SUPPORTED
;
431 * The tracefile_size should not be < to the subbuf_size, otherwise
432 * we won't be able to write the packets on disk
434 if ((attr
->attr
.tracefile_size
> 0) &&
435 (attr
->attr
.tracefile_size
< attr
->attr
.subbuf_size
)) {
436 ret
= LTTNG_ERR_INVALID
;
440 /* Validate buffer type. */
442 case LTTNG_BUFFER_PER_PID
:
444 case LTTNG_BUFFER_PER_UID
:
447 ret
= LTTNG_ERR_BUFFER_NOT_SUPPORTED
;
451 /* Create UST channel */
452 uchan
= trace_ust_create_channel(attr
, domain
);
454 ret
= LTTNG_ERR_FATAL
;
459 if (trace_ust_is_max_id(usess
->used_channel_id
)) {
460 ret
= LTTNG_ERR_UST_CHAN_FAIL
;
463 uchan
->id
= trace_ust_get_next_chan_id(usess
);
465 DBG2("Channel %s is being created for UST with buffer %d and id %" PRIu64
,
466 uchan
->name
, type
, uchan
->id
);
468 /* Flag session buffer type. */
469 if (!usess
->buffer_type_changed
) {
470 usess
->buffer_type
= type
;
471 usess
->buffer_type_changed
= 1;
472 } else if (usess
->buffer_type
!= type
) {
473 /* Buffer type was already set. Refuse to create channel. */
474 ret
= LTTNG_ERR_BUFFER_TYPE_MISMATCH
;
475 goto error_free_chan
;
479 /* Enable channel for global domain */
480 ret
= ust_app_create_channel_glb(usess
, uchan
);
481 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
482 ret
= LTTNG_ERR_UST_CHAN_FAIL
;
483 goto error_free_chan
;
487 /* Adding the channel to the channel hash table. */
489 if (strncmp(uchan
->name
, DEFAULT_METADATA_NAME
,
490 sizeof(uchan
->name
))) {
491 lttng_ht_add_unique_str(usess
->domain_global
.channels
, &uchan
->node
);
492 chan_published
= true;
495 * Copy channel attribute to session if this is metadata so if NO
496 * application exists we can access that data in the shadow copy during
497 * the global update of newly registered application.
499 memcpy(&usess
->metadata_attr
, &uchan
->attr
,
500 sizeof(usess
->metadata_attr
));
504 DBG2("Channel %s created successfully", uchan
->name
);
505 if (domain
!= LTTNG_DOMAIN_UST
) {
506 struct agent
*agt
= trace_ust_find_agent(usess
, domain
);
509 agt
= agent_create(domain
);
511 ret
= LTTNG_ERR_NOMEM
;
512 goto error_remove_chan
;
514 agent_add(agt
, usess
->agents
);
518 channel_attr_destroy(defattr
);
522 if (chan_published
) {
523 trace_ust_delete_channel(usess
->domain_global
.channels
, uchan
);
526 trace_ust_destroy_channel(uchan
);
528 channel_attr_destroy(defattr
);
533 * Disable UST channel for session and domain.
535 int channel_ust_disable(struct ltt_ust_session
*usess
,
536 struct ltt_ust_channel
*uchan
)
543 /* Already disabled */
544 if (uchan
->enabled
== 0) {
545 DBG2("Channel UST %s already disabled", uchan
->name
);
548 if (!usess
->active
) {
552 DBG2("Channel %s being disabled in UST global domain", uchan
->name
);
553 /* Disable channel for global domain */
554 ret
= ust_app_disable_channel_glb(usess
, uchan
);
555 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
556 ret
= LTTNG_ERR_UST_CHAN_DISABLE_FAIL
;
562 DBG2("Channel %s disabled successfully", uchan
->name
);