projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: sessiond: don't negate error code on list error
[lttng-tools.git] / src / bin / lttng-sessiond / cmd.c
1 /*
2 * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License, version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 51
16 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #define _LGPL_SOURCE
20 #include <assert.h>
21 #include <inttypes.h>
22 #include <urcu/list.h>
23 #include <urcu/uatomic.h>
24 #include <sys/stat.h>
25 #include <stdio.h>
26
27 #include <common/defaults.h>
28 #include <common/common.h>
29 #include <common/sessiond-comm/sessiond-comm.h>
30 #include <common/relayd/relayd.h>
31 #include <common/utils.h>
32 #include <common/compat/string.h>
33 #include <common/kernel-ctl/kernel-ctl.h>
34 #include <common/dynamic-buffer.h>
35 #include <common/buffer-view.h>
36 #include <common/trace-chunk.h>
37 #include <lttng/location-internal.h>
38 #include <lttng/trigger/trigger-internal.h>
39 #include <lttng/condition/condition.h>
40 #include <lttng/action/action.h>
41 #include <lttng/channel.h>
42 #include <lttng/channel-internal.h>
43 #include <lttng/rotate-internal.h>
44 #include <lttng/location-internal.h>
45 #include <lttng/session-internal.h>
46 #include <lttng/userspace-probe-internal.h>
47 #include <lttng/session-descriptor-internal.h>
48 #include <common/string-utils/string-utils.h>
49
50 #include "channel.h"
51 #include "consumer.h"
52 #include "event.h"
53 #include "health-sessiond.h"
54 #include "kernel.h"
55 #include "kernel-consumer.h"
56 #include "lttng-sessiond.h"
57 #include "utils.h"
58 #include "lttng-syscall.h"
59 #include "agent.h"
60 #include "buffer-registry.h"
61 #include "notification-thread.h"
62 #include "notification-thread-commands.h"
63 #include "rotate.h"
64 #include "rotation-thread.h"
65 #include "timer.h"
66 #include "agent-thread.h"
67
68 #include "cmd.h"
69
70 /* Sleep for 100ms between each check for the shm path's deletion. */
71 #define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
72
73 struct cmd_destroy_session_reply_context {
74 int reply_sock_fd;
75 bool implicit_rotation_on_destroy;
76 /*
77 * Indicates whether or not an error occurred while launching the
78 * destruction of a session.
79 */
80 enum lttng_error_code destruction_status;
81 };
82
83 static enum lttng_error_code wait_on_path(void *path);
84
85 /*
86 * Command completion handler that is used by the destroy command
87 * when a session that has a non-default shm_path is being destroyed.
88 *
89 * See comment in cmd_destroy_session() for the rationale.
90 */
91 static struct destroy_completion_handler {
92 struct cmd_completion_handler handler;
93 char shm_path[member_sizeof(struct ltt_session, shm_path)];
94 } destroy_completion_handler = {
95 .handler = {
96 .run = wait_on_path,
97 .data = destroy_completion_handler.shm_path
98 },
99 .shm_path = { 0 },
100 };
101
102 static struct cmd_completion_handler *current_completion_handler;
103
104 /*
105 * Used to keep a unique index for each relayd socket created where this value
106 * is associated with streams on the consumer so it can match the right relayd
107 * to send to. It must be accessed with the relayd_net_seq_idx_lock
108 * held.
109 */
110 static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
111 static uint64_t relayd_net_seq_idx;
112
113 static int validate_ust_event_name(const char *);
114 static int cmd_enable_event_internal(struct ltt_session *session,
115 const struct lttng_domain *domain,
116 char *channel_name, struct lttng_event *event,
117 char *filter_expression,
118 struct lttng_filter_bytecode *filter,
119 struct lttng_event_exclusion *exclusion,
120 int wpipe);
121
122 /*
123 * Create a session path used by list_lttng_sessions for the case that the
124 * session consumer is on the network.
125 */
126 static int build_network_session_path(char *dst, size_t size,
127 struct ltt_session *session)
128 {
129 int ret, kdata_port, udata_port;
130 struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
131 char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
132
133 assert(session);
134 assert(dst);
135
136 memset(tmp_urls, 0, sizeof(tmp_urls));
137 memset(tmp_uurl, 0, sizeof(tmp_uurl));
138
139 kdata_port = udata_port = DEFAULT_NETWORK_DATA_PORT;
140
141 if (session->kernel_session && session->kernel_session->consumer) {
142 kuri = &session->kernel_session->consumer->dst.net.control;
143 kdata_port = session->kernel_session->consumer->dst.net.data.port;
144 }
145
146 if (session->ust_session && session->ust_session->consumer) {
147 uuri = &session->ust_session->consumer->dst.net.control;
148 udata_port = session->ust_session->consumer->dst.net.data.port;
149 }
150
151 if (uuri == NULL && kuri == NULL) {
152 uri = &session->consumer->dst.net.control;
153 kdata_port = session->consumer->dst.net.data.port;
154 } else if (kuri && uuri) {
155 ret = uri_compare(kuri, uuri);
156 if (ret) {
157 /* Not Equal */
158 uri = kuri;
159 /* Build uuri URL string */
160 ret = uri_to_str_url(uuri, tmp_uurl, sizeof(tmp_uurl));
161 if (ret < 0) {
162 goto error;
163 }
164 } else {
165 uri = kuri;
166 }
167 } else if (kuri && uuri == NULL) {
168 uri = kuri;
169 } else if (uuri && kuri == NULL) {
170 uri = uuri;
171 }
172
173 ret = uri_to_str_url(uri, tmp_urls, sizeof(tmp_urls));
174 if (ret < 0) {
175 goto error;
176 }
177
178 /*
179 * Do we have a UST url set. If yes, this means we have both kernel and UST
180 * to print.
181 */
182 if (*tmp_uurl != '\0') {
183 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
184 tmp_urls, kdata_port, tmp_uurl, udata_port);
185 } else {
186 int dport;
187 if (kuri || (!kuri && !uuri)) {
188 dport = kdata_port;
189 } else {
190 /* No kernel URI, use the UST port. */
191 dport = udata_port;
192 }
193 ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, dport);
194 }
195
196 error:
197 return ret;
198 }
199
200 /*
201 * Get run-time attributes if the session has been started (discarded events,
202 * lost packets).
203 */
204 static int get_kernel_runtime_stats(struct ltt_session *session,
205 struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
206 uint64_t *lost_packets)
207 {
208 int ret;
209
210 if (!session->has_been_started) {
211 ret = 0;
212 *discarded_events = 0;
213 *lost_packets = 0;
214 goto end;
215 }
216
217 ret = consumer_get_discarded_events(session->id, kchan->key,
218 session->kernel_session->consumer,
219 discarded_events);
220 if (ret < 0) {
221 goto end;
222 }
223
224 ret = consumer_get_lost_packets(session->id, kchan->key,
225 session->kernel_session->consumer,
226 lost_packets);
227 if (ret < 0) {
228 goto end;
229 }
230
231 end:
232 return ret;
233 }
234
235 /*
236 * Get run-time attributes if the session has been started (discarded events,
237 * lost packets).
238 */
239 static int get_ust_runtime_stats(struct ltt_session *session,
240 struct ltt_ust_channel *uchan, uint64_t *discarded_events,
241 uint64_t *lost_packets)
242 {
243 int ret;
244 struct ltt_ust_session *usess;
245
246 if (!discarded_events || !lost_packets) {
247 ret = -1;
248 goto end;
249 }
250
251 usess = session->ust_session;
252 assert(discarded_events);
253 assert(lost_packets);
254
255 if (!usess || !session->has_been_started) {
256 *discarded_events = 0;
257 *lost_packets = 0;
258 ret = 0;
259 goto end;
260 }
261
262 if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
263 ret = ust_app_uid_get_channel_runtime_stats(usess->id,
264 &usess->buffer_reg_uid_list,
265 usess->consumer, uchan->id,
266 uchan->attr.overwrite,
267 discarded_events,
268 lost_packets);
269 } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
270 ret = ust_app_pid_get_channel_runtime_stats(usess,
271 uchan, usess->consumer,
272 uchan->attr.overwrite,
273 discarded_events,
274 lost_packets);
275 if (ret < 0) {
276 goto end;
277 }
278 *discarded_events += uchan->per_pid_closed_app_discarded;
279 *lost_packets += uchan->per_pid_closed_app_lost;
280 } else {
281 ERR("Unsupported buffer type");
282 assert(0);
283 ret = -1;
284 goto end;
285 }
286
287 end:
288 return ret;
289 }
290
291 /*
292 * Fill lttng_channel array of all channels.
293 */
294 static ssize_t list_lttng_channels(enum lttng_domain_type domain,
295 struct ltt_session *session, struct lttng_channel *channels,
296 struct lttng_channel_extended *chan_exts)
297 {
298 int i = 0, ret = 0;
299 struct ltt_kernel_channel *kchan;
300
301 DBG("Listing channels for session %s", session->name);
302
303 switch (domain) {
304 case LTTNG_DOMAIN_KERNEL:
305 /* Kernel channels */
306 if (session->kernel_session != NULL) {
307 cds_list_for_each_entry(kchan,
308 &session->kernel_session->channel_list.head, list) {
309 uint64_t discarded_events, lost_packets;
310 struct lttng_channel_extended *extended;
311
312 extended = (struct lttng_channel_extended *)
313 kchan->channel->attr.extended.ptr;
314
315 ret = get_kernel_runtime_stats(session, kchan,
316 &discarded_events, &lost_packets);
317 if (ret < 0) {
318 goto end;
319 }
320 /* Copy lttng_channel struct to array */
321 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
322 channels[i].enabled = kchan->enabled;
323 chan_exts[i].discarded_events =
324 discarded_events;
325 chan_exts[i].lost_packets = lost_packets;
326 chan_exts[i].monitor_timer_interval =
327 extended->monitor_timer_interval;
328 chan_exts[i].blocking_timeout = 0;
329 i++;
330 }
331 }
332 break;
333 case LTTNG_DOMAIN_UST:
334 {
335 struct lttng_ht_iter iter;
336 struct ltt_ust_channel *uchan;
337
338 rcu_read_lock();
339 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
340 &iter.iter, uchan, node.node) {
341 uint64_t discarded_events = 0, lost_packets = 0;
342
343 if (lttng_strncpy(channels[i].name, uchan->name,
344 LTTNG_SYMBOL_NAME_LEN)) {
345 break;
346 }
347 channels[i].attr.overwrite = uchan->attr.overwrite;
348 channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
349 channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
350 channels[i].attr.switch_timer_interval =
351 uchan->attr.switch_timer_interval;
352 channels[i].attr.read_timer_interval =
353 uchan->attr.read_timer_interval;
354 channels[i].enabled = uchan->enabled;
355 channels[i].attr.tracefile_size = uchan->tracefile_size;
356 channels[i].attr.tracefile_count = uchan->tracefile_count;
357
358 /*
359 * Map enum lttng_ust_output to enum lttng_event_output.
360 */
361 switch (uchan->attr.output) {
362 case LTTNG_UST_MMAP:
363 channels[i].attr.output = LTTNG_EVENT_MMAP;
364 break;
365 default:
366 /*
367 * LTTNG_UST_MMAP is the only supported UST
368 * output mode.
369 */
370 assert(0);
371 break;
372 }
373
374 chan_exts[i].monitor_timer_interval =
375 uchan->monitor_timer_interval;
376 chan_exts[i].blocking_timeout =
377 uchan->attr.u.s.blocking_timeout;
378
379 ret = get_ust_runtime_stats(session, uchan,
380 &discarded_events, &lost_packets);
381 if (ret < 0) {
382 break;
383 }
384 chan_exts[i].discarded_events = discarded_events;
385 chan_exts[i].lost_packets = lost_packets;
386 i++;
387 }
388 rcu_read_unlock();
389 break;
390 }
391 default:
392 break;
393 }
394
395 end:
396 if (ret < 0) {
397 return -LTTNG_ERR_FATAL;
398 } else {
399 return LTTNG_OK;
400 }
401 }
402
403 static int increment_extended_len(const char *filter_expression,
404 struct lttng_event_exclusion *exclusion,
405 const struct lttng_userspace_probe_location *probe_location,
406 size_t *extended_len)
407 {
408 int ret = 0;
409
410 *extended_len += sizeof(struct lttcomm_event_extended_header);
411
412 if (filter_expression) {
413 *extended_len += strlen(filter_expression) + 1;
414 }
415
416 if (exclusion) {
417 *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN;
418 }
419
420 if (probe_location) {
421 ret = lttng_userspace_probe_location_serialize(probe_location,
422 NULL, NULL);
423 if (ret < 0) {
424 goto end;
425 }
426 *extended_len += ret;
427 }
428 ret = 0;
429 end:
430 return ret;
431 }
432
433 static int append_extended_info(const char *filter_expression,
434 struct lttng_event_exclusion *exclusion,
435 struct lttng_userspace_probe_location *probe_location,
436 void **extended_at)
437 {
438 int ret = 0;
439 size_t filter_len = 0;
440 size_t nb_exclusions = 0;
441 size_t userspace_probe_location_len = 0;
442 struct lttng_dynamic_buffer location_buffer;
443 struct lttcomm_event_extended_header extended_header;
444
445 if (filter_expression) {
446 filter_len = strlen(filter_expression) + 1;
447 }
448
449 if (exclusion) {
450 nb_exclusions = exclusion->count;
451 }
452
453 if (probe_location) {
454 lttng_dynamic_buffer_init(&location_buffer);
455 ret = lttng_userspace_probe_location_serialize(probe_location,
456 &location_buffer, NULL);
457 if (ret < 0) {
458 ret = -1;
459 goto end;
460 }
461 userspace_probe_location_len = location_buffer.size;
462 }
463
464 /* Set header fields */
465 extended_header.filter_len = filter_len;
466 extended_header.nb_exclusions = nb_exclusions;
467 extended_header.userspace_probe_location_len = userspace_probe_location_len;
468
469 /* Copy header */
470 memcpy(*extended_at, &extended_header, sizeof(extended_header));
471 *extended_at += sizeof(extended_header);
472
473 /* Copy filter string */
474 if (filter_expression) {
475 memcpy(*extended_at, filter_expression, filter_len);
476 *extended_at += filter_len;
477 }
478
479 /* Copy exclusion names */
480 if (exclusion) {
481 size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN;
482
483 memcpy(*extended_at, &exclusion->names, len);
484 *extended_at += len;
485 }
486
487 if (probe_location) {
488 memcpy(*extended_at, location_buffer.data, location_buffer.size);
489 *extended_at += location_buffer.size;
490 lttng_dynamic_buffer_reset(&location_buffer);
491 }
492 ret = 0;
493 end:
494 return ret;
495 }
496
497 /*
498 * Create a list of agent domain events.
499 *
500 * Return number of events in list on success or else a negative value.
501 */
502 static int list_lttng_agent_events(struct agent *agt,
503 struct lttng_event **events, size_t *total_size)
504 {
505 int i = 0, ret = 0;
506 unsigned int nb_event = 0;
507 struct agent_event *event;
508 struct lttng_event *tmp_events = NULL;
509 struct lttng_ht_iter iter;
510 size_t extended_len = 0;
511 void *extended_at;
512
513 assert(agt);
514 assert(events);
515
516 DBG3("Listing agent events");
517
518 rcu_read_lock();
519 nb_event = lttng_ht_get_count(agt->events);
520 rcu_read_unlock();
521 if (nb_event == 0) {
522 ret = nb_event;
523 *total_size = 0;
524 goto error;
525 }
526
527 /* Compute required extended infos size */
528 extended_len = nb_event * sizeof(struct lttcomm_event_extended_header);
529
530 /*
531 * This is only valid because the commands which add events are
532 * processed in the same thread as the listing.
533 */
534 rcu_read_lock();
535 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
536 ret = increment_extended_len(event->filter_expression, NULL, NULL,
537 &extended_len);
538 if (ret) {
539 DBG("Error computing the length of extended info message");
540 ret = -LTTNG_ERR_FATAL;
541 goto error;
542 }
543 }
544 rcu_read_unlock();
545
546 *total_size = nb_event * sizeof(*tmp_events) + extended_len;
547 tmp_events = zmalloc(*total_size);
548 if (!tmp_events) {
549 PERROR("zmalloc agent events session");
550 ret = -LTTNG_ERR_FATAL;
551 goto error;
552 }
553
554 extended_at = ((uint8_t *) tmp_events) +
555 nb_event * sizeof(struct lttng_event);
556
557 rcu_read_lock();
558 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
559 strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
560 tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
561 tmp_events[i].enabled = event->enabled;
562 tmp_events[i].loglevel = event->loglevel_value;
563 tmp_events[i].loglevel_type = event->loglevel_type;
564 i++;
565
566 /* Append extended info */
567 ret = append_extended_info(event->filter_expression, NULL, NULL,
568 &extended_at);
569 if (ret) {
570 DBG("Error appending extended info message");
571 ret = -LTTNG_ERR_FATAL;
572 goto error;
573 }
574 }
575
576 *events = tmp_events;
577 ret = nb_event;
578 assert(nb_event == i);
579
580 end:
581 rcu_read_unlock();
582 return ret;
583 error:
584 free(tmp_events);
585 goto end;
586 }
587
588 /*
589 * Create a list of ust global domain events.
590 */
591 static int list_lttng_ust_global_events(char *channel_name,
592 struct ltt_ust_domain_global *ust_global,
593 struct lttng_event **events, size_t *total_size)
594 {
595 int i = 0, ret = 0;
596 unsigned int nb_event = 0;
597 struct lttng_ht_iter iter;
598 struct lttng_ht_node_str *node;
599 struct ltt_ust_channel *uchan;
600 struct ltt_ust_event *uevent;
601 struct lttng_event *tmp;
602 size_t extended_len = 0;
603 void *extended_at;
604
605 DBG("Listing UST global events for channel %s", channel_name);
606
607 rcu_read_lock();
608
609 lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
610 node = lttng_ht_iter_get_node_str(&iter);
611 if (node == NULL) {
612 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
613 goto end;
614 }
615
616 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
617
618 nb_event = lttng_ht_get_count(uchan->events);
619 if (nb_event == 0) {
620 ret = nb_event;
621 *total_size = 0;
622 goto end;
623 }
624
625 DBG3("Listing UST global %d events", nb_event);
626
627 /* Compute required extended infos size */
628 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
629 if (uevent->internal) {
630 nb_event--;
631 continue;
632 }
633
634 ret = increment_extended_len(uevent->filter_expression,
635 uevent->exclusion, NULL, &extended_len);
636 if (ret) {
637 DBG("Error computing the length of extended info message");
638 ret = -LTTNG_ERR_FATAL;
639 goto end;
640 }
641 }
642 if (nb_event == 0) {
643 /* All events are internal, skip. */
644 ret = 0;
645 *total_size = 0;
646 goto end;
647 }
648
649 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
650 tmp = zmalloc(*total_size);
651 if (tmp == NULL) {
652 ret = -LTTNG_ERR_FATAL;
653 goto end;
654 }
655
656 extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event);
657
658 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
659 if (uevent->internal) {
660 /* This event should remain hidden from clients */
661 continue;
662 }
663 strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
664 tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
665 tmp[i].enabled = uevent->enabled;
666
667 switch (uevent->attr.instrumentation) {
668 case LTTNG_UST_TRACEPOINT:
669 tmp[i].type = LTTNG_EVENT_TRACEPOINT;
670 break;
671 case LTTNG_UST_PROBE:
672 tmp[i].type = LTTNG_EVENT_PROBE;
673 break;
674 case LTTNG_UST_FUNCTION:
675 tmp[i].type = LTTNG_EVENT_FUNCTION;
676 break;
677 }
678
679 tmp[i].loglevel = uevent->attr.loglevel;
680 switch (uevent->attr.loglevel_type) {
681 case LTTNG_UST_LOGLEVEL_ALL:
682 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
683 break;
684 case LTTNG_UST_LOGLEVEL_RANGE:
685 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
686 break;
687 case LTTNG_UST_LOGLEVEL_SINGLE:
688 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
689 break;
690 }
691 if (uevent->filter) {
692 tmp[i].filter = 1;
693 }
694 if (uevent->exclusion) {
695 tmp[i].exclusion = 1;
696 }
697 i++;
698
699 /* Append extended info */
700 ret = append_extended_info(uevent->filter_expression,
701 uevent->exclusion, NULL, &extended_at);
702 if (ret) {
703 DBG("Error appending extended info message");
704 ret = -LTTNG_ERR_FATAL;
705 goto end;
706 }
707 }
708
709 ret = nb_event;
710 *events = tmp;
711 end:
712 rcu_read_unlock();
713 return ret;
714 }
715
716 /*
717 * Fill lttng_event array of all kernel events in the channel.
718 */
719 static int list_lttng_kernel_events(char *channel_name,
720 struct ltt_kernel_session *kernel_session,
721 struct lttng_event **events, size_t *total_size)
722 {
723 int i = 0, ret;
724 unsigned int nb_event;
725 struct ltt_kernel_event *event;
726 struct ltt_kernel_channel *kchan;
727 size_t extended_len = 0;
728 void *extended_at;
729
730 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
731 if (kchan == NULL) {
732 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
733 goto error;
734 }
735
736 nb_event = kchan->event_count;
737
738 DBG("Listing events for channel %s", kchan->channel->name);
739
740 if (nb_event == 0) {
741 *total_size = 0;
742 *events = NULL;
743 goto end;
744 }
745
746 /* Compute required extended infos size */
747 cds_list_for_each_entry(event, &kchan->events_list.head, list) {
748 ret = increment_extended_len(event->filter_expression, NULL,
749 event->userspace_probe_location,
750 &extended_len);
751 if (ret) {
752 DBG("Error computing the length of extended info message");
753 ret = -LTTNG_ERR_FATAL;
754 goto error;
755 }
756 }
757
758 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
759 *events = zmalloc(*total_size);
760 if (*events == NULL) {
761 ret = -LTTNG_ERR_FATAL;
762 goto error;
763 }
764
765 extended_at = ((void *) *events) +
766 nb_event * sizeof(struct lttng_event);
767
768 /* Kernel channels */
769 cds_list_for_each_entry(event, &kchan->events_list.head , list) {
770 strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
771 (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
772 (*events)[i].enabled = event->enabled;
773 (*events)[i].filter =
774 (unsigned char) !!event->filter_expression;
775
776 switch (event->event->instrumentation) {
777 case LTTNG_KERNEL_TRACEPOINT:
778 (*events)[i].type = LTTNG_EVENT_TRACEPOINT;
779 break;
780 case LTTNG_KERNEL_KRETPROBE:
781 (*events)[i].type = LTTNG_EVENT_FUNCTION;
782 memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
783 sizeof(struct lttng_kernel_kprobe));
784 break;
785 case LTTNG_KERNEL_KPROBE:
786 (*events)[i].type = LTTNG_EVENT_PROBE;
787 memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
788 sizeof(struct lttng_kernel_kprobe));
789 break;
790 case LTTNG_KERNEL_UPROBE:
791 (*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE;
792 break;
793 case LTTNG_KERNEL_FUNCTION:
794 (*events)[i].type = LTTNG_EVENT_FUNCTION;
795 memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
796 sizeof(struct lttng_kernel_function));
797 break;
798 case LTTNG_KERNEL_NOOP:
799 (*events)[i].type = LTTNG_EVENT_NOOP;
800 break;
801 case LTTNG_KERNEL_SYSCALL:
802 (*events)[i].type = LTTNG_EVENT_SYSCALL;
803 break;
804 case LTTNG_KERNEL_ALL:
805 /* fall-through. */
806 default:
807 assert(0);
808 break;
809 }
810 i++;
811
812 /* Append extended info */
813 ret = append_extended_info(event->filter_expression, NULL,
814 event->userspace_probe_location, &extended_at);
815 if (ret) {
816 DBG("Error appending extended info message");
817 ret = -LTTNG_ERR_FATAL;
818 goto error;
819 }
820 }
821
822 end:
823 return nb_event;
824
825 error:
826 return ret;
827 }
828
829 /*
830 * Add URI so the consumer output object. Set the correct path depending on the
831 * domain adding the default trace directory.
832 */
833 static enum lttng_error_code add_uri_to_consumer(
834 const struct ltt_session *session,
835 struct consumer_output *consumer,
836 struct lttng_uri *uri, enum lttng_domain_type domain)
837 {
838 int ret;
839 enum lttng_error_code ret_code = LTTNG_OK;
840
841 assert(uri);
842
843 if (consumer == NULL) {
844 DBG("No consumer detected. Don't add URI. Stopping.");
845 ret_code = LTTNG_ERR_NO_CONSUMER;
846 goto error;
847 }
848
849 switch (domain) {
850 case LTTNG_DOMAIN_KERNEL:
851 ret = lttng_strncpy(consumer->domain_subdir,
852 DEFAULT_KERNEL_TRACE_DIR,
853 sizeof(consumer->domain_subdir));
854 break;
855 case LTTNG_DOMAIN_UST:
856 ret = lttng_strncpy(consumer->domain_subdir,
857 DEFAULT_UST_TRACE_DIR,
858 sizeof(consumer->domain_subdir));
859 break;
860 default:
861 /*
862 * This case is possible is we try to add the URI to the global
863 * tracing session consumer object which in this case there is
864 * no subdir.
865 */
866 memset(consumer->domain_subdir, 0,
867 sizeof(consumer->domain_subdir));
868 ret = 0;
869 }
870 if (ret) {
871 ERR("Failed to initialize consumer output domain subdirectory");
872 ret_code = LTTNG_ERR_FATAL;
873 goto error;
874 }
875
876 switch (uri->dtype) {
877 case LTTNG_DST_IPV4:
878 case LTTNG_DST_IPV6:
879 DBG2("Setting network URI to consumer");
880
881 if (consumer->type == CONSUMER_DST_NET) {
882 if ((uri->stype == LTTNG_STREAM_CONTROL &&
883 consumer->dst.net.control_isset) ||
884 (uri->stype == LTTNG_STREAM_DATA &&
885 consumer->dst.net.data_isset)) {
886 ret_code = LTTNG_ERR_URL_EXIST;
887 goto error;
888 }
889 } else {
890 memset(&consumer->dst, 0, sizeof(consumer->dst));
891 }
892
893 /* Set URI into consumer output object */
894 ret = consumer_set_network_uri(session, consumer, uri);
895 if (ret < 0) {
896 ret_code = -ret;
897 goto error;
898 } else if (ret == 1) {
899 /*
900 * URI was the same in the consumer so we do not append the subdir
901 * again so to not duplicate output dir.
902 */
903 ret_code = LTTNG_OK;
904 goto error;
905 }
906 break;
907 case LTTNG_DST_PATH:
908 if (*uri->dst.path != '/' || strstr(uri->dst.path, "../")) {
909 ret_code = LTTNG_ERR_INVALID;
910 goto error;
911 }
912 DBG2("Setting trace directory path from URI to %s",
913 uri->dst.path);
914 memset(&consumer->dst, 0, sizeof(consumer->dst));
915
916 ret = lttng_strncpy(consumer->dst.session_root_path,
917 uri->dst.path,
918 sizeof(consumer->dst.session_root_path));
919 if (ret) {
920 ret_code = LTTNG_ERR_FATAL;
921 goto error;
922 }
923 consumer->type = CONSUMER_DST_LOCAL;
924 break;
925 }
926
927 ret_code = LTTNG_OK;
928 error:
929 return ret_code;
930 }
931
932 /*
933 * Init tracing by creating trace directory and sending fds kernel consumer.
934 */
935 static int init_kernel_tracing(struct ltt_kernel_session *session)
936 {
937 int ret = 0;
938 struct lttng_ht_iter iter;
939 struct consumer_socket *socket;
940
941 assert(session);
942
943 rcu_read_lock();
944
945 if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
946 cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
947 socket, node.node) {
948 pthread_mutex_lock(socket->lock);
949 ret = kernel_consumer_send_session(socket, session);
950 pthread_mutex_unlock(socket->lock);
951 if (ret < 0) {
952 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
953 goto error;
954 }
955 }
956 }
957
958 error:
959 rcu_read_unlock();
960 return ret;
961 }
962
963 /*
964 * Create a socket to the relayd using the URI.
965 *
966 * On success, the relayd_sock pointer is set to the created socket.
967 * Else, it remains untouched and an LTTng error code is returned.
968 */
969 static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
970 struct lttcomm_relayd_sock **relayd_sock,
971 struct consumer_output *consumer)
972 {
973 int ret;
974 enum lttng_error_code status = LTTNG_OK;
975 struct lttcomm_relayd_sock *rsock;
976
977 rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
978 RELAYD_VERSION_COMM_MINOR);
979 if (!rsock) {
980 status = LTTNG_ERR_FATAL;
981 goto error;
982 }
983
984 /*
985 * Connect to relayd so we can proceed with a session creation. This call
986 * can possibly block for an arbitrary amount of time to set the health
987 * state to be in poll execution.
988 */
989 health_poll_entry();
990 ret = relayd_connect(rsock);
991 health_poll_exit();
992 if (ret < 0) {
993 ERR("Unable to reach lttng-relayd");
994 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
995 goto free_sock;
996 }
997
998 /* Create socket for control stream. */
999 if (uri->stype == LTTNG_STREAM_CONTROL) {
1000 DBG3("Creating relayd stream socket from URI");
1001
1002 /* Check relayd version */
1003 ret = relayd_version_check(rsock);
1004 if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) {
1005 status = LTTNG_ERR_RELAYD_VERSION_FAIL;
1006 goto close_sock;
1007 } else if (ret < 0) {
1008 ERR("Unable to reach lttng-relayd");
1009 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
1010 goto close_sock;
1011 }
1012 consumer->relay_major_version = rsock->major;
1013 consumer->relay_minor_version = rsock->minor;
1014 } else if (uri->stype == LTTNG_STREAM_DATA) {
1015 DBG3("Creating relayd data socket from URI");
1016 } else {
1017 /* Command is not valid */
1018 ERR("Relayd invalid stream type: %d", uri->stype);
1019 status = LTTNG_ERR_INVALID;
1020 goto close_sock;
1021 }
1022
1023 *relayd_sock = rsock;
1024
1025 return status;
1026
1027 close_sock:
1028 /* The returned value is not useful since we are on an error path. */
1029 (void) relayd_close(rsock);
1030 free_sock:
1031 free(rsock);
1032 error:
1033 return status;
1034 }
1035
1036 /*
1037 * Connect to the relayd using URI and send the socket to the right consumer.
1038 *
1039 * The consumer socket lock must be held by the caller.
1040 *
1041 * Returns LTTNG_OK on success or an LTTng error code on failure.
1042 */
1043 static enum lttng_error_code send_consumer_relayd_socket(
1044 unsigned int session_id,
1045 struct lttng_uri *relayd_uri,
1046 struct consumer_output *consumer,
1047 struct consumer_socket *consumer_sock,
1048 const char *session_name, const char *hostname,
1049 const char *base_path, int session_live_timer,
1050 const uint64_t *current_chunk_id,
1051 time_t session_creation_time,
1052 bool session_name_contains_creation_time)
1053 {
1054 int ret;
1055 struct lttcomm_relayd_sock *rsock = NULL;
1056 enum lttng_error_code status;
1057
1058 /* Connect to relayd and make version check if uri is the control. */
1059 status = create_connect_relayd(relayd_uri, &rsock, consumer);
1060 if (status != LTTNG_OK) {
1061 goto relayd_comm_error;
1062 }
1063 assert(rsock);
1064
1065 /* Set the network sequence index if not set. */
1066 if (consumer->net_seq_index == (uint64_t) -1ULL) {
1067 pthread_mutex_lock(&relayd_net_seq_idx_lock);
1068 /*
1069 * Increment net_seq_idx because we are about to transfer the
1070 * new relayd socket to the consumer.
1071 * Assign unique key so the consumer can match streams.
1072 */
1073 consumer->net_seq_index = ++relayd_net_seq_idx;
1074 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
1075 }
1076
1077 /* Send relayd socket to consumer. */
1078 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
1079 relayd_uri->stype, session_id,
1080 session_name, hostname, base_path,
1081 session_live_timer, current_chunk_id,
1082 session_creation_time, session_name_contains_creation_time);
1083 if (ret < 0) {
1084 status = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
1085 goto close_sock;
1086 }
1087
1088 /* Flag that the corresponding socket was sent. */
1089 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
1090 consumer_sock->control_sock_sent = 1;
1091 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
1092 consumer_sock->data_sock_sent = 1;
1093 }
1094
1095 /*
1096 * Close socket which was dup on the consumer side. The session daemon does
1097 * NOT keep track of the relayd socket(s) once transfer to the consumer.
1098 */
1099
1100 close_sock:
1101 if (status != LTTNG_OK) {
1102 /*
1103 * The consumer output for this session should not be used anymore
1104 * since the relayd connection failed thus making any tracing or/and
1105 * streaming not usable.
1106 */
1107 consumer->enabled = 0;
1108 }
1109 (void) relayd_close(rsock);
1110 free(rsock);
1111
1112 relayd_comm_error:
1113 return status;
1114 }
1115
1116 /*
1117 * Send both relayd sockets to a specific consumer and domain. This is a
1118 * helper function to facilitate sending the information to the consumer for a
1119 * session.
1120 *
1121 * The consumer socket lock must be held by the caller.
1122 *
1123 * Returns LTTNG_OK, or an LTTng error code on failure.
1124 */
1125 static enum lttng_error_code send_consumer_relayd_sockets(
1126 enum lttng_domain_type domain,
1127 unsigned int session_id, struct consumer_output *consumer,
1128 struct consumer_socket *sock, const char *session_name,
1129 const char *hostname, const char *base_path, int session_live_timer,
1130 const uint64_t *current_chunk_id, time_t session_creation_time,
1131 bool session_name_contains_creation_time)
1132 {
1133 enum lttng_error_code status = LTTNG_OK;
1134
1135 assert(consumer);
1136 assert(sock);
1137
1138 /* Sending control relayd socket. */
1139 if (!sock->control_sock_sent) {
1140 status = send_consumer_relayd_socket(session_id,
1141 &consumer->dst.net.control, consumer, sock,
1142 session_name, hostname, base_path, session_live_timer,
1143 current_chunk_id, session_creation_time,
1144 session_name_contains_creation_time);
1145 if (status != LTTNG_OK) {
1146 goto error;
1147 }
1148 }
1149
1150 /* Sending data relayd socket. */
1151 if (!sock->data_sock_sent) {
1152 status = send_consumer_relayd_socket(session_id,
1153 &consumer->dst.net.data, consumer, sock,
1154 session_name, hostname, base_path, session_live_timer,
1155 current_chunk_id, session_creation_time,
1156 session_name_contains_creation_time);
1157 if (status != LTTNG_OK) {
1158 goto error;
1159 }
1160 }
1161
1162 error:
1163 return status;
1164 }
1165
1166 /*
1167 * Setup relayd connections for a tracing session. First creates the socket to
1168 * the relayd and send them to the right domain consumer. Consumer type MUST be
1169 * network.
1170 */
1171 int cmd_setup_relayd(struct ltt_session *session)
1172 {
1173 int ret = LTTNG_OK;
1174 struct ltt_ust_session *usess;
1175 struct ltt_kernel_session *ksess;
1176 struct consumer_socket *socket;
1177 struct lttng_ht_iter iter;
1178 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
1179
1180 assert(session);
1181
1182 usess = session->ust_session;
1183 ksess = session->kernel_session;
1184
1185 DBG("Setting relayd for session %s", session->name);
1186
1187 rcu_read_lock();
1188 if (session->current_trace_chunk) {
1189 enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
1190 session->current_trace_chunk, &current_chunk_id.value);
1191
1192 if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
1193 current_chunk_id.is_set = true;
1194 } else {
1195 ERR("Failed to get current trace chunk id");
1196 ret = LTTNG_ERR_UNK;
1197 goto error;
1198 }
1199 }
1200
1201 if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
1202 && usess->consumer->enabled) {
1203 /* For each consumer socket, send relayd sockets */
1204 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
1205 socket, node.node) {
1206 pthread_mutex_lock(socket->lock);
1207 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
1208 usess->consumer, socket,
1209 session->name, session->hostname,
1210 session->base_path,
1211 session->live_timer,
1212 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
1213 session->creation_time,
1214 session->name_contains_creation_time);
1215 pthread_mutex_unlock(socket->lock);
1216 if (ret != LTTNG_OK) {
1217 goto error;
1218 }
1219 /* Session is now ready for network streaming. */
1220 session->net_handle = 1;
1221 }
1222 session->consumer->relay_major_version =
1223 usess->consumer->relay_major_version;
1224 session->consumer->relay_minor_version =
1225 usess->consumer->relay_minor_version;
1226 }
1227
1228 if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
1229 && ksess->consumer->enabled) {
1230 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1231 socket, node.node) {
1232 pthread_mutex_lock(socket->lock);
1233 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
1234 ksess->consumer, socket,
1235 session->name, session->hostname,
1236 session->base_path,
1237 session->live_timer,
1238 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
1239 session->creation_time,
1240 session->name_contains_creation_time);
1241 pthread_mutex_unlock(socket->lock);
1242 if (ret != LTTNG_OK) {
1243 goto error;
1244 }
1245 /* Session is now ready for network streaming. */
1246 session->net_handle = 1;
1247 }
1248 session->consumer->relay_major_version =
1249 ksess->consumer->relay_major_version;
1250 session->consumer->relay_minor_version =
1251 ksess->consumer->relay_minor_version;
1252 }
1253
1254 error:
1255 rcu_read_unlock();
1256 return ret;
1257 }
1258
1259 /*
1260 * Start a kernel session by opening all necessary streams.
1261 */
1262 static int start_kernel_session(struct ltt_kernel_session *ksess)
1263 {
1264 int ret;
1265 struct ltt_kernel_channel *kchan;
1266
1267 /* Open kernel metadata */
1268 if (ksess->metadata == NULL && ksess->output_traces) {
1269 ret = kernel_open_metadata(ksess);
1270 if (ret < 0) {
1271 ret = LTTNG_ERR_KERN_META_FAIL;
1272 goto error;
1273 }
1274 }
1275
1276 /* Open kernel metadata stream */
1277 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
1278 ret = kernel_open_metadata_stream(ksess);
1279 if (ret < 0) {
1280 ERR("Kernel create metadata stream failed");
1281 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1282 goto error;
1283 }
1284 }
1285
1286 /* For each channel */
1287 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1288 if (kchan->stream_count == 0) {
1289 ret = kernel_open_channel_stream(kchan);
1290 if (ret < 0) {
1291 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1292 goto error;
1293 }
1294 /* Update the stream global counter */
1295 ksess->stream_count_global += ret;
1296 }
1297 }
1298
1299 /* Setup kernel consumer socket and send fds to it */
1300 ret = init_kernel_tracing(ksess);
1301 if (ret != 0) {
1302 ret = LTTNG_ERR_KERN_START_FAIL;
1303 goto error;
1304 }
1305
1306 /* This start the kernel tracing */
1307 ret = kernel_start_session(ksess);
1308 if (ret < 0) {
1309 ret = LTTNG_ERR_KERN_START_FAIL;
1310 goto error;
1311 }
1312
1313 /* Quiescent wait after starting trace */
1314 kernel_wait_quiescent();
1315
1316 ksess->active = 1;
1317
1318 ret = LTTNG_OK;
1319
1320 error:
1321 return ret;
1322 }
1323
1324 /*
1325 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1326 */
1327 int cmd_disable_channel(struct ltt_session *session,
1328 enum lttng_domain_type domain, char *channel_name)
1329 {
1330 int ret;
1331 struct ltt_ust_session *usess;
1332
1333 usess = session->ust_session;
1334
1335 rcu_read_lock();
1336
1337 switch (domain) {
1338 case LTTNG_DOMAIN_KERNEL:
1339 {
1340 ret = channel_kernel_disable(session->kernel_session,
1341 channel_name);
1342 if (ret != LTTNG_OK) {
1343 goto error;
1344 }
1345
1346 kernel_wait_quiescent();
1347 break;
1348 }
1349 case LTTNG_DOMAIN_UST:
1350 {
1351 struct ltt_ust_channel *uchan;
1352 struct lttng_ht *chan_ht;
1353
1354 chan_ht = usess->domain_global.channels;
1355
1356 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
1357 if (uchan == NULL) {
1358 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1359 goto error;
1360 }
1361
1362 ret = channel_ust_disable(usess, uchan);
1363 if (ret != LTTNG_OK) {
1364 goto error;
1365 }
1366 break;
1367 }
1368 default:
1369 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1370 goto error;
1371 }
1372
1373 ret = LTTNG_OK;
1374
1375 error:
1376 rcu_read_unlock();
1377 return ret;
1378 }
1379
1380 /*
1381 * Command LTTNG_TRACK_PID processed by the client thread.
1382 *
1383 * Called with session lock held.
1384 */
1385 int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
1386 int pid)
1387 {
1388 int ret;
1389
1390 rcu_read_lock();
1391
1392 switch (domain) {
1393 case LTTNG_DOMAIN_KERNEL:
1394 {
1395 struct ltt_kernel_session *ksess;
1396
1397 ksess = session->kernel_session;
1398
1399 ret = kernel_track_pid(ksess, pid);
1400 if (ret != LTTNG_OK) {
1401 goto error;
1402 }
1403
1404 kernel_wait_quiescent();
1405 break;
1406 }
1407 case LTTNG_DOMAIN_UST:
1408 {
1409 struct ltt_ust_session *usess;
1410
1411 usess = session->ust_session;
1412
1413 ret = trace_ust_track_pid(usess, pid);
1414 if (ret != LTTNG_OK) {
1415 goto error;
1416 }
1417 break;
1418 }
1419 default:
1420 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1421 goto error;
1422 }
1423
1424 ret = LTTNG_OK;
1425
1426 error:
1427 rcu_read_unlock();
1428 return ret;
1429 }
1430
1431 /*
1432 * Command LTTNG_UNTRACK_PID processed by the client thread.
1433 *
1434 * Called with session lock held.
1435 */
1436 int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
1437 int pid)
1438 {
1439 int ret;
1440
1441 rcu_read_lock();
1442
1443 switch (domain) {
1444 case LTTNG_DOMAIN_KERNEL:
1445 {
1446 struct ltt_kernel_session *ksess;
1447
1448 ksess = session->kernel_session;
1449
1450 ret = kernel_untrack_pid(ksess, pid);
1451 if (ret != LTTNG_OK) {
1452 goto error;
1453 }
1454
1455 kernel_wait_quiescent();
1456 break;
1457 }
1458 case LTTNG_DOMAIN_UST:
1459 {
1460 struct ltt_ust_session *usess;
1461
1462 usess = session->ust_session;
1463
1464 ret = trace_ust_untrack_pid(usess, pid);
1465 if (ret != LTTNG_OK) {
1466 goto error;
1467 }
1468 break;
1469 }
1470 default:
1471 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1472 goto error;
1473 }
1474
1475 ret = LTTNG_OK;
1476
1477 error:
1478 rcu_read_unlock();
1479 return ret;
1480 }
1481
1482 /*
1483 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1484 *
1485 * The wpipe arguments is used as a notifier for the kernel thread.
1486 */
1487 int cmd_enable_channel(struct ltt_session *session,
1488 const struct lttng_domain *domain, const struct lttng_channel *_attr, int wpipe)
1489 {
1490 int ret;
1491 struct ltt_ust_session *usess = session->ust_session;
1492 struct lttng_ht *chan_ht;
1493 size_t len;
1494 struct lttng_channel attr;
1495
1496 assert(session);
1497 assert(_attr);
1498 assert(domain);
1499
1500 attr = *_attr;
1501 len = lttng_strnlen(attr.name, sizeof(attr.name));
1502
1503 /* Validate channel name */
1504 if (attr.name[0] == '.' ||
1505 memchr(attr.name, '/', len) != NULL) {
1506 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1507 goto end;
1508 }
1509
1510 DBG("Enabling channel %s for session %s", attr.name, session->name);
1511
1512 rcu_read_lock();
1513
1514 /*
1515 * Don't try to enable a channel if the session has been started at
1516 * some point in time before. The tracer does not allow it.
1517 */
1518 if (session->has_been_started) {
1519 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1520 goto error;
1521 }
1522
1523 /*
1524 * If the session is a live session, remove the switch timer, the
1525 * live timer does the same thing but sends also synchronisation
1526 * beacons for inactive streams.
1527 */
1528 if (session->live_timer > 0) {
1529 attr.attr.live_timer_interval = session->live_timer;
1530 attr.attr.switch_timer_interval = 0;
1531 }
1532
1533 /* Check for feature support */
1534 switch (domain->type) {
1535 case LTTNG_DOMAIN_KERNEL:
1536 {
1537 if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) {
1538 /* Sampling position of buffer is not supported */
1539 WARN("Kernel tracer does not support buffer monitoring. "
1540 "Setting the monitor interval timer to 0 "
1541 "(disabled) for channel '%s' of session '%s'",
1542 attr.name, session->name);
1543 lttng_channel_set_monitor_timer_interval(&attr, 0);
1544 }
1545 break;
1546 }
1547 case LTTNG_DOMAIN_UST:
1548 break;
1549 case LTTNG_DOMAIN_JUL:
1550 case LTTNG_DOMAIN_LOG4J:
1551 case LTTNG_DOMAIN_PYTHON:
1552 if (!agent_tracing_is_enabled()) {
1553 DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
1554 ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
1555 goto error;
1556 }
1557 break;
1558 default:
1559 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1560 goto error;
1561 }
1562
1563 switch (domain->type) {
1564 case LTTNG_DOMAIN_KERNEL:
1565 {
1566 struct ltt_kernel_channel *kchan;
1567
1568 kchan = trace_kernel_get_channel_by_name(attr.name,
1569 session->kernel_session);
1570 if (kchan == NULL) {
1571 if (session->snapshot.nb_output > 0 ||
1572 session->snapshot_mode) {
1573 /* Enforce mmap output for snapshot sessions. */
1574 attr.attr.output = LTTNG_EVENT_MMAP;
1575 }
1576 ret = channel_kernel_create(session->kernel_session, &attr, wpipe);
1577 if (attr.name[0] != '\0') {
1578 session->kernel_session->has_non_default_channel = 1;
1579 }
1580 } else {
1581 ret = channel_kernel_enable(session->kernel_session, kchan);
1582 }
1583
1584 if (ret != LTTNG_OK) {
1585 goto error;
1586 }
1587
1588 kernel_wait_quiescent();
1589 break;
1590 }
1591 case LTTNG_DOMAIN_UST:
1592 case LTTNG_DOMAIN_JUL:
1593 case LTTNG_DOMAIN_LOG4J:
1594 case LTTNG_DOMAIN_PYTHON:
1595 {
1596 struct ltt_ust_channel *uchan;
1597
1598 /*
1599 * FIXME
1600 *
1601 * Current agent implementation limitations force us to allow
1602 * only one channel at once in "agent" subdomains. Each
1603 * subdomain has a default channel name which must be strictly
1604 * adhered to.
1605 */
1606 if (domain->type == LTTNG_DOMAIN_JUL) {
1607 if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME,
1608 LTTNG_SYMBOL_NAME_LEN)) {
1609 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1610 goto error;
1611 }
1612 } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
1613 if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME,
1614 LTTNG_SYMBOL_NAME_LEN)) {
1615 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1616 goto error;
1617 }
1618 } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
1619 if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME,
1620 LTTNG_SYMBOL_NAME_LEN)) {
1621 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1622 goto error;
1623 }
1624 }
1625
1626 chan_ht = usess->domain_global.channels;
1627
1628 uchan = trace_ust_find_channel_by_name(chan_ht, attr.name);
1629 if (uchan == NULL) {
1630 ret = channel_ust_create(usess, &attr, domain->buf_type);
1631 if (attr.name[0] != '\0') {
1632 usess->has_non_default_channel = 1;
1633 }
1634 } else {
1635 ret = channel_ust_enable(usess, uchan);
1636 }
1637 break;
1638 }
1639 default:
1640 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1641 goto error;
1642 }
1643
1644 if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) {
1645 session->has_non_mmap_channel = true;
1646 }
1647 error:
1648 rcu_read_unlock();
1649 end:
1650 return ret;
1651 }
1652
1653 /*
1654 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1655 */
1656 int cmd_disable_event(struct ltt_session *session,
1657 enum lttng_domain_type domain, const char *channel_name,
1658 const struct lttng_event *event)
1659 {
1660 int ret;
1661 const char *event_name;
1662
1663 DBG("Disable event command for event \'%s\'", event->name);
1664
1665 event_name = event->name;
1666
1667 /* Error out on unhandled search criteria */
1668 if (event->loglevel_type || event->loglevel != -1 || event->enabled
1669 || event->pid || event->filter || event->exclusion) {
1670 ret = LTTNG_ERR_UNK;
1671 goto error;
1672 }
1673
1674 rcu_read_lock();
1675
1676 switch (domain) {
1677 case LTTNG_DOMAIN_KERNEL:
1678 {
1679 struct ltt_kernel_channel *kchan;
1680 struct ltt_kernel_session *ksess;
1681
1682 ksess = session->kernel_session;
1683
1684 /*
1685 * If a non-default channel has been created in the
1686 * session, explicitely require that -c chan_name needs
1687 * to be provided.
1688 */
1689 if (ksess->has_non_default_channel && channel_name[0] == '\0') {
1690 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1691 goto error_unlock;
1692 }
1693
1694 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1695 if (kchan == NULL) {
1696 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
1697 goto error_unlock;
1698 }
1699
1700 switch (event->type) {
1701 case LTTNG_EVENT_ALL:
1702 case LTTNG_EVENT_TRACEPOINT:
1703 case LTTNG_EVENT_SYSCALL:
1704 case LTTNG_EVENT_PROBE:
1705 case LTTNG_EVENT_FUNCTION:
1706 case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
1707 if (event_name[0] == '\0') {
1708 ret = event_kernel_disable_event(kchan,
1709 NULL, event->type);
1710 } else {
1711 ret = event_kernel_disable_event(kchan,
1712 event_name, event->type);
1713 }
1714 if (ret != LTTNG_OK) {
1715 goto error_unlock;
1716 }
1717 break;
1718 default:
1719 ret = LTTNG_ERR_UNK;
1720 goto error_unlock;
1721 }
1722
1723 kernel_wait_quiescent();
1724 break;
1725 }
1726 case LTTNG_DOMAIN_UST:
1727 {
1728 struct ltt_ust_channel *uchan;
1729 struct ltt_ust_session *usess;
1730
1731 usess = session->ust_session;
1732
1733 if (validate_ust_event_name(event_name)) {
1734 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1735 goto error_unlock;
1736 }
1737
1738 /*
1739 * If a non-default channel has been created in the
1740 * session, explicitly require that -c chan_name needs
1741 * to be provided.
1742 */
1743 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1744 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1745 goto error_unlock;
1746 }
1747
1748 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1749 channel_name);
1750 if (uchan == NULL) {
1751 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1752 goto error_unlock;
1753 }
1754
1755 switch (event->type) {
1756 case LTTNG_EVENT_ALL:
1757 /*
1758 * An empty event name means that everything
1759 * should be disabled.
1760 */
1761 if (event->name[0] == '\0') {
1762 ret = event_ust_disable_all_tracepoints(usess, uchan);
1763 } else {
1764 ret = event_ust_disable_tracepoint(usess, uchan,
1765 event_name);
1766 }
1767 if (ret != LTTNG_OK) {
1768 goto error_unlock;
1769 }
1770 break;
1771 default:
1772 ret = LTTNG_ERR_UNK;
1773 goto error_unlock;
1774 }
1775
1776 DBG3("Disable UST event %s in channel %s completed", event_name,
1777 channel_name);
1778 break;
1779 }
1780 case LTTNG_DOMAIN_LOG4J:
1781 case LTTNG_DOMAIN_JUL:
1782 case LTTNG_DOMAIN_PYTHON:
1783 {
1784 struct agent *agt;
1785 struct ltt_ust_session *usess = session->ust_session;
1786
1787 assert(usess);
1788
1789 switch (event->type) {
1790 case LTTNG_EVENT_ALL:
1791 break;
1792 default:
1793 ret = LTTNG_ERR_UNK;
1794 goto error_unlock;
1795 }
1796
1797 agt = trace_ust_find_agent(usess, domain);
1798 if (!agt) {
1799 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
1800 goto error_unlock;
1801 }
1802 /*
1803 * An empty event name means that everything
1804 * should be disabled.
1805 */
1806 if (event->name[0] == '\0') {
1807 ret = event_agent_disable_all(usess, agt);
1808 } else {
1809 ret = event_agent_disable(usess, agt, event_name);
1810 }
1811 if (ret != LTTNG_OK) {
1812 goto error_unlock;
1813 }
1814
1815 break;
1816 }
1817 default:
1818 ret = LTTNG_ERR_UND;
1819 goto error_unlock;
1820 }
1821
1822 ret = LTTNG_OK;
1823
1824 error_unlock:
1825 rcu_read_unlock();
1826 error:
1827 return ret;
1828 }
1829
1830 /*
1831 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1832 */
1833 int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
1834 char *channel_name, const struct lttng_event_context *ctx, int kwpipe)
1835 {
1836 int ret, chan_kern_created = 0, chan_ust_created = 0;
1837 char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
1838
1839 /*
1840 * Don't try to add a context if the session has been started at
1841 * some point in time before. The tracer does not allow it and would
1842 * result in a corrupted trace.
1843 */
1844 if (session->has_been_started) {
1845 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1846 goto end;
1847 }
1848
1849 if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
1850 app_ctx_provider_name = ctx->u.app_ctx.provider_name;
1851 app_ctx_name = ctx->u.app_ctx.ctx_name;
1852 }
1853
1854 switch (domain) {
1855 case LTTNG_DOMAIN_KERNEL:
1856 assert(session->kernel_session);
1857
1858 if (session->kernel_session->channel_count == 0) {
1859 /* Create default channel */
1860 ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
1861 if (ret != LTTNG_OK) {
1862 goto error;
1863 }
1864 chan_kern_created = 1;
1865 }
1866 /* Add kernel context to kernel tracer */
1867 ret = context_kernel_add(session->kernel_session, ctx, channel_name);
1868 if (ret != LTTNG_OK) {
1869 goto error;
1870 }
1871 break;
1872 case LTTNG_DOMAIN_JUL:
1873 case LTTNG_DOMAIN_LOG4J:
1874 {
1875 /*
1876 * Validate channel name.
1877 * If no channel name is given and the domain is JUL or LOG4J,
1878 * set it to the appropriate domain-specific channel name. If
1879 * a name is provided but does not match the expexted channel
1880 * name, return an error.
1881 */
1882 if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
1883 strcmp(channel_name,
1884 DEFAULT_JUL_CHANNEL_NAME)) {
1885 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1886 goto error;
1887 } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
1888 strcmp(channel_name,
1889 DEFAULT_LOG4J_CHANNEL_NAME)) {
1890 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1891 goto error;
1892 }
1893 /* break is _not_ missing here. */
1894 }
1895 case LTTNG_DOMAIN_UST:
1896 {
1897 struct ltt_ust_session *usess = session->ust_session;
1898 unsigned int chan_count;
1899
1900 assert(usess);
1901
1902 chan_count = lttng_ht_get_count(usess->domain_global.channels);
1903 if (chan_count == 0) {
1904 struct lttng_channel *attr;
1905 /* Create default channel */
1906 attr = channel_new_default_attr(domain, usess->buffer_type);
1907 if (attr == NULL) {
1908 ret = LTTNG_ERR_FATAL;
1909 goto error;
1910 }
1911
1912 ret = channel_ust_create(usess, attr, usess->buffer_type);
1913 if (ret != LTTNG_OK) {
1914 free(attr);
1915 goto error;
1916 }
1917 channel_attr_destroy(attr);
1918 chan_ust_created = 1;
1919 }
1920
1921 ret = context_ust_add(usess, domain, ctx, channel_name);
1922 free(app_ctx_provider_name);
1923 free(app_ctx_name);
1924 app_ctx_name = NULL;
1925 app_ctx_provider_name = NULL;
1926 if (ret != LTTNG_OK) {
1927 goto error;
1928 }
1929 break;
1930 }
1931 default:
1932 ret = LTTNG_ERR_UND;
1933 goto error;
1934 }
1935
1936 ret = LTTNG_OK;
1937 goto end;
1938
1939 error:
1940 if (chan_kern_created) {
1941 struct ltt_kernel_channel *kchan =
1942 trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
1943 session->kernel_session);
1944 /* Created previously, this should NOT fail. */
1945 assert(kchan);
1946 kernel_destroy_channel(kchan);
1947 }
1948
1949 if (chan_ust_created) {
1950 struct ltt_ust_channel *uchan =
1951 trace_ust_find_channel_by_name(
1952 session->ust_session->domain_global.channels,
1953 DEFAULT_CHANNEL_NAME);
1954 /* Created previously, this should NOT fail. */
1955 assert(uchan);
1956 /* Remove from the channel list of the session. */
1957 trace_ust_delete_channel(session->ust_session->domain_global.channels,
1958 uchan);
1959 trace_ust_destroy_channel(uchan);
1960 }
1961 end:
1962 free(app_ctx_provider_name);
1963 free(app_ctx_name);
1964 return ret;
1965 }
1966
1967 static inline bool name_starts_with(const char *name, const char *prefix)
1968 {
1969 const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
1970
1971 return !strncmp(name, prefix, max_cmp_len);
1972 }
1973
1974 /* Perform userspace-specific event name validation */
1975 static int validate_ust_event_name(const char *name)
1976 {
1977 int ret = 0;
1978
1979 if (!name) {
1980 ret = -1;
1981 goto end;
1982 }
1983
1984 /*
1985 * Check name against all internal UST event component namespaces used
1986 * by the agents.
1987 */
1988 if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
1989 name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
1990 name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
1991 ret = -1;
1992 }
1993
1994 end:
1995 return ret;
1996 }
1997
1998 /*
1999 * Internal version of cmd_enable_event() with a supplemental
2000 * "internal_event" flag which is used to enable internal events which should
2001 * be hidden from clients. Such events are used in the agent implementation to
2002 * enable the events through which all "agent" events are funeled.
2003 */
2004 static int _cmd_enable_event(struct ltt_session *session,
2005 const struct lttng_domain *domain,
2006 char *channel_name, struct lttng_event *event,
2007 char *filter_expression,
2008 struct lttng_filter_bytecode *filter,
2009 struct lttng_event_exclusion *exclusion,
2010 int wpipe, bool internal_event)
2011 {
2012 int ret = 0, channel_created = 0;
2013 struct lttng_channel *attr = NULL;
2014
2015 assert(session);
2016 assert(event);
2017 assert(channel_name);
2018
2019 /* If we have a filter, we must have its filter expression */
2020 assert(!(!!filter_expression ^ !!filter));
2021
2022 /* Normalize event name as a globbing pattern */
2023 strutils_normalize_star_glob_pattern(event->name);
2024
2025 /* Normalize exclusion names as globbing patterns */
2026 if (exclusion) {
2027 size_t i;
2028
2029 for (i = 0; i < exclusion->count; i++) {
2030 char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i);
2031
2032 strutils_normalize_star_glob_pattern(name);
2033 }
2034 }
2035
2036 DBG("Enable event command for event \'%s\'", event->name);
2037
2038 rcu_read_lock();
2039
2040 switch (domain->type) {
2041 case LTTNG_DOMAIN_KERNEL:
2042 {
2043 struct ltt_kernel_channel *kchan;
2044
2045 /*
2046 * If a non-default channel has been created in the
2047 * session, explicitely require that -c chan_name needs
2048 * to be provided.
2049 */
2050 if (session->kernel_session->has_non_default_channel
2051 && channel_name[0] == '\0') {
2052 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2053 goto error;
2054 }
2055
2056 kchan = trace_kernel_get_channel_by_name(channel_name,
2057 session->kernel_session);
2058 if (kchan == NULL) {
2059 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
2060 LTTNG_BUFFER_GLOBAL);
2061 if (attr == NULL) {
2062 ret = LTTNG_ERR_FATAL;
2063 goto error;
2064 }
2065 if (lttng_strncpy(attr->name, channel_name,
2066 sizeof(attr->name))) {
2067 ret = LTTNG_ERR_INVALID;
2068 goto error;
2069 }
2070
2071 ret = cmd_enable_channel(session, domain, attr, wpipe);
2072 if (ret != LTTNG_OK) {
2073 goto error;
2074 }
2075 channel_created = 1;
2076 }
2077
2078 /* Get the newly created kernel channel pointer */
2079 kchan = trace_kernel_get_channel_by_name(channel_name,
2080 session->kernel_session);
2081 if (kchan == NULL) {
2082 /* This sould not happen... */
2083 ret = LTTNG_ERR_FATAL;
2084 goto error;
2085 }
2086
2087 switch (event->type) {
2088 case LTTNG_EVENT_ALL:
2089 {
2090 char *filter_expression_a = NULL;
2091 struct lttng_filter_bytecode *filter_a = NULL;
2092
2093 /*
2094 * We need to duplicate filter_expression and filter,
2095 * because ownership is passed to first enable
2096 * event.
2097 */
2098 if (filter_expression) {
2099 filter_expression_a = strdup(filter_expression);
2100 if (!filter_expression_a) {
2101 ret = LTTNG_ERR_FATAL;
2102 goto error;
2103 }
2104 }
2105 if (filter) {
2106 filter_a = zmalloc(sizeof(*filter_a) + filter->len);
2107 if (!filter_a) {
2108 free(filter_expression_a);
2109 ret = LTTNG_ERR_FATAL;
2110 goto error;
2111 }
2112 memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
2113 }
2114 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
2115 ret = event_kernel_enable_event(kchan, event,
2116 filter_expression, filter);
2117 /* We have passed ownership */
2118 filter_expression = NULL;
2119 filter = NULL;
2120 if (ret != LTTNG_OK) {
2121 if (channel_created) {
2122 /* Let's not leak a useless channel. */
2123 kernel_destroy_channel(kchan);
2124 }
2125 free(filter_expression_a);
2126 free(filter_a);
2127 goto error;
2128 }
2129 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
2130 ret = event_kernel_enable_event(kchan, event,
2131 filter_expression_a, filter_a);
2132 /* We have passed ownership */
2133 filter_expression_a = NULL;
2134 filter_a = NULL;
2135 if (ret != LTTNG_OK) {
2136 goto error;
2137 }
2138 break;
2139 }
2140 case LTTNG_EVENT_PROBE:
2141 case LTTNG_EVENT_USERSPACE_PROBE:
2142 case LTTNG_EVENT_FUNCTION:
2143 case LTTNG_EVENT_FUNCTION_ENTRY:
2144 case LTTNG_EVENT_TRACEPOINT:
2145 ret = event_kernel_enable_event(kchan, event,
2146 filter_expression, filter);
2147 /* We have passed ownership */
2148 filter_expression = NULL;
2149 filter = NULL;
2150 if (ret != LTTNG_OK) {
2151 if (channel_created) {
2152 /* Let's not leak a useless channel. */
2153 kernel_destroy_channel(kchan);
2154 }
2155 goto error;
2156 }
2157 break;
2158 case LTTNG_EVENT_SYSCALL:
2159 ret = event_kernel_enable_event(kchan, event,
2160 filter_expression, filter);
2161 /* We have passed ownership */
2162 filter_expression = NULL;
2163 filter = NULL;
2164 if (ret != LTTNG_OK) {
2165 goto error;
2166 }
2167 break;
2168 default:
2169 ret = LTTNG_ERR_UNK;
2170 goto error;
2171 }
2172
2173 kernel_wait_quiescent();
2174 break;
2175 }
2176 case LTTNG_DOMAIN_UST:
2177 {
2178 struct ltt_ust_channel *uchan;
2179 struct ltt_ust_session *usess = session->ust_session;
2180
2181 assert(usess);
2182
2183 /*
2184 * If a non-default channel has been created in the
2185 * session, explicitely require that -c chan_name needs
2186 * to be provided.
2187 */
2188 if (usess->has_non_default_channel && channel_name[0] == '\0') {
2189 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2190 goto error;
2191 }
2192
2193 /* Get channel from global UST domain */
2194 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2195 channel_name);
2196 if (uchan == NULL) {
2197 /* Create default channel */
2198 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2199 usess->buffer_type);
2200 if (attr == NULL) {
2201 ret = LTTNG_ERR_FATAL;
2202 goto error;
2203 }
2204 if (lttng_strncpy(attr->name, channel_name,
2205 sizeof(attr->name))) {
2206 ret = LTTNG_ERR_INVALID;
2207 goto error;
2208 }
2209
2210 ret = cmd_enable_channel(session, domain, attr, wpipe);
2211 if (ret != LTTNG_OK) {
2212 goto error;
2213 }
2214
2215 /* Get the newly created channel reference back */
2216 uchan = trace_ust_find_channel_by_name(
2217 usess->domain_global.channels, channel_name);
2218 assert(uchan);
2219 }
2220
2221 if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
2222 /*
2223 * Don't allow users to add UST events to channels which
2224 * are assigned to a userspace subdomain (JUL, Log4J,
2225 * Python, etc.).
2226 */
2227 ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
2228 goto error;
2229 }
2230
2231 if (!internal_event) {
2232 /*
2233 * Ensure the event name is not reserved for internal
2234 * use.
2235 */
2236 ret = validate_ust_event_name(event->name);
2237 if (ret) {
2238 WARN("Userspace event name %s failed validation.",
2239 event->name);
2240 ret = LTTNG_ERR_INVALID_EVENT_NAME;
2241 goto error;
2242 }
2243 }
2244
2245 /* At this point, the session and channel exist on the tracer */
2246 ret = event_ust_enable_tracepoint(usess, uchan, event,
2247 filter_expression, filter, exclusion,
2248 internal_event);
2249 /* We have passed ownership */
2250 filter_expression = NULL;
2251 filter = NULL;
2252 exclusion = NULL;
2253 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2254 goto already_enabled;
2255 } else if (ret != LTTNG_OK) {
2256 goto error;
2257 }
2258 break;
2259 }
2260 case LTTNG_DOMAIN_LOG4J:
2261 case LTTNG_DOMAIN_JUL:
2262 case LTTNG_DOMAIN_PYTHON:
2263 {
2264 const char *default_event_name, *default_chan_name;
2265 struct agent *agt;
2266 struct lttng_event uevent;
2267 struct lttng_domain tmp_dom;
2268 struct ltt_ust_session *usess = session->ust_session;
2269
2270 assert(usess);
2271
2272 if (!agent_tracing_is_enabled()) {
2273 DBG("Attempted to enable an event in an agent domain but the agent thread is not running");
2274 ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
2275 goto error;
2276 }
2277
2278 agt = trace_ust_find_agent(usess, domain->type);
2279 if (!agt) {
2280 agt = agent_create(domain->type);
2281 if (!agt) {
2282 ret = LTTNG_ERR_NOMEM;
2283 goto error;
2284 }
2285 agent_add(agt, usess->agents);
2286 }
2287
2288 /* Create the default tracepoint. */
2289 memset(&uevent, 0, sizeof(uevent));
2290 uevent.type = LTTNG_EVENT_TRACEPOINT;
2291 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
2292 default_event_name = event_get_default_agent_ust_name(
2293 domain->type);
2294 if (!default_event_name) {
2295 ret = LTTNG_ERR_FATAL;
2296 goto error;
2297 }
2298 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
2299 uevent.name[sizeof(uevent.name) - 1] = '\0';
2300
2301 /*
2302 * The domain type is changed because we are about to enable the
2303 * default channel and event for the JUL domain that are hardcoded.
2304 * This happens in the UST domain.
2305 */
2306 memcpy(&tmp_dom, domain, sizeof(tmp_dom));
2307 tmp_dom.type = LTTNG_DOMAIN_UST;
2308
2309 switch (domain->type) {
2310 case LTTNG_DOMAIN_LOG4J:
2311 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
2312 break;
2313 case LTTNG_DOMAIN_JUL:
2314 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
2315 break;
2316 case LTTNG_DOMAIN_PYTHON:
2317 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2318 break;
2319 default:
2320 /* The switch/case we are in makes this impossible */
2321 assert(0);
2322 }
2323
2324 {
2325 char *filter_expression_copy = NULL;
2326 struct lttng_filter_bytecode *filter_copy = NULL;
2327
2328 if (filter) {
2329 const size_t filter_size = sizeof(
2330 struct lttng_filter_bytecode)
2331 + filter->len;
2332
2333 filter_copy = zmalloc(filter_size);
2334 if (!filter_copy) {
2335 ret = LTTNG_ERR_NOMEM;
2336 goto error;
2337 }
2338 memcpy(filter_copy, filter, filter_size);
2339
2340 filter_expression_copy =
2341 strdup(filter_expression);
2342 if (!filter_expression) {
2343 ret = LTTNG_ERR_NOMEM;
2344 }
2345
2346 if (!filter_expression_copy || !filter_copy) {
2347 free(filter_expression_copy);
2348 free(filter_copy);
2349 goto error;
2350 }
2351 }
2352
2353 ret = cmd_enable_event_internal(session, &tmp_dom,
2354 (char *) default_chan_name,
2355 &uevent, filter_expression_copy,
2356 filter_copy, NULL, wpipe);
2357 }
2358
2359 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2360 goto already_enabled;
2361 } else if (ret != LTTNG_OK) {
2362 goto error;
2363 }
2364
2365 /* The wild card * means that everything should be enabled. */
2366 if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
2367 ret = event_agent_enable_all(usess, agt, event, filter,
2368 filter_expression);
2369 } else {
2370 ret = event_agent_enable(usess, agt, event, filter,
2371 filter_expression);
2372 }
2373 filter = NULL;
2374 filter_expression = NULL;
2375 if (ret != LTTNG_OK) {
2376 goto error;
2377 }
2378
2379 break;
2380 }
2381 default:
2382 ret = LTTNG_ERR_UND;
2383 goto error;
2384 }
2385
2386 ret = LTTNG_OK;
2387
2388 already_enabled:
2389 error:
2390 free(filter_expression);
2391 free(filter);
2392 free(exclusion);
2393 channel_attr_destroy(attr);
2394 rcu_read_unlock();
2395 return ret;
2396 }
2397
2398 /*
2399 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2400 * We own filter, exclusion, and filter_expression.
2401 */
2402 int cmd_enable_event(struct ltt_session *session,
2403 const struct lttng_domain *domain,
2404 char *channel_name, struct lttng_event *event,
2405 char *filter_expression,
2406 struct lttng_filter_bytecode *filter,
2407 struct lttng_event_exclusion *exclusion,
2408 int wpipe)
2409 {
2410 return _cmd_enable_event(session, domain, channel_name, event,
2411 filter_expression, filter, exclusion, wpipe, false);
2412 }
2413
2414 /*
2415 * Enable an event which is internal to LTTng. An internal should
2416 * never be made visible to clients and are immune to checks such as
2417 * reserved names.
2418 */
2419 static int cmd_enable_event_internal(struct ltt_session *session,
2420 const struct lttng_domain *domain,
2421 char *channel_name, struct lttng_event *event,
2422 char *filter_expression,
2423 struct lttng_filter_bytecode *filter,
2424 struct lttng_event_exclusion *exclusion,
2425 int wpipe)
2426 {
2427 return _cmd_enable_event(session, domain, channel_name, event,
2428 filter_expression, filter, exclusion, wpipe, true);
2429 }
2430
2431 /*
2432 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2433 */
2434 ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
2435 struct lttng_event **events)
2436 {
2437 int ret;
2438 ssize_t nb_events = 0;
2439
2440 switch (domain) {
2441 case LTTNG_DOMAIN_KERNEL:
2442 nb_events = kernel_list_events(events);
2443 if (nb_events < 0) {
2444 ret = LTTNG_ERR_KERN_LIST_FAIL;
2445 goto error;
2446 }
2447 break;
2448 case LTTNG_DOMAIN_UST:
2449 nb_events = ust_app_list_events(events);
2450 if (nb_events < 0) {
2451 ret = LTTNG_ERR_UST_LIST_FAIL;
2452 goto error;
2453 }
2454 break;
2455 case LTTNG_DOMAIN_LOG4J:
2456 case LTTNG_DOMAIN_JUL:
2457 case LTTNG_DOMAIN_PYTHON:
2458 nb_events = agent_list_events(events, domain);
2459 if (nb_events < 0) {
2460 ret = LTTNG_ERR_UST_LIST_FAIL;
2461 goto error;
2462 }
2463 break;
2464 default:
2465 ret = LTTNG_ERR_UND;
2466 goto error;
2467 }
2468
2469 return nb_events;
2470
2471 error:
2472 /* Return negative value to differentiate return code */
2473 return -ret;
2474 }
2475
2476 /*
2477 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2478 */
2479 ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2480 struct lttng_event_field **fields)
2481 {
2482 int ret;
2483 ssize_t nb_fields = 0;
2484
2485 switch (domain) {
2486 case LTTNG_DOMAIN_UST:
2487 nb_fields = ust_app_list_event_fields(fields);
2488 if (nb_fields < 0) {
2489 ret = LTTNG_ERR_UST_LIST_FAIL;
2490 goto error;
2491 }
2492 break;
2493 case LTTNG_DOMAIN_KERNEL:
2494 default: /* fall-through */
2495 ret = LTTNG_ERR_UND;
2496 goto error;
2497 }
2498
2499 return nb_fields;
2500
2501 error:
2502 /* Return negative value to differentiate return code */
2503 return -ret;
2504 }
2505
2506 ssize_t cmd_list_syscalls(struct lttng_event **events)
2507 {
2508 return syscall_table_list(events);
2509 }
2510
2511 /*
2512 * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
2513 *
2514 * Called with session lock held.
2515 */
2516 ssize_t cmd_list_tracker_pids(struct ltt_session *session,
2517 enum lttng_domain_type domain, int32_t **pids)
2518 {
2519 int ret;
2520 ssize_t nr_pids = 0;
2521
2522 switch (domain) {
2523 case LTTNG_DOMAIN_KERNEL:
2524 {
2525 struct ltt_kernel_session *ksess;
2526
2527 ksess = session->kernel_session;
2528 nr_pids = kernel_list_tracker_pids(ksess, pids);
2529 if (nr_pids < 0) {
2530 ret = LTTNG_ERR_KERN_LIST_FAIL;
2531 goto error;
2532 }
2533 break;
2534 }
2535 case LTTNG_DOMAIN_UST:
2536 {
2537 struct ltt_ust_session *usess;
2538
2539 usess = session->ust_session;
2540 nr_pids = trace_ust_list_tracker_pids(usess, pids);
2541 if (nr_pids < 0) {
2542 ret = LTTNG_ERR_UST_LIST_FAIL;
2543 goto error;
2544 }
2545 break;
2546 }
2547 case LTTNG_DOMAIN_LOG4J:
2548 case LTTNG_DOMAIN_JUL:
2549 case LTTNG_DOMAIN_PYTHON:
2550 default:
2551 ret = LTTNG_ERR_UND;
2552 goto error;
2553 }
2554
2555 return nr_pids;
2556
2557 error:
2558 /* Return negative value to differentiate return code */
2559 return -ret;
2560 }
2561
2562 /*
2563 * Command LTTNG_START_TRACE processed by the client thread.
2564 *
2565 * Called with session mutex held.
2566 */
2567 int cmd_start_trace(struct ltt_session *session)
2568 {
2569 enum lttng_error_code ret;
2570 unsigned long nb_chan = 0;
2571 struct ltt_kernel_session *ksession;
2572 struct ltt_ust_session *usess;
2573 const bool session_rotated_after_last_stop =
2574 session->rotated_after_last_stop;
2575
2576 assert(session);
2577
2578 /* Ease our life a bit ;) */
2579 ksession = session->kernel_session;
2580 usess = session->ust_session;
2581
2582 /* Is the session already started? */
2583 if (session->active) {
2584 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2585 goto error;
2586 }
2587
2588 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
2589 !session->current_trace_chunk) {
2590 /*
2591 * A rotation was launched while the session was stopped and
2592 * it has not been completed yet. It is not possible to start
2593 * the session since starting the session here would require a
2594 * rotation from "NULL" to a new trace chunk. That rotation
2595 * would overlap with the ongoing rotation, which is not
2596 * supported.
2597 */
2598 WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing",
2599 session->name);
2600 ret = LTTNG_ERR_ROTATION_PENDING;
2601 goto error;
2602 }
2603
2604 /*
2605 * Starting a session without channel is useless since after that it's not
2606 * possible to enable channel thus inform the client.
2607 */
2608 if (usess && usess->domain_global.channels) {
2609 nb_chan += lttng_ht_get_count(usess->domain_global.channels);
2610 }
2611 if (ksession) {
2612 nb_chan += ksession->channel_count;
2613 }
2614 if (!nb_chan) {
2615 ret = LTTNG_ERR_NO_CHANNEL;
2616 goto error;
2617 }
2618
2619 session->active = 1;
2620 session->rotated_after_last_stop = false;
2621 if (session->output_traces && !session->current_trace_chunk) {
2622 if (!session->has_been_started) {
2623 struct lttng_trace_chunk *trace_chunk;
2624
2625 DBG("Creating initial trace chunk of session \"%s\"",
2626 session->name);
2627 trace_chunk = session_create_new_trace_chunk(
2628 session, NULL, NULL, NULL);
2629 if (!trace_chunk) {
2630 ret = LTTNG_ERR_CREATE_DIR_FAIL;
2631 goto error;
2632 }
2633 assert(!session->current_trace_chunk);
2634 ret = session_set_trace_chunk(session, trace_chunk,
2635 NULL);
2636 lttng_trace_chunk_put(trace_chunk);
2637 if (ret) {
2638 ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
2639 goto error;
2640 }
2641 } else {
2642 DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk",
2643 session->name);
2644 /*
2645 * Rotate existing streams into the new chunk.
2646 * This is a "quiet" rotation has no client has
2647 * explicitly requested this operation.
2648 *
2649 * There is also no need to wait for the rotation
2650 * to complete as it will happen immediately. No data
2651 * was produced as the session was stopped, so the
2652 * rotation should happen on reception of the command.
2653 */
2654 ret = cmd_rotate_session(session, NULL, true);
2655 if (ret != LTTNG_OK) {
2656 goto error;
2657 }
2658 }
2659 }
2660
2661 /* Kernel tracing */
2662 if (ksession != NULL) {
2663 DBG("Start kernel tracing session %s", session->name);
2664 ret = start_kernel_session(ksession);
2665 if (ret != LTTNG_OK) {
2666 goto error;
2667 }
2668 }
2669
2670 /* Flag session that trace should start automatically */
2671 if (usess) {
2672 int int_ret = ust_app_start_trace_all(usess);
2673
2674 if (int_ret < 0) {
2675 ret = LTTNG_ERR_UST_START_FAIL;
2676 goto error;
2677 }
2678 }
2679
2680 /*
2681 * Clear the flag that indicates that a rotation was done while the
2682 * session was stopped.
2683 */
2684 session->rotated_after_last_stop = false;
2685
2686 if (session->rotate_timer_period) {
2687 int int_ret = timer_session_rotation_schedule_timer_start(
2688 session, session->rotate_timer_period);
2689
2690 if (int_ret < 0) {
2691 ERR("Failed to enable rotate timer");
2692 ret = LTTNG_ERR_UNK;
2693 goto error;
2694 }
2695 }
2696
2697 ret = LTTNG_OK;
2698
2699 error:
2700 if (ret == LTTNG_OK) {
2701 /* Flag this after a successful start. */
2702 session->has_been_started |= 1;
2703 } else {
2704 session->active = 0;
2705 /* Restore initial state on error. */
2706 session->rotated_after_last_stop =
2707 session_rotated_after_last_stop;
2708 }
2709 return ret;
2710 }
2711
2712 /*
2713 * Command LTTNG_STOP_TRACE processed by the client thread.
2714 */
2715 int cmd_stop_trace(struct ltt_session *session)
2716 {
2717 int ret;
2718 struct ltt_kernel_channel *kchan;
2719 struct ltt_kernel_session *ksession;
2720 struct ltt_ust_session *usess;
2721 bool error_occurred = false;
2722
2723 assert(session);
2724
2725 DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id);
2726 /* Short cut */
2727 ksession = session->kernel_session;
2728 usess = session->ust_session;
2729
2730 /* Session is not active. Skip everythong and inform the client. */
2731 if (!session->active) {
2732 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2733 goto error;
2734 }
2735
2736 /* Kernel tracer */
2737 if (ksession && ksession->active) {
2738 DBG("Stop kernel tracing");
2739
2740 ret = kernel_stop_session(ksession);
2741 if (ret < 0) {
2742 ret = LTTNG_ERR_KERN_STOP_FAIL;
2743 goto error;
2744 }
2745
2746 kernel_wait_quiescent();
2747
2748 /* Flush metadata after stopping (if exists) */
2749 if (ksession->metadata_stream_fd >= 0) {
2750 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
2751 if (ret < 0) {
2752 ERR("Kernel metadata flush failed");
2753 error_occurred = true;
2754 }
2755 }
2756
2757 /* Flush all buffers after stopping */
2758 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2759 ret = kernel_flush_buffer(kchan);
2760 if (ret < 0) {
2761 ERR("Kernel flush buffer error");
2762 error_occurred = true;
2763 }
2764 }
2765
2766 ksession->active = 0;
2767 DBG("Kernel session stopped %s (id %" PRIu64 ")", session->name,
2768 session->id);
2769 }
2770
2771 if (usess && usess->active) {
2772 ret = ust_app_stop_trace_all(usess);
2773 if (ret < 0) {
2774 ret = LTTNG_ERR_UST_STOP_FAIL;
2775 goto error;
2776 }
2777 }
2778
2779 /* Flag inactive after a successful stop. */
2780 session->active = 0;
2781 ret = !error_occurred ? LTTNG_OK : LTTNG_ERR_UNK;
2782
2783 error:
2784 return ret;
2785 }
2786
2787 /*
2788 * Set the base_path of the session only if subdir of a control uris is set.
2789 * Return LTTNG_OK on success, otherwise LTTNG_ERR_*.
2790 */
2791 static int set_session_base_path_from_uris(struct ltt_session *session,
2792 size_t nb_uri,
2793 struct lttng_uri *uris)
2794 {
2795 int ret;
2796 size_t i;
2797
2798 for (i = 0; i < nb_uri; i++) {
2799 if (uris[i].stype != LTTNG_STREAM_CONTROL ||
2800 uris[i].subdir[0] == '\0') {
2801 /* Not interested in these URIs */
2802 continue;
2803 }
2804
2805 if (session->base_path != NULL) {
2806 free(session->base_path);
2807 session->base_path = NULL;
2808 }
2809
2810 /* Set session base_path */
2811 session->base_path = strdup(uris[i].subdir);
2812 if (!session->base_path) {
2813 PERROR("Failed to copy base path \"%s\" to session \"%s\"",
2814 uris[i].subdir, session->name);
2815 ret = LTTNG_ERR_NOMEM;
2816 goto error;
2817 }
2818 DBG2("Setting base path \"%s\" for session \"%s\"",
2819 session->base_path, session->name);
2820 }
2821 ret = LTTNG_OK;
2822 error:
2823 return ret;
2824 }
2825
2826 /*
2827 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2828 */
2829 int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2830 struct lttng_uri *uris)
2831 {
2832 int ret, i;
2833 struct ltt_kernel_session *ksess = session->kernel_session;
2834 struct ltt_ust_session *usess = session->ust_session;
2835
2836 assert(session);
2837 assert(uris);
2838 assert(nb_uri > 0);
2839
2840 /* Can't set consumer URI if the session is active. */
2841 if (session->active) {
2842 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2843 goto error;
2844 }
2845
2846 /*
2847 * Set the session base path if any. This is done inside
2848 * cmd_set_consumer_uri to preserve backward compatibility of the
2849 * previous session creation api vs the session descriptor api.
2850 */
2851 ret = set_session_base_path_from_uris(session, nb_uri, uris);
2852 if (ret != LTTNG_OK) {
2853 goto error;
2854 }
2855
2856 /* Set the "global" consumer URIs */
2857 for (i = 0; i < nb_uri; i++) {
2858 ret = add_uri_to_consumer(session, session->consumer, &uris[i],
2859 LTTNG_DOMAIN_NONE);
2860 if (ret != LTTNG_OK) {
2861 goto error;
2862 }
2863 }
2864
2865 /* Set UST session URIs */
2866 if (session->ust_session) {
2867 for (i = 0; i < nb_uri; i++) {
2868 ret = add_uri_to_consumer(session,
2869 session->ust_session->consumer,
2870 &uris[i], LTTNG_DOMAIN_UST);
2871 if (ret != LTTNG_OK) {
2872 goto error;
2873 }
2874 }
2875 }
2876
2877 /* Set kernel session URIs */
2878 if (session->kernel_session) {
2879 for (i = 0; i < nb_uri; i++) {
2880 ret = add_uri_to_consumer(session,
2881 session->kernel_session->consumer,
2882 &uris[i], LTTNG_DOMAIN_KERNEL);
2883 if (ret != LTTNG_OK) {
2884 goto error;
2885 }
2886 }
2887 }
2888
2889 /*
2890 * Make sure to set the session in output mode after we set URI since a
2891 * session can be created without URL (thus flagged in no output mode).
2892 */
2893 session->output_traces = 1;
2894 if (ksess) {
2895 ksess->output_traces = 1;
2896 }
2897
2898 if (usess) {
2899 usess->output_traces = 1;
2900 }
2901
2902 /* All good! */
2903 ret = LTTNG_OK;
2904
2905 error:
2906 return ret;
2907 }
2908
2909 static
2910 enum lttng_error_code set_session_output_from_descriptor(
2911 struct ltt_session *session,
2912 const struct lttng_session_descriptor *descriptor)
2913 {
2914 int ret;
2915 enum lttng_error_code ret_code = LTTNG_OK;
2916 enum lttng_session_descriptor_type session_type =
2917 lttng_session_descriptor_get_type(descriptor);
2918 enum lttng_session_descriptor_output_type output_type =
2919 lttng_session_descriptor_get_output_type(descriptor);
2920 struct lttng_uri uris[2] = {};
2921 size_t uri_count = 0;
2922
2923 switch (output_type) {
2924 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
2925 goto end;
2926 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
2927 lttng_session_descriptor_get_local_output_uri(descriptor,
2928 &uris[0]);
2929 uri_count = 1;
2930 break;
2931 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
2932 lttng_session_descriptor_get_network_output_uris(descriptor,
2933 &uris[0], &uris[1]);
2934 uri_count = 2;
2935 break;
2936 default:
2937 ret_code = LTTNG_ERR_INVALID;
2938 goto end;
2939 }
2940
2941 switch (session_type) {
2942 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
2943 {
2944 struct snapshot_output *new_output = NULL;
2945
2946 new_output = snapshot_output_alloc();
2947 if (!new_output) {
2948 ret_code = LTTNG_ERR_NOMEM;
2949 goto end;
2950 }
2951
2952 ret = snapshot_output_init_with_uri(session,
2953 DEFAULT_SNAPSHOT_MAX_SIZE,
2954 NULL, uris, uri_count, session->consumer,
2955 new_output, &session->snapshot);
2956 if (ret < 0) {
2957 ret_code = (ret == -ENOMEM) ?
2958 LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID;
2959 snapshot_output_destroy(new_output);
2960 goto end;
2961 }
2962 snapshot_add_output(&session->snapshot, new_output);
2963 break;
2964 }
2965 case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
2966 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
2967 {
2968 ret_code = cmd_set_consumer_uri(session, uri_count, uris);
2969 break;
2970 }
2971 default:
2972 ret_code = LTTNG_ERR_INVALID;
2973 goto end;
2974 }
2975 end:
2976 return ret_code;
2977 }
2978
2979 static
2980 enum lttng_error_code cmd_create_session_from_descriptor(
2981 struct lttng_session_descriptor *descriptor,
2982 const lttng_sock_cred *creds,
2983 const char *home_path)
2984 {
2985 int ret;
2986 enum lttng_error_code ret_code;
2987 const char *session_name;
2988 struct ltt_session *new_session = NULL;
2989 enum lttng_session_descriptor_status descriptor_status;
2990
2991 session_lock_list();
2992 if (home_path) {
2993 if (*home_path != '/') {
2994 ERR("Home path provided by client is not absolute");
2995 ret_code = LTTNG_ERR_INVALID;
2996 goto end;
2997 }
2998 }
2999
3000 descriptor_status = lttng_session_descriptor_get_session_name(
3001 descriptor, &session_name);
3002 switch (descriptor_status) {
3003 case LTTNG_SESSION_DESCRIPTOR_STATUS_OK:
3004 break;
3005 case LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET:
3006 session_name = NULL;
3007 break;
3008 default:
3009 ret_code = LTTNG_ERR_INVALID;
3010 goto end;
3011 }
3012
3013 ret_code = session_create(session_name, creds->uid, creds->gid,
3014 &new_session);
3015 if (ret_code != LTTNG_OK) {
3016 goto end;
3017 }
3018
3019 if (!session_name) {
3020 ret = lttng_session_descriptor_set_session_name(descriptor,
3021 new_session->name);
3022 if (ret) {
3023 ret_code = LTTNG_ERR_SESSION_FAIL;
3024 goto end;
3025 }
3026 }
3027
3028 if (!lttng_session_descriptor_is_output_destination_initialized(
3029 descriptor)) {
3030 /*
3031 * Only include the session's creation time in the output
3032 * destination if the name of the session itself was
3033 * not auto-generated.
3034 */
3035 ret_code = lttng_session_descriptor_set_default_output(
3036 descriptor,
3037 session_name ? &new_session->creation_time : NULL,
3038 home_path);
3039 if (ret_code != LTTNG_OK) {
3040 goto end;
3041 }
3042 } else {
3043 new_session->has_user_specified_directory =
3044 lttng_session_descriptor_has_output_directory(
3045 descriptor);
3046 }
3047
3048 switch (lttng_session_descriptor_get_type(descriptor)) {
3049 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
3050 new_session->snapshot_mode = 1;
3051 break;
3052 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
3053 new_session->live_timer =
3054 lttng_session_descriptor_live_get_timer_interval(
3055 descriptor);
3056 break;
3057 default:
3058 break;
3059 }
3060
3061 ret_code = set_session_output_from_descriptor(new_session, descriptor);
3062 if (ret_code != LTTNG_OK) {
3063 goto end;
3064 }
3065 new_session->consumer->enabled = 1;
3066 ret_code = LTTNG_OK;
3067 end:
3068 /* Release reference provided by the session_create function. */
3069 session_put(new_session);
3070 if (ret_code != LTTNG_OK && new_session) {
3071 /* Release the global reference on error. */
3072 session_destroy(new_session);
3073 }
3074 session_unlock_list();
3075 return ret_code;
3076 }
3077
3078 enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
3079 struct lttng_session_descriptor **return_descriptor)
3080 {
3081 int ret;
3082 size_t payload_size;
3083 struct lttng_dynamic_buffer payload;
3084 struct lttng_buffer_view home_dir_view;
3085 struct lttng_buffer_view session_descriptor_view;
3086 struct lttng_session_descriptor *session_descriptor = NULL;
3087 enum lttng_error_code ret_code;
3088
3089 lttng_dynamic_buffer_init(&payload);
3090 if (cmd_ctx->lsm->u.create_session.home_dir_size >=
3091 LTTNG_PATH_MAX) {
3092 ret_code = LTTNG_ERR_INVALID;
3093 goto error;
3094 }
3095 if (cmd_ctx->lsm->u.create_session.session_descriptor_size >
3096 LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
3097 ret_code = LTTNG_ERR_INVALID;
3098 goto error;
3099 }
3100
3101 payload_size = cmd_ctx->lsm->u.create_session.home_dir_size +
3102 cmd_ctx->lsm->u.create_session.session_descriptor_size;
3103 ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
3104 if (ret) {
3105 ret_code = LTTNG_ERR_NOMEM;
3106 goto error;
3107 }
3108
3109 ret = lttcomm_recv_unix_sock(sock, payload.data, payload.size);
3110 if (ret <= 0) {
3111 ERR("Reception of session descriptor failed, aborting.");
3112 ret_code = LTTNG_ERR_SESSION_FAIL;
3113 goto error;
3114 }
3115
3116 home_dir_view = lttng_buffer_view_from_dynamic_buffer(
3117 &payload,
3118 0,
3119 cmd_ctx->lsm->u.create_session.home_dir_size);
3120 session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
3121 &payload,
3122 cmd_ctx->lsm->u.create_session.home_dir_size,
3123 cmd_ctx->lsm->u.create_session.session_descriptor_size);
3124
3125 ret = lttng_session_descriptor_create_from_buffer(
3126 &session_descriptor_view, &session_descriptor);
3127 if (ret < 0) {
3128 ERR("Failed to create session descriptor from payload of \"create session\" command");
3129 ret_code = LTTNG_ERR_INVALID;
3130 goto error;
3131 }
3132
3133 /*
3134 * Sets the descriptor's auto-generated properties (name, output) if
3135 * needed.
3136 */
3137 ret_code = cmd_create_session_from_descriptor(session_descriptor,
3138 &cmd_ctx->creds,
3139 home_dir_view.size ? home_dir_view.data : NULL);
3140 if (ret_code != LTTNG_OK) {
3141 goto error;
3142 }
3143
3144 ret_code = LTTNG_OK;
3145 *return_descriptor = session_descriptor;
3146 session_descriptor = NULL;
3147 error:
3148 lttng_dynamic_buffer_reset(&payload);
3149 lttng_session_descriptor_destroy(session_descriptor);
3150 return ret_code;
3151 }
3152
3153 static
3154 void cmd_destroy_session_reply(const struct ltt_session *session,
3155 void *_reply_context)
3156 {
3157 int ret;
3158 ssize_t comm_ret;
3159 const struct cmd_destroy_session_reply_context *reply_context =
3160 _reply_context;
3161 struct lttng_dynamic_buffer payload;
3162 struct lttcomm_session_destroy_command_header cmd_header;
3163 struct lttng_trace_archive_location *location = NULL;
3164 struct lttcomm_lttng_msg llm = {
3165 .cmd_type = LTTNG_DESTROY_SESSION,
3166 .ret_code = reply_context->destruction_status,
3167 .pid = UINT32_MAX,
3168 .cmd_header_size =
3169 sizeof(struct lttcomm_session_destroy_command_header),
3170 .data_size = 0,
3171 };
3172 size_t payload_size_before_location;
3173
3174 lttng_dynamic_buffer_init(&payload);
3175
3176 ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm));
3177 if (ret) {
3178 ERR("Failed to append session destruction message");
3179 goto error;
3180 }
3181
3182 cmd_header.rotation_state =
3183 (int32_t) (reply_context->implicit_rotation_on_destroy ?
3184 session->rotation_state :
3185 LTTNG_ROTATION_STATE_NO_ROTATION);
3186 ret = lttng_dynamic_buffer_append(&payload, &cmd_header,
3187 sizeof(cmd_header));
3188 if (ret) {
3189 ERR("Failed to append session destruction command header");
3190 goto error;
3191 }
3192
3193 if (!reply_context->implicit_rotation_on_destroy) {
3194 DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply",
3195 session->name);
3196 goto send_reply;
3197 }
3198 if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) {
3199 DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply",
3200 session->name);
3201 goto send_reply;
3202 }
3203
3204 location = session_get_trace_archive_location(session);
3205 if (!location) {
3206 ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"",
3207 session->name);
3208 goto error;
3209 }
3210
3211 payload_size_before_location = payload.size;
3212 comm_ret = lttng_trace_archive_location_serialize(location,
3213 &payload);
3214 if (comm_ret < 0) {
3215 ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
3216 session->name);
3217 goto error;
3218 }
3219 /* Update the message to indicate the location's length. */
3220 ((struct lttcomm_lttng_msg *) payload.data)->data_size =
3221 payload.size - payload_size_before_location;
3222 send_reply:
3223 comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd,
3224 payload.data, payload.size);
3225 if (comm_ret != (ssize_t) payload.size) {
3226 ERR("Failed to send result of the destruction of session \"%s\" to client",
3227 session->name);
3228 }
3229 error:
3230 ret = close(reply_context->reply_sock_fd);
3231 if (ret) {
3232 PERROR("Failed to close client socket in deferred session destroy reply");
3233 }
3234 lttng_dynamic_buffer_reset(&payload);
3235 free(_reply_context);
3236 }
3237
3238 /*
3239 * Command LTTNG_DESTROY_SESSION processed by the client thread.
3240 *
3241 * Called with session lock held.
3242 */
3243 int cmd_destroy_session(struct ltt_session *session,
3244 struct notification_thread_handle *notification_thread_handle,
3245 int *sock_fd)
3246 {
3247 int ret;
3248 enum lttng_error_code destruction_last_error = LTTNG_OK;
3249 struct cmd_destroy_session_reply_context *reply_context = NULL;
3250
3251 if (sock_fd) {
3252 reply_context = zmalloc(sizeof(*reply_context));
3253 if (!reply_context) {
3254 ret = LTTNG_ERR_NOMEM;
3255 goto end;
3256 }
3257 reply_context->reply_sock_fd = *sock_fd;
3258 }
3259
3260 /* Safety net */
3261 assert(session);
3262
3263 DBG("Begin destroy session %s (id %" PRIu64 ")", session->name,
3264 session->id);
3265 if (session->active) {
3266 DBG("Session \"%s\" is active, attempting to stop it before destroying it",
3267 session->name);
3268 ret = cmd_stop_trace(session);
3269 if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) {
3270 /* Carry on with the destruction of the session. */
3271 ERR("Failed to stop session \"%s\" as part of its destruction: %s",
3272 session->name, lttng_strerror(-ret));
3273 destruction_last_error = ret;
3274 }
3275 }
3276
3277 if (session->rotation_schedule_timer_enabled) {
3278 if (timer_session_rotation_schedule_timer_stop(
3279 session)) {
3280 ERR("Failed to stop the \"rotation schedule\" timer of session %s",
3281 session->name);
3282 destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;
3283 }
3284 }
3285
3286 if (session->rotate_size) {
3287 unsubscribe_session_consumed_size_rotation(session, notification_thread_handle);
3288 session->rotate_size = 0;
3289 }
3290
3291 if (session->most_recent_chunk_id.is_set &&
3292 session->most_recent_chunk_id.value != 0 &&
3293 session->current_trace_chunk && session->output_traces) {
3294 /*
3295 * Perform a last rotation on destruction if rotations have
3296 * occurred during the session's lifetime.
3297 */
3298 ret = cmd_rotate_session(session, NULL, false);
3299 if (ret != LTTNG_OK) {
3300 ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
3301 session->name, lttng_strerror(-ret));
3302 destruction_last_error = -ret;
3303 }
3304 if (reply_context) {
3305 reply_context->implicit_rotation_on_destroy = true;
3306 }
3307 } else if (session->has_been_started && session->current_trace_chunk) {
3308 /*
3309 * The user has not triggered a session rotation. However, to
3310 * ensure all data has been consumed, the session is rotated
3311 * to a 'null' trace chunk before it is destroyed.
3312 *
3313 * This is a "quiet" rotation meaning that no notification is
3314 * emitted and no renaming of the current trace chunk takes
3315 * place.
3316 */
3317 ret = cmd_rotate_session(session, NULL, true);
3318 if (ret != LTTNG_OK) {
3319 ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
3320 session->name, lttng_strerror(-ret));
3321 destruction_last_error = -ret;
3322 }
3323 }
3324
3325 if (session->shm_path[0]) {
3326 /*
3327 * When a session is created with an explicit shm_path,
3328 * the consumer daemon will create its shared memory files
3329 * at that location and will *not* unlink them. This is normal
3330 * as the intention of that feature is to make it possible
3331 * to retrieve the content of those files should a crash occur.
3332 *
3333 * To ensure the content of those files can be used, the
3334 * sessiond daemon will replicate the content of the metadata
3335 * cache in a metadata file.
3336 *
3337 * On clean-up, it is expected that the consumer daemon will
3338 * unlink the shared memory files and that the session daemon
3339 * will unlink the metadata file. Then, the session's directory
3340 * in the shm path can be removed.
3341 *
3342 * Unfortunately, a flaw in the design of the sessiond's and
3343 * consumerd's tear down of channels makes it impossible to
3344 * determine when the sessiond _and_ the consumerd have both
3345 * destroyed their representation of a channel. For one, the
3346 * unlinking, close, and rmdir happen in deferred 'call_rcu'
3347 * callbacks in both daemons.
3348 *
3349 * However, it is also impossible for the sessiond to know when
3350 * the consumer daemon is done destroying its channel(s) since
3351 * it occurs as a reaction to the closing of the channel's file
3352 * descriptor. There is no resulting communication initiated
3353 * from the consumerd to the sessiond to confirm that the
3354 * operation is completed (and was successful).
3355 *
3356 * Until this is all fixed, the session daemon checks for the
3357 * removal of the session's shm path which makes it possible
3358 * to safely advertise a session as having been destroyed.
3359 *
3360 * Prior to this fix, it was not possible to reliably save
3361 * a session making use of the --shm-path option, destroy it,
3362 * and load it again. This is because the creation of the
3363 * session would fail upon seeing the session's shm path
3364 * already in existence.
3365 *
3366 * Note that none of the error paths in the check for the
3367 * directory's existence return an error. This is normal
3368 * as there isn't much that can be done. The session will
3369 * be destroyed properly, except that we can't offer the
3370 * guarantee that the same session can be re-created.
3371 */
3372 current_completion_handler = &destroy_completion_handler.handler;
3373 ret = lttng_strncpy(destroy_completion_handler.shm_path,
3374 session->shm_path,
3375 sizeof(destroy_completion_handler.shm_path));
3376 assert(!ret);
3377 }
3378
3379 /*
3380 * The session is destroyed. However, note that the command context
3381 * still holds a reference to the session, thus delaying its destruction
3382 * _at least_ up to the point when that reference is released.
3383 */
3384 session_destroy(session);
3385 if (reply_context) {
3386 reply_context->destruction_status = destruction_last_error;
3387 ret = session_add_destroy_notifier(session,
3388 cmd_destroy_session_reply,
3389 (void *) reply_context);
3390 if (ret) {
3391 ret = LTTNG_ERR_FATAL;
3392 goto end;
3393 } else {
3394 *sock_fd = -1;
3395 }
3396 }
3397 ret = LTTNG_OK;
3398 end:
3399 return ret;
3400 }
3401
3402 /*
3403 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
3404 */
3405 int cmd_register_consumer(struct ltt_session *session,
3406 enum lttng_domain_type domain, const char *sock_path,
3407 struct consumer_data *cdata)
3408 {
3409 int ret, sock;
3410 struct consumer_socket *socket = NULL;
3411
3412 assert(session);
3413 assert(cdata);
3414 assert(sock_path);
3415
3416 switch (domain) {
3417 case LTTNG_DOMAIN_KERNEL:
3418 {
3419 struct ltt_kernel_session *ksess = session->kernel_session;
3420
3421 assert(ksess);
3422
3423 /* Can't register a consumer if there is already one */
3424 if (ksess->consumer_fds_sent != 0) {
3425 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
3426 goto error;
3427 }
3428
3429 sock = lttcomm_connect_unix_sock(sock_path);
3430 if (sock < 0) {
3431 ret = LTTNG_ERR_CONNECT_FAIL;
3432 goto error;
3433 }
3434 cdata->cmd_sock = sock;
3435
3436 socket = consumer_allocate_socket(&cdata->cmd_sock);
3437 if (socket == NULL) {
3438 ret = close(sock);
3439 if (ret < 0) {
3440 PERROR("close register consumer");
3441 }
3442 cdata->cmd_sock = -1;
3443 ret = LTTNG_ERR_FATAL;
3444 goto error;
3445 }
3446
3447 socket->lock = zmalloc(sizeof(pthread_mutex_t));
3448 if (socket->lock == NULL) {
3449 PERROR("zmalloc pthread mutex");
3450 ret = LTTNG_ERR_FATAL;
3451 goto error;
3452 }
3453 pthread_mutex_init(socket->lock, NULL);
3454 socket->registered = 1;
3455
3456 rcu_read_lock();
3457 consumer_add_socket(socket, ksess->consumer);
3458 rcu_read_unlock();
3459
3460 pthread_mutex_lock(&cdata->pid_mutex);
3461 cdata->pid = -1;
3462 pthread_mutex_unlock(&cdata->pid_mutex);
3463
3464 break;
3465 }
3466 default:
3467 /* TODO: Userspace tracing */
3468 ret = LTTNG_ERR_UND;
3469 goto error;
3470 }
3471
3472 return LTTNG_OK;
3473
3474 error:
3475 if (socket) {
3476 consumer_destroy_socket(socket);
3477 }
3478 return ret;
3479 }
3480
3481 /*
3482 * Command LTTNG_LIST_DOMAINS processed by the client thread.
3483 */
3484 ssize_t cmd_list_domains(struct ltt_session *session,
3485 struct lttng_domain **domains)
3486 {
3487 int ret, index = 0;
3488 ssize_t nb_dom = 0;
3489 struct agent *agt;
3490 struct lttng_ht_iter iter;
3491
3492 if (session->kernel_session != NULL) {
3493 DBG3("Listing domains found kernel domain");
3494 nb_dom++;
3495 }
3496
3497 if (session->ust_session != NULL) {
3498 DBG3("Listing domains found UST global domain");
3499 nb_dom++;
3500
3501 rcu_read_lock();
3502 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3503 agt, node.node) {
3504 if (agt->being_used) {
3505 nb_dom++;
3506 }
3507 }
3508 rcu_read_unlock();
3509 }
3510
3511 if (!nb_dom) {
3512 goto end;
3513 }
3514
3515 *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
3516 if (*domains == NULL) {
3517 ret = LTTNG_ERR_FATAL;
3518 goto error;
3519 }
3520
3521 if (session->kernel_session != NULL) {
3522 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
3523
3524 /* Kernel session buffer type is always GLOBAL */
3525 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
3526
3527 index++;
3528 }
3529
3530 if (session->ust_session != NULL) {
3531 (*domains)[index].type = LTTNG_DOMAIN_UST;
3532 (*domains)[index].buf_type = session->ust_session->buffer_type;
3533 index++;
3534
3535 rcu_read_lock();
3536 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3537 agt, node.node) {
3538 if (agt->being_used) {
3539 (*domains)[index].type = agt->domain;
3540 (*domains)[index].buf_type = session->ust_session->buffer_type;
3541 index++;
3542 }
3543 }
3544 rcu_read_unlock();
3545 }
3546 end:
3547 return nb_dom;
3548
3549 error:
3550 /* Return negative value to differentiate return code */
3551 return -ret;
3552 }
3553
3554
3555 /*
3556 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3557 */
3558 ssize_t cmd_list_channels(enum lttng_domain_type domain,
3559 struct ltt_session *session, struct lttng_channel **channels)
3560 {
3561 ssize_t nb_chan = 0, payload_size = 0, ret;
3562
3563 switch (domain) {
3564 case LTTNG_DOMAIN_KERNEL:
3565 if (session->kernel_session != NULL) {
3566 nb_chan = session->kernel_session->channel_count;
3567 }
3568 DBG3("Number of kernel channels %zd", nb_chan);
3569 if (nb_chan <= 0) {
3570 ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
3571 goto end;
3572 }
3573 break;
3574 case LTTNG_DOMAIN_UST:
3575 if (session->ust_session != NULL) {
3576 rcu_read_lock();
3577 nb_chan = lttng_ht_get_count(
3578 session->ust_session->domain_global.channels);
3579 rcu_read_unlock();
3580 }
3581 DBG3("Number of UST global channels %zd", nb_chan);
3582 if (nb_chan < 0) {
3583 ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
3584 goto end;
3585 }
3586 break;
3587 default:
3588 ret = -LTTNG_ERR_UND;
3589 goto end;
3590 }
3591
3592 if (nb_chan > 0) {
3593 const size_t channel_size = sizeof(struct lttng_channel) +
3594 sizeof(struct lttng_channel_extended);
3595 struct lttng_channel_extended *channel_exts;
3596
3597 payload_size = nb_chan * channel_size;
3598 *channels = zmalloc(payload_size);
3599 if (*channels == NULL) {
3600 ret = -LTTNG_ERR_FATAL;
3601 goto end;
3602 }
3603
3604 channel_exts = ((void *) *channels) +
3605 (nb_chan * sizeof(struct lttng_channel));
3606 ret = list_lttng_channels(domain, session, *channels, channel_exts);
3607 if (ret != LTTNG_OK) {
3608 free(*channels);
3609 *channels = NULL;
3610 goto end;
3611 }
3612 } else {
3613 *channels = NULL;
3614 }
3615
3616 ret = payload_size;
3617 end:
3618 return ret;
3619 }
3620
3621 /*
3622 * Command LTTNG_LIST_EVENTS processed by the client thread.
3623 */
3624 ssize_t cmd_list_events(enum lttng_domain_type domain,
3625 struct ltt_session *session, char *channel_name,
3626 struct lttng_event **events, size_t *total_size)
3627 {
3628 int ret = 0;
3629 ssize_t nb_event = 0;
3630
3631 switch (domain) {
3632 case LTTNG_DOMAIN_KERNEL:
3633 if (session->kernel_session != NULL) {
3634 nb_event = list_lttng_kernel_events(channel_name,
3635 session->kernel_session, events,
3636 total_size);
3637 }
3638 break;
3639 case LTTNG_DOMAIN_UST:
3640 {
3641 if (session->ust_session != NULL) {
3642 nb_event = list_lttng_ust_global_events(channel_name,
3643 &session->ust_session->domain_global, events,
3644 total_size);
3645 }
3646 break;
3647 }
3648 case LTTNG_DOMAIN_LOG4J:
3649 case LTTNG_DOMAIN_JUL:
3650 case LTTNG_DOMAIN_PYTHON:
3651 if (session->ust_session) {
3652 struct lttng_ht_iter iter;
3653 struct agent *agt;
3654
3655 rcu_read_lock();
3656 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3657 &iter.iter, agt, node.node) {
3658 if (agt->domain == domain) {
3659 nb_event = list_lttng_agent_events(
3660 agt, events,
3661 total_size);
3662 break;
3663 }
3664 }
3665 rcu_read_unlock();
3666 }
3667 break;
3668 default:
3669 ret = LTTNG_ERR_UND;
3670 goto error;
3671 }
3672
3673 return nb_event;
3674
3675 error:
3676 /* Return negative value to differentiate return code */
3677 return -ret;
3678 }
3679
3680 /*
3681 * Using the session list, filled a lttng_session array to send back to the
3682 * client for session listing.
3683 *
3684 * The session list lock MUST be acquired before calling this function. Use
3685 * session_lock_list() and session_unlock_list().
3686 */
3687 void cmd_list_lttng_sessions(struct lttng_session *sessions,
3688 size_t session_count, uid_t uid, gid_t gid)
3689 {
3690 int ret;
3691 unsigned int i = 0;
3692 struct ltt_session *session;
3693 struct ltt_session_list *list = session_get_list();
3694 struct lttng_session_extended *extended =
3695 (typeof(extended)) (&sessions[session_count]);
3696
3697 DBG("Getting all available session for UID %d GID %d",
3698 uid, gid);
3699 /*
3700 * Iterate over session list and append data after the control struct in
3701 * the buffer.
3702 */
3703 cds_list_for_each_entry(session, &list->head, list) {
3704 if (!session_get(session)) {
3705 continue;
3706 }
3707 /*
3708 * Only list the sessions the user can control.
3709 */
3710 if (!session_access_ok(session, uid, gid) ||
3711 session->destroyed) {
3712 session_put(session);
3713 continue;
3714 }
3715
3716 struct ltt_kernel_session *ksess = session->kernel_session;
3717 struct ltt_ust_session *usess = session->ust_session;
3718
3719 if (session->consumer->type == CONSUMER_DST_NET ||
3720 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3721 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3722 ret = build_network_session_path(sessions[i].path,
3723 sizeof(sessions[i].path), session);
3724 } else {
3725 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
3726 session->consumer->dst.session_root_path);
3727 }
3728 if (ret < 0) {
3729 PERROR("snprintf session path");
3730 session_put(session);
3731 continue;
3732 }
3733
3734 strncpy(sessions[i].name, session->name, NAME_MAX);
3735 sessions[i].name[NAME_MAX - 1] = '\0';
3736 sessions[i].enabled = session->active;
3737 sessions[i].snapshot_mode = session->snapshot_mode;
3738 sessions[i].live_timer_interval = session->live_timer;
3739 extended[i].creation_time.value = (uint64_t) session->creation_time;
3740 extended[i].creation_time.is_set = 1;
3741 i++;
3742 session_put(session);
3743 }
3744 }
3745
3746 /*
3747 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
3748 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
3749 */
3750 int cmd_data_pending(struct ltt_session *session)
3751 {
3752 int ret;
3753 struct ltt_kernel_session *ksess = session->kernel_session;
3754 struct ltt_ust_session *usess = session->ust_session;
3755
3756 assert(session);
3757
3758 DBG("Data pending for session %s", session->name);
3759
3760 /* Session MUST be stopped to ask for data availability. */
3761 if (session->active) {
3762 ret = LTTNG_ERR_SESSION_STARTED;
3763 goto error;
3764 } else {
3765 /*
3766 * If stopped, just make sure we've started before else the above call
3767 * will always send that there is data pending.
3768 *
3769 * The consumer assumes that when the data pending command is received,
3770 * the trace has been started before or else no output data is written
3771 * by the streams which is a condition for data pending. So, this is
3772 * *VERY* important that we don't ask the consumer before a start
3773 * trace.
3774 */
3775 if (!session->has_been_started) {
3776 ret = 0;
3777 goto error;
3778 }
3779 }
3780
3781 /* A rotation is still pending, we have to wait. */
3782 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
3783 DBG("Rotate still pending for session %s", session->name);
3784 ret = 1;
3785 goto error;
3786 }
3787
3788 if (ksess && ksess->consumer) {
3789 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
3790 if (ret == 1) {
3791 /* Data is still being extracted for the kernel. */
3792 goto error;
3793 }
3794 }
3795
3796 if (usess && usess->consumer) {
3797 ret = consumer_is_data_pending(usess->id, usess->consumer);
3798 if (ret == 1) {
3799 /* Data is still being extracted for the kernel. */
3800 goto error;
3801 }
3802 }
3803
3804 /* Data is ready to be read by a viewer */
3805 ret = 0;
3806
3807 error:
3808 return ret;
3809 }
3810
3811 /*
3812 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
3813 *
3814 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3815 */
3816 int cmd_snapshot_add_output(struct ltt_session *session,
3817 const struct lttng_snapshot_output *output, uint32_t *id)
3818 {
3819 int ret;
3820 struct snapshot_output *new_output;
3821
3822 assert(session);
3823 assert(output);
3824
3825 DBG("Cmd snapshot add output for session %s", session->name);
3826
3827 /*
3828 * Can't create an output if the session is not set in no-output mode.
3829 */
3830 if (session->output_traces) {
3831 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3832 goto error;
3833 }
3834
3835 if (session->has_non_mmap_channel) {
3836 ret = LTTNG_ERR_SNAPSHOT_UNSUPPORTED;
3837 goto error;
3838 }
3839
3840 /* Only one output is allowed until we have the "tee" feature. */
3841 if (session->snapshot.nb_output == 1) {
3842 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
3843 goto error;
3844 }
3845
3846 new_output = snapshot_output_alloc();
3847 if (!new_output) {
3848 ret = LTTNG_ERR_NOMEM;
3849 goto error;
3850 }
3851
3852 ret = snapshot_output_init(session, output->max_size, output->name,
3853 output->ctrl_url, output->data_url, session->consumer, new_output,
3854 &session->snapshot);
3855 if (ret < 0) {
3856 if (ret == -ENOMEM) {
3857 ret = LTTNG_ERR_NOMEM;
3858 } else {
3859 ret = LTTNG_ERR_INVALID;
3860 }
3861 goto free_error;
3862 }
3863
3864 rcu_read_lock();
3865 snapshot_add_output(&session->snapshot, new_output);
3866 if (id) {
3867 *id = new_output->id;
3868 }
3869 rcu_read_unlock();
3870
3871 return LTTNG_OK;
3872
3873 free_error:
3874 snapshot_output_destroy(new_output);
3875 error:
3876 return ret;
3877 }
3878
3879 /*
3880 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
3881 *
3882 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3883 */
3884 int cmd_snapshot_del_output(struct ltt_session *session,
3885 const struct lttng_snapshot_output *output)
3886 {
3887 int ret;
3888 struct snapshot_output *sout = NULL;
3889
3890 assert(session);
3891 assert(output);
3892
3893 rcu_read_lock();
3894
3895 /*
3896 * Permission denied to create an output if the session is not
3897 * set in no output mode.
3898 */
3899 if (session->output_traces) {
3900 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3901 goto error;
3902 }
3903
3904 if (output->id) {
3905 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
3906 session->name);
3907 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
3908 } else if (*output->name != '\0') {
3909 DBG("Cmd snapshot del output name %s for session %s", output->name,
3910 session->name);
3911 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
3912 }
3913 if (!sout) {
3914 ret = LTTNG_ERR_INVALID;
3915 goto error;
3916 }
3917
3918 snapshot_delete_output(&session->snapshot, sout);
3919 snapshot_output_destroy(sout);
3920 ret = LTTNG_OK;
3921
3922 error:
3923 rcu_read_unlock();
3924 return ret;
3925 }
3926
3927 /*
3928 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
3929 *
3930 * If no output is available, outputs is untouched and 0 is returned.
3931 *
3932 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
3933 */
3934 ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
3935 struct lttng_snapshot_output **outputs)
3936 {
3937 int ret, idx = 0;
3938 struct lttng_snapshot_output *list = NULL;
3939 struct lttng_ht_iter iter;
3940 struct snapshot_output *output;
3941
3942 assert(session);
3943 assert(outputs);
3944
3945 DBG("Cmd snapshot list outputs for session %s", session->name);
3946
3947 /*
3948 * Permission denied to create an output if the session is not
3949 * set in no output mode.
3950 */
3951 if (session->output_traces) {
3952 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3953 goto end;
3954 }
3955
3956 if (session->snapshot.nb_output == 0) {
3957 ret = 0;
3958 goto end;
3959 }
3960
3961 list = zmalloc(session->snapshot.nb_output * sizeof(*list));
3962 if (!list) {
3963 ret = -LTTNG_ERR_NOMEM;
3964 goto end;
3965 }
3966
3967 /* Copy list from session to the new list object. */
3968 rcu_read_lock();
3969 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
3970 output, node.node) {
3971 assert(output->consumer);
3972 list[idx].id = output->id;
3973 list[idx].max_size = output->max_size;
3974 if (lttng_strncpy(list[idx].name, output->name,
3975 sizeof(list[idx].name))) {
3976 ret = -LTTNG_ERR_INVALID;
3977 goto error;
3978 }
3979 if (output->consumer->type == CONSUMER_DST_LOCAL) {
3980 if (lttng_strncpy(list[idx].ctrl_url,
3981 output->consumer->dst.session_root_path,
3982 sizeof(list[idx].ctrl_url))) {
3983 ret = -LTTNG_ERR_INVALID;
3984 goto error;
3985 }
3986 } else {
3987 /* Control URI. */
3988 ret = uri_to_str_url(&output->consumer->dst.net.control,
3989 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
3990 if (ret < 0) {
3991 ret = -LTTNG_ERR_NOMEM;
3992 goto error;
3993 }
3994
3995 /* Data URI. */
3996 ret = uri_to_str_url(&output->consumer->dst.net.data,
3997 list[idx].data_url, sizeof(list[idx].data_url));
3998 if (ret < 0) {
3999 ret = -LTTNG_ERR_NOMEM;
4000 goto error;
4001 }
4002 }
4003 idx++;
4004 }
4005
4006 *outputs = list;
4007 list = NULL;
4008 ret = session->snapshot.nb_output;
4009 error:
4010 rcu_read_unlock();
4011 free(list);
4012 end:
4013 return ret;
4014 }
4015
4016 /*
4017 * Check if we can regenerate the metadata for this session.
4018 * Only kernel, UST per-uid and non-live sessions are supported.
4019 *
4020 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
4021 */
4022 static
4023 int check_regenerate_metadata_support(struct ltt_session *session)
4024 {
4025 int ret;
4026
4027 assert(session);
4028
4029 if (session->live_timer != 0) {
4030 ret = LTTNG_ERR_LIVE_SESSION;
4031 goto end;
4032 }
4033 if (!session->active) {
4034 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4035 goto end;
4036 }
4037 if (session->ust_session) {
4038 switch (session->ust_session->buffer_type) {
4039 case LTTNG_BUFFER_PER_UID:
4040 break;
4041 case LTTNG_BUFFER_PER_PID:
4042 ret = LTTNG_ERR_PER_PID_SESSION;
4043 goto end;
4044 default:
4045 assert(0);
4046 ret = LTTNG_ERR_UNK;
4047 goto end;
4048 }
4049 }
4050 if (session->consumer->type == CONSUMER_DST_NET &&
4051 session->consumer->relay_minor_version < 8) {
4052 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
4053 goto end;
4054 }
4055 ret = 0;
4056
4057 end:
4058 return ret;
4059 }
4060
4061 static
4062 int clear_metadata_file(int fd)
4063 {
4064 int ret;
4065 off_t lseek_ret;
4066
4067 lseek_ret = lseek(fd, 0, SEEK_SET);
4068 if (lseek_ret < 0) {
4069 PERROR("lseek");
4070 ret = -1;
4071 goto end;
4072 }
4073
4074 ret = ftruncate(fd, 0);
4075 if (ret < 0) {
4076 PERROR("ftruncate");
4077 goto end;
4078 }
4079
4080 end:
4081 return ret;
4082 }
4083
4084 static
4085 int ust_regenerate_metadata(struct ltt_ust_session *usess)
4086 {
4087 int ret = 0;
4088 struct buffer_reg_uid *uid_reg = NULL;
4089 struct buffer_reg_session *session_reg = NULL;
4090
4091 rcu_read_lock();
4092 cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
4093 struct ust_registry_session *registry;
4094 struct ust_registry_channel *chan;
4095 struct lttng_ht_iter iter_chan;
4096
4097 session_reg = uid_reg->registry;
4098 registry = session_reg->reg.ust;
4099
4100 pthread_mutex_lock(&registry->lock);
4101 registry->metadata_len_sent = 0;
4102 memset(registry->metadata, 0, registry->metadata_alloc_len);
4103 registry->metadata_len = 0;
4104 registry->metadata_version++;
4105 if (registry->metadata_fd > 0) {
4106 /* Clear the metadata file's content. */
4107 ret = clear_metadata_file(registry->metadata_fd);
4108 if (ret) {
4109 pthread_mutex_unlock(&registry->lock);
4110 goto end;
4111 }
4112 }
4113
4114 ret = ust_metadata_session_statedump(registry, NULL,
4115 registry->major, registry->minor);
4116 if (ret) {
4117 pthread_mutex_unlock(&registry->lock);
4118 ERR("Failed to generate session metadata (err = %d)",
4119 ret);
4120 goto end;
4121 }
4122 cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
4123 chan, node.node) {
4124 struct ust_registry_event *event;
4125 struct lttng_ht_iter iter_event;
4126
4127 ret = ust_metadata_channel_statedump(registry, chan);
4128 if (ret) {
4129 pthread_mutex_unlock(&registry->lock);
4130 ERR("Failed to generate channel metadata "
4131 "(err = %d)", ret);
4132 goto end;
4133 }
4134 cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter,
4135 event, node.node) {
4136 ret = ust_metadata_event_statedump(registry,
4137 chan, event);
4138 if (ret) {
4139 pthread_mutex_unlock(&registry->lock);
4140 ERR("Failed to generate event metadata "
4141 "(err = %d)", ret);
4142 goto end;
4143 }
4144 }
4145 }
4146 pthread_mutex_unlock(&registry->lock);
4147 }
4148
4149 end:
4150 rcu_read_unlock();
4151 return ret;
4152 }
4153
4154 /*
4155 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
4156 *
4157 * Ask the consumer to truncate the existing metadata file(s) and
4158 * then regenerate the metadata. Live and per-pid sessions are not
4159 * supported and return an error.
4160 *
4161 * Return 0 on success or else a LTTNG_ERR code.
4162 */
4163 int cmd_regenerate_metadata(struct ltt_session *session)
4164 {
4165 int ret;
4166
4167 assert(session);
4168
4169 ret = check_regenerate_metadata_support(session);
4170 if (ret) {
4171 goto end;
4172 }
4173
4174 if (session->kernel_session) {
4175 ret = kernctl_session_regenerate_metadata(
4176 session->kernel_session->fd);
4177 if (ret < 0) {
4178 ERR("Failed to regenerate the kernel metadata");
4179 goto end;
4180 }
4181 }
4182
4183 if (session->ust_session) {
4184 ret = ust_regenerate_metadata(session->ust_session);
4185 if (ret < 0) {
4186 ERR("Failed to regenerate the UST metadata");
4187 goto end;
4188 }
4189 }
4190 DBG("Cmd metadata regenerate for session %s", session->name);
4191 ret = LTTNG_OK;
4192
4193 end:
4194 return ret;
4195 }
4196
4197 /*
4198 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
4199 *
4200 * Ask the tracer to regenerate a new statedump.
4201 *
4202 * Return 0 on success or else a LTTNG_ERR code.
4203 */
4204 int cmd_regenerate_statedump(struct ltt_session *session)
4205 {
4206 int ret;
4207
4208 assert(session);
4209
4210 if (!session->active) {
4211 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4212 goto end;
4213 }
4214
4215 if (session->kernel_session) {
4216 ret = kernctl_session_regenerate_statedump(
4217 session->kernel_session->fd);
4218 /*
4219 * Currently, the statedump in kernel can only fail if out
4220 * of memory.
4221 */
4222 if (ret < 0) {
4223 if (ret == -ENOMEM) {
4224 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
4225 } else {
4226 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4227 }
4228 ERR("Failed to regenerate the kernel statedump");
4229 goto end;
4230 }
4231 }
4232
4233 if (session->ust_session) {
4234 ret = ust_app_regenerate_statedump_all(session->ust_session);
4235 /*
4236 * Currently, the statedump in UST always returns 0.
4237 */
4238 if (ret < 0) {
4239 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4240 ERR("Failed to regenerate the UST statedump");
4241 goto end;
4242 }
4243 }
4244 DBG("Cmd regenerate statedump for session %s", session->name);
4245 ret = LTTNG_OK;
4246
4247 end:
4248 return ret;
4249 }
4250
4251 int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
4252 struct notification_thread_handle *notification_thread)
4253 {
4254 int ret;
4255 size_t trigger_len;
4256 ssize_t sock_recv_len;
4257 struct lttng_trigger *trigger = NULL;
4258 struct lttng_buffer_view view;
4259 struct lttng_dynamic_buffer trigger_buffer;
4260
4261 lttng_dynamic_buffer_init(&trigger_buffer);
4262 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
4263 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
4264 if (ret) {
4265 ret = LTTNG_ERR_NOMEM;
4266 goto end;
4267 }
4268
4269 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
4270 trigger_len);
4271 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
4272 ERR("Failed to receive \"register trigger\" command payload");
4273 /* TODO: should this be a new error enum ? */
4274 ret = LTTNG_ERR_INVALID_TRIGGER;
4275 goto end;
4276 }
4277
4278 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
4279 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
4280 trigger_len) {
4281 ERR("Invalid trigger payload received in \"register trigger\" command");
4282 ret = LTTNG_ERR_INVALID_TRIGGER;
4283 goto end;
4284 }
4285
4286 ret = notification_thread_command_register_trigger(notification_thread,
4287 trigger);
4288 /* Ownership of trigger was transferred. */
4289 trigger = NULL;
4290 end:
4291 lttng_trigger_destroy(trigger);
4292 lttng_dynamic_buffer_reset(&trigger_buffer);
4293 return ret;
4294 }
4295
4296 int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
4297 struct notification_thread_handle *notification_thread)
4298 {
4299 int ret;
4300 size_t trigger_len;
4301 ssize_t sock_recv_len;
4302 struct lttng_trigger *trigger = NULL;
4303 struct lttng_buffer_view view;
4304 struct lttng_dynamic_buffer trigger_buffer;
4305
4306 lttng_dynamic_buffer_init(&trigger_buffer);
4307 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
4308 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
4309 if (ret) {
4310 ret = LTTNG_ERR_NOMEM;
4311 goto end;
4312 }
4313
4314 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
4315 trigger_len);
4316 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
4317 ERR("Failed to receive \"unregister trigger\" command payload");
4318 /* TODO: should this be a new error enum ? */
4319 ret = LTTNG_ERR_INVALID_TRIGGER;
4320 goto end;
4321 }
4322
4323 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
4324 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
4325 trigger_len) {
4326 ERR("Invalid trigger payload received in \"unregister trigger\" command");
4327 ret = LTTNG_ERR_INVALID_TRIGGER;
4328 goto end;
4329 }
4330
4331 ret = notification_thread_command_unregister_trigger(notification_thread,
4332 trigger);
4333 end:
4334 lttng_trigger_destroy(trigger);
4335 lttng_dynamic_buffer_reset(&trigger_buffer);
4336 return ret;
4337 }
4338
4339 /*
4340 * Send relayd sockets from snapshot output to consumer. Ignore request if the
4341 * snapshot output is *not* set with a remote destination.
4342 *
4343 * Return LTTNG_OK on success or a LTTNG_ERR code.
4344 */
4345 static enum lttng_error_code set_relayd_for_snapshot(
4346 struct consumer_output *output,
4347 const struct ltt_session *session)
4348 {
4349 enum lttng_error_code status = LTTNG_OK;
4350 struct lttng_ht_iter iter;
4351 struct consumer_socket *socket;
4352 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
4353 const char *base_path;
4354
4355 assert(output);
4356 assert(session);
4357
4358 DBG2("Set relayd object from snapshot output");
4359
4360 if (session->current_trace_chunk) {
4361 enum lttng_trace_chunk_status chunk_status =
4362 lttng_trace_chunk_get_id(
4363 session->current_trace_chunk,
4364 &current_chunk_id.value);
4365
4366 if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) {
4367 current_chunk_id.is_set = true;
4368 } else {
4369 ERR("Failed to get current trace chunk id");
4370 status = LTTNG_ERR_UNK;
4371 goto error;
4372 }
4373 }
4374
4375 /* Ignore if snapshot consumer output is not network. */
4376 if (output->type != CONSUMER_DST_NET) {
4377 goto error;
4378 }
4379
4380 /*
4381 * The snapshot record URI base path overrides the session
4382 * base path.
4383 */
4384 if (output->dst.net.control.subdir[0] != '\0') {
4385 base_path = output->dst.net.control.subdir;
4386 } else {
4387 base_path = session->base_path;
4388 }
4389
4390 /*
4391 * For each consumer socket, create and send the relayd object of the
4392 * snapshot output.
4393 */
4394 rcu_read_lock();
4395 cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
4396 socket, node.node) {
4397 pthread_mutex_lock(socket->lock);
4398 status = send_consumer_relayd_sockets(0, session->id,
4399 output, socket,
4400 session->name, session->hostname,
4401 base_path,
4402 session->live_timer,
4403 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
4404 session->creation_time,
4405 session->name_contains_creation_time);
4406 pthread_mutex_unlock(socket->lock);
4407 if (status != LTTNG_OK) {
4408 rcu_read_unlock();
4409 goto error;
4410 }
4411 }
4412 rcu_read_unlock();
4413
4414 error:
4415 return status;
4416 }
4417
4418 /*
4419 * Record a kernel snapshot.
4420 *
4421 * Return LTTNG_OK on success or a LTTNG_ERR code.
4422 */
4423 static enum lttng_error_code record_kernel_snapshot(
4424 struct ltt_kernel_session *ksess,
4425 const struct consumer_output *output,
4426 const struct ltt_session *session,
4427 int wait, uint64_t nb_packets_per_stream)
4428 {
4429 enum lttng_error_code status;
4430
4431 assert(ksess);
4432 assert(output);
4433 assert(session);
4434
4435 status = kernel_snapshot_record(
4436 ksess, output, wait, nb_packets_per_stream);
4437 return status;
4438 }
4439
4440 /*
4441 * Record a UST snapshot.
4442 *
4443 * Returns LTTNG_OK on success or a LTTNG_ERR error code.
4444 */
4445 static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
4446 const struct consumer_output *output,
4447 const struct ltt_session *session,
4448 int wait, uint64_t nb_packets_per_stream)
4449 {
4450 enum lttng_error_code status;
4451
4452 assert(usess);
4453 assert(output);
4454 assert(session);
4455
4456 status = ust_app_snapshot_record(
4457 usess, output, wait, nb_packets_per_stream);
4458 return status;
4459 }
4460
4461 static
4462 uint64_t get_session_size_one_more_packet_per_stream(
4463 const struct ltt_session *session, uint64_t cur_nr_packets)
4464 {
4465 uint64_t tot_size = 0;
4466
4467 if (session->kernel_session) {
4468 struct ltt_kernel_channel *chan;
4469 const struct ltt_kernel_session *ksess =
4470 session->kernel_session;
4471
4472 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
4473 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
4474 /*
4475 * Don't take channel into account if we
4476 * already grab all its packets.
4477 */
4478 continue;
4479 }
4480 tot_size += chan->channel->attr.subbuf_size
4481 * chan->stream_count;
4482 }
4483 }
4484
4485 if (session->ust_session) {
4486 const struct ltt_ust_session *usess = session->ust_session;
4487
4488 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
4489 cur_nr_packets);
4490 }
4491
4492 return tot_size;
4493 }
4494
4495 /*
4496 * Calculate the number of packets we can grab from each stream that
4497 * fits within the overall snapshot max size.
4498 *
4499 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
4500 * the number of packets per stream.
4501 *
4502 * TODO: this approach is not perfect: we consider the worse case
4503 * (packet filling the sub-buffers) as an upper bound, but we could do
4504 * better if we do this calculation while we actually grab the packet
4505 * content: we would know how much padding we don't actually store into
4506 * the file.
4507 *
4508 * This algorithm is currently bounded by the number of packets per
4509 * stream.
4510 *
4511 * Since we call this algorithm before actually grabbing the data, it's
4512 * an approximation: for instance, applications could appear/disappear
4513 * in between this call and actually grabbing data.
4514 */
4515 static
4516 int64_t get_session_nb_packets_per_stream(const struct ltt_session *session,
4517 uint64_t max_size)
4518 {
4519 int64_t size_left;
4520 uint64_t cur_nb_packets = 0;
4521
4522 if (!max_size) {
4523 return 0; /* Infinite */
4524 }
4525
4526 size_left = max_size;
4527 for (;;) {
4528 uint64_t one_more_packet_tot_size;
4529
4530 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(
4531 session, cur_nb_packets);
4532 if (!one_more_packet_tot_size) {
4533 /* We are already grabbing all packets. */
4534 break;
4535 }
4536 size_left -= one_more_packet_tot_size;
4537 if (size_left < 0) {
4538 break;
4539 }
4540 cur_nb_packets++;
4541 }
4542 if (!cur_nb_packets && size_left != max_size) {
4543 /* Not enough room to grab one packet of each stream, error. */
4544 return -1;
4545 }
4546 return cur_nb_packets;
4547 }
4548
4549 static
4550 enum lttng_error_code snapshot_record(struct ltt_session *session,
4551 const struct snapshot_output *snapshot_output, int wait)
4552 {
4553 int64_t nb_packets_per_stream;
4554 char snapshot_chunk_name[LTTNG_NAME_MAX];
4555 int ret;
4556 enum lttng_error_code ret_code = LTTNG_OK;
4557 struct lttng_trace_chunk *snapshot_trace_chunk;
4558 struct consumer_output *original_ust_consumer_output = NULL;
4559 struct consumer_output *original_kernel_consumer_output = NULL;
4560 struct consumer_output *snapshot_ust_consumer_output = NULL;
4561 struct consumer_output *snapshot_kernel_consumer_output = NULL;
4562
4563 ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
4564 "%s-%s-%" PRIu64,
4565 snapshot_output->name,
4566 snapshot_output->datetime,
4567 snapshot_output->nb_snapshot);
4568 if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) {
4569 ERR("Failed to format snapshot name");
4570 ret_code = LTTNG_ERR_INVALID;
4571 goto error;
4572 }
4573 DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"",
4574 snapshot_output->name, session->name,
4575 snapshot_chunk_name);
4576 if (!session->kernel_session && !session->ust_session) {
4577 ERR("Failed to record snapshot as no channels exist");
4578 ret_code = LTTNG_ERR_NO_CHANNEL;
4579 goto error;
4580 }
4581
4582 if (session->kernel_session) {
4583 original_kernel_consumer_output =
4584 session->kernel_session->consumer;
4585 snapshot_kernel_consumer_output =
4586 consumer_copy_output(snapshot_output->consumer);
4587 strcpy(snapshot_kernel_consumer_output->chunk_path,
4588 snapshot_chunk_name);
4589 ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
4590 original_kernel_consumer_output);
4591 if (ret < 0) {
4592 ERR("Failed to copy consumer sockets from snapshot output configuration");
4593 ret_code = LTTNG_ERR_NOMEM;
4594 goto error;
4595 }
4596 ret_code = set_relayd_for_snapshot(
4597 snapshot_kernel_consumer_output, session);
4598 if (ret_code != LTTNG_OK) {
4599 ERR("Failed to setup relay daemon for kernel tracer snapshot");
4600 goto error;
4601 }
4602 session->kernel_session->consumer =
4603 snapshot_kernel_consumer_output;
4604 }
4605 if (session->ust_session) {
4606 original_ust_consumer_output = session->ust_session->consumer;
4607 snapshot_ust_consumer_output =
4608 consumer_copy_output(snapshot_output->consumer);
4609 strcpy(snapshot_ust_consumer_output->chunk_path,
4610 snapshot_chunk_name);
4611 ret = consumer_copy_sockets(snapshot_ust_consumer_output,
4612 original_ust_consumer_output);
4613 if (ret < 0) {
4614 ERR("Failed to copy consumer sockets from snapshot output configuration");
4615 ret_code = LTTNG_ERR_NOMEM;
4616 goto error;
4617 }
4618 ret_code = set_relayd_for_snapshot(
4619 snapshot_ust_consumer_output, session);
4620 if (ret_code != LTTNG_OK) {
4621 ERR("Failed to setup relay daemon for userspace tracer snapshot");
4622 goto error;
4623 }
4624 session->ust_session->consumer =
4625 snapshot_ust_consumer_output;
4626 }
4627
4628 snapshot_trace_chunk = session_create_new_trace_chunk(session,
4629 snapshot_kernel_consumer_output ?:
4630 snapshot_ust_consumer_output,
4631 consumer_output_get_base_path(
4632 snapshot_output->consumer),
4633 snapshot_chunk_name);
4634 if (!snapshot_trace_chunk) {
4635 ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"",
4636 session->name);
4637 ret_code = LTTNG_ERR_CREATE_DIR_FAIL;
4638 goto error;
4639 }
4640 assert(!session->current_trace_chunk);
4641 ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL);
4642 lttng_trace_chunk_put(snapshot_trace_chunk);
4643 snapshot_trace_chunk = NULL;
4644 if (ret) {
4645 ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"",
4646 session->name);
4647 ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
4648 goto error;
4649 }
4650
4651 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4652 snapshot_output->max_size);
4653 if (nb_packets_per_stream < 0) {
4654 ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
4655 goto error_close_trace_chunk;
4656 }
4657
4658 if (session->kernel_session) {
4659 ret_code = record_kernel_snapshot(session->kernel_session,
4660 snapshot_kernel_consumer_output, session,
4661 wait, nb_packets_per_stream);
4662 if (ret_code != LTTNG_OK) {
4663 goto error_close_trace_chunk;
4664 }
4665 }
4666
4667 if (session->ust_session) {
4668 ret_code = record_ust_snapshot(session->ust_session,
4669 snapshot_ust_consumer_output, session,
4670 wait, nb_packets_per_stream);
4671 if (ret_code != LTTNG_OK) {
4672 goto error_close_trace_chunk;
4673 }
4674 }
4675 error_close_trace_chunk:
4676 if (session_close_trace_chunk(
4677 session, session->current_trace_chunk, NULL, NULL)) {
4678 /*
4679 * Don't goto end; make sure the chunk is closed for the session
4680 * to allow future snapshots.
4681 */
4682 ERR("Failed to close snapshot trace chunk of session \"%s\"",
4683 session->name);
4684 ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
4685 }
4686 if (session_set_trace_chunk(session, NULL, NULL)) {
4687 ERR("Failed to release the current trace chunk of session \"%s\"",
4688 session->name);
4689 ret_code = LTTNG_ERR_UNK;
4690 }
4691 error:
4692 if (original_ust_consumer_output) {
4693 session->ust_session->consumer = original_ust_consumer_output;
4694 }
4695 if (original_kernel_consumer_output) {
4696 session->kernel_session->consumer =
4697 original_kernel_consumer_output;
4698 }
4699 consumer_output_put(snapshot_ust_consumer_output);
4700 consumer_output_put(snapshot_kernel_consumer_output);
4701 return ret_code;
4702 }
4703
4704 /*
4705 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
4706 *
4707 * The wait parameter is ignored so this call always wait for the snapshot to
4708 * complete before returning.
4709 *
4710 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4711 */
4712 int cmd_snapshot_record(struct ltt_session *session,
4713 const struct lttng_snapshot_output *output, int wait)
4714 {
4715 enum lttng_error_code cmd_ret = LTTNG_OK;
4716 int ret;
4717 unsigned int snapshot_success = 0;
4718 char datetime[16];
4719 struct snapshot_output *tmp_output = NULL;
4720
4721 assert(session);
4722 assert(output);
4723
4724 DBG("Cmd snapshot record for session %s", session->name);
4725
4726 /* Get the datetime for the snapshot output directory. */
4727 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
4728 sizeof(datetime));
4729 if (!ret) {
4730 cmd_ret = LTTNG_ERR_INVALID;
4731 goto error;
4732 }
4733
4734 /*
4735 * Permission denied to create an output if the session is not
4736 * set in no output mode.
4737 */
4738 if (session->output_traces) {
4739 cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
4740 goto error;
4741 }
4742
4743 /* The session needs to be started at least once. */
4744 if (!session->has_been_started) {
4745 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
4746 goto error;
4747 }
4748
4749 /* Use temporary output for the session. */
4750 if (*output->ctrl_url != '\0') {
4751 tmp_output = snapshot_output_alloc();
4752 if (!tmp_output) {
4753 cmd_ret = LTTNG_ERR_NOMEM;
4754 goto error;
4755 }
4756
4757 ret = snapshot_output_init(session, output->max_size,
4758 output->name,
4759 output->ctrl_url, output->data_url,
4760 session->consumer,
4761 tmp_output, NULL);
4762 if (ret < 0) {
4763 if (ret == -ENOMEM) {
4764 cmd_ret = LTTNG_ERR_NOMEM;
4765 } else {
4766 cmd_ret = LTTNG_ERR_INVALID;
4767 }
4768 goto error;
4769 }
4770 /* Use the global session count for the temporary snapshot. */
4771 tmp_output->nb_snapshot = session->snapshot.nb_snapshot;
4772
4773 /* Use the global datetime */
4774 memcpy(tmp_output->datetime, datetime, sizeof(datetime));
4775 cmd_ret = snapshot_record(session, tmp_output, wait);
4776 if (cmd_ret != LTTNG_OK) {
4777 goto error;
4778 }
4779 snapshot_success = 1;
4780 } else {
4781 struct snapshot_output *sout;
4782 struct lttng_ht_iter iter;
4783
4784 rcu_read_lock();
4785 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
4786 &iter.iter, sout, node.node) {
4787 struct snapshot_output output_copy;
4788
4789 /*
4790 * Make a local copy of the output and override output
4791 * parameters with those provided as part of the
4792 * command.
4793 */
4794 memcpy(&output_copy, sout, sizeof(output_copy));
4795
4796 if (output->max_size != (uint64_t) -1ULL) {
4797 output_copy.max_size = output->max_size;
4798 }
4799
4800 output_copy.nb_snapshot = session->snapshot.nb_snapshot;
4801 memcpy(output_copy.datetime, datetime,
4802 sizeof(datetime));
4803
4804 /* Use temporary name. */
4805 if (*output->name != '\0') {
4806 if (lttng_strncpy(output_copy.name,
4807 output->name,
4808 sizeof(output_copy.name))) {
4809 cmd_ret = LTTNG_ERR_INVALID;
4810 rcu_read_unlock();
4811 goto error;
4812 }
4813 }
4814
4815 cmd_ret = snapshot_record(session, &output_copy, wait);
4816 if (cmd_ret != LTTNG_OK) {
4817 rcu_read_unlock();
4818 goto error;
4819 }
4820 snapshot_success = 1;
4821 }
4822 rcu_read_unlock();
4823 }
4824
4825 if (snapshot_success) {
4826 session->snapshot.nb_snapshot++;
4827 } else {
4828 cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL;
4829 }
4830
4831 error:
4832 if (tmp_output) {
4833 snapshot_output_destroy(tmp_output);
4834 }
4835 return cmd_ret;
4836 }
4837
4838 /*
4839 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
4840 */
4841 int cmd_set_session_shm_path(struct ltt_session *session,
4842 const char *shm_path)
4843 {
4844 /* Safety net */
4845 assert(session);
4846
4847 /*
4848 * Can only set shm path before session is started.
4849 */
4850 if (session->has_been_started) {
4851 return LTTNG_ERR_SESSION_STARTED;
4852 }
4853
4854 strncpy(session->shm_path, shm_path,
4855 sizeof(session->shm_path));
4856 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
4857
4858 return 0;
4859 }
4860
4861 /*
4862 * Command LTTNG_ROTATE_SESSION from the lttng-ctl library.
4863 *
4864 * Ask the consumer to rotate the session output directory.
4865 * The session lock must be held.
4866 *
4867 * Returns LTTNG_OK on success or else a negative LTTng error code.
4868 */
4869 int cmd_rotate_session(struct ltt_session *session,
4870 struct lttng_rotate_session_return *rotate_return,
4871 bool quiet_rotation)
4872 {
4873 int ret;
4874 uint64_t ongoing_rotation_chunk_id;
4875 enum lttng_error_code cmd_ret = LTTNG_OK;
4876 struct lttng_trace_chunk *chunk_being_archived = NULL;
4877 struct lttng_trace_chunk *new_trace_chunk = NULL;
4878 enum lttng_trace_chunk_status chunk_status;
4879 bool failed_to_rotate = false;
4880 enum lttng_error_code rotation_fail_code = LTTNG_OK;
4881
4882 assert(session);
4883
4884 if (!session->has_been_started) {
4885 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
4886 goto end;
4887 }
4888
4889 /*
4890 * Explicit rotation is not supported for live sessions.
4891 * However, live sessions can perform a quiet rotation on
4892 * destroy.
4893 * Rotation is not supported for snapshot traces (no output).
4894 */
4895 if ((!quiet_rotation && session->live_timer) ||
4896 !session->output_traces) {
4897 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
4898 goto end;
4899 }
4900
4901 /* Unsupported feature in lttng-relayd before 2.11. */
4902 if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET &&
4903 (session->consumer->relay_major_version == 2 &&
4904 session->consumer->relay_minor_version < 11)) {
4905 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
4906 goto end;
4907 }
4908
4909 /* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */
4910 if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) {
4911 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL;
4912 goto end;
4913 }
4914
4915 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
4916 DBG("Refusing to launch a rotation; a rotation is already in progress for session %s",
4917 session->name);
4918 cmd_ret = LTTNG_ERR_ROTATION_PENDING;
4919 goto end;
4920 }
4921
4922 /*
4923 * After a stop, we only allow one rotation to occur, the other ones are
4924 * useless until a new start.
4925 */
4926 if (session->rotated_after_last_stop) {
4927 DBG("Session \"%s\" was already rotated after stop, refusing rotation",
4928 session->name);
4929 cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
4930 goto end;
4931 }
4932 if (session->active) {
4933 new_trace_chunk = session_create_new_trace_chunk(session, NULL,
4934 NULL, NULL);
4935 if (!new_trace_chunk) {
4936 cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
4937 goto error;
4938 }
4939 }
4940
4941 /*
4942 * The current trace chunk becomes the chunk being archived.
4943 *
4944 * After this point, "chunk_being_archived" must absolutely
4945 * be closed on the consumer(s), otherwise it will never be
4946 * cleaned-up, which will result in a leak.
4947 */
4948 ret = session_set_trace_chunk(session, new_trace_chunk,
4949 &chunk_being_archived);
4950 if (ret) {
4951 cmd_ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
4952 goto error;
4953 }
4954
4955 if (session->kernel_session) {
4956 cmd_ret = kernel_rotate_session(session);
4957 if (cmd_ret != LTTNG_OK) {
4958 failed_to_rotate = true;
4959 rotation_fail_code = cmd_ret;
4960 }
4961 }
4962 if (session->ust_session) {
4963 cmd_ret = ust_app_rotate_session(session);
4964 if (cmd_ret != LTTNG_OK) {
4965 failed_to_rotate = true;
4966 rotation_fail_code = cmd_ret;
4967 }
4968 }
4969
4970 if (!session->active) {
4971 session->rotated_after_last_stop = true;
4972 }
4973
4974 if (!chunk_being_archived) {
4975 DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check",
4976 session->name);
4977 if (failed_to_rotate) {
4978 cmd_ret = rotation_fail_code;
4979 goto error;
4980 }
4981 cmd_ret = LTTNG_OK;
4982 goto end;
4983 }
4984
4985 session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
4986 chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
4987 &ongoing_rotation_chunk_id);
4988 assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
4989
4990 ret = session_close_trace_chunk(session, chunk_being_archived,
4991 quiet_rotation ?
4992 NULL :
4993 &((enum lttng_trace_chunk_command_type){
4994 LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}),
4995 session->last_chunk_path);
4996 if (ret) {
4997 cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
4998 goto error;
4999 }
5000
5001 if (failed_to_rotate) {
5002 cmd_ret = rotation_fail_code;
5003 goto error;
5004 }
5005
5006 session->quiet_rotation = quiet_rotation;
5007 ret = timer_session_rotation_pending_check_start(session,
5008 DEFAULT_ROTATE_PENDING_TIMER);
5009 if (ret) {
5010 cmd_ret = LTTNG_ERR_UNK;
5011 goto error;
5012 }
5013
5014 if (rotate_return) {
5015 rotate_return->rotation_id = ongoing_rotation_chunk_id;
5016 }
5017
5018 session->chunk_being_archived = chunk_being_archived;
5019 chunk_being_archived = NULL;
5020 if (!quiet_rotation) {
5021 ret = notification_thread_command_session_rotation_ongoing(
5022 notification_thread_handle,
5023 session->name, session->uid, session->gid,
5024 ongoing_rotation_chunk_id);
5025 if (ret != LTTNG_OK) {
5026 ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
5027 session->name);
5028 cmd_ret = ret;
5029 }
5030 }
5031
5032 DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent",
5033 session->name, ongoing_rotation_chunk_id);
5034 end:
5035 lttng_trace_chunk_put(new_trace_chunk);
5036 lttng_trace_chunk_put(chunk_being_archived);
5037 ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret);
5038 return ret;
5039 error:
5040 if (session_reset_rotation_state(session,
5041 LTTNG_ROTATION_STATE_ERROR)) {
5042 ERR("Failed to reset rotation state of session \"%s\"",
5043 session->name);
5044 }
5045 goto end;
5046 }
5047
5048 /*
5049 * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library.
5050 *
5051 * Check if the session has finished its rotation.
5052 *
5053 * Return LTTNG_OK on success or else an LTTNG_ERR code.
5054 */
5055 int cmd_rotate_get_info(struct ltt_session *session,
5056 struct lttng_rotation_get_info_return *info_return,
5057 uint64_t rotation_id)
5058 {
5059 enum lttng_error_code cmd_ret = LTTNG_OK;
5060 enum lttng_rotation_state rotation_state;
5061
5062 DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
5063 session->most_recent_chunk_id.value);
5064
5065 if (session->chunk_being_archived) {
5066 enum lttng_trace_chunk_status chunk_status;
5067 uint64_t chunk_id;
5068
5069 chunk_status = lttng_trace_chunk_get_id(
5070 session->chunk_being_archived,
5071 &chunk_id);
5072 assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
5073
5074 rotation_state = rotation_id == chunk_id ?
5075 LTTNG_ROTATION_STATE_ONGOING :
5076 LTTNG_ROTATION_STATE_EXPIRED;
5077 } else {
5078 if (session->last_archived_chunk_id.is_set &&
5079 rotation_id != session->last_archived_chunk_id.value) {
5080 rotation_state = LTTNG_ROTATION_STATE_EXPIRED;
5081 } else {
5082 rotation_state = session->rotation_state;
5083 }
5084 }
5085
5086 switch (rotation_state) {
5087 case LTTNG_ROTATION_STATE_NO_ROTATION:
5088 DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"",
5089 session->name);
5090 goto end;
5091 case LTTNG_ROTATION_STATE_EXPIRED:
5092 DBG("Reporting that the rotation state of rotation id %" PRIu64 " of session \"%s\" has expired",
5093 rotation_id, session->name);
5094 break;
5095 case LTTNG_ROTATION_STATE_ONGOING:
5096 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending",
5097 rotation_id, session->name);
5098 break;
5099 case LTTNG_ROTATION_STATE_COMPLETED:
5100 {
5101 int fmt_ret;
5102 char *chunk_path;
5103 char *current_tracing_path_reply;
5104 size_t current_tracing_path_reply_len;
5105
5106 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed",
5107 rotation_id, session->name);
5108
5109 switch (session_get_consumer_destination_type(session)) {
5110 case CONSUMER_DST_LOCAL:
5111 current_tracing_path_reply =
5112 info_return->location.local.absolute_path;
5113 current_tracing_path_reply_len =
5114 sizeof(info_return->location.local.absolute_path);
5115 info_return->location_type =
5116 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
5117 fmt_ret = asprintf(&chunk_path,
5118 "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
5119 session_get_base_path(session),
5120 session->last_archived_chunk_name);
5121 if (fmt_ret == -1) {
5122 PERROR("Failed to format the path of the last archived trace chunk");
5123 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5124 cmd_ret = LTTNG_ERR_UNK;
5125 goto end;
5126 }
5127 break;
5128 case CONSUMER_DST_NET:
5129 {
5130 uint16_t ctrl_port, data_port;
5131
5132 current_tracing_path_reply =
5133 info_return->location.relay.relative_path;
5134 current_tracing_path_reply_len =
5135 sizeof(info_return->location.relay.relative_path);
5136 /* Currently the only supported relay protocol. */
5137 info_return->location.relay.protocol =
5138 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
5139
5140 fmt_ret = lttng_strncpy(info_return->location.relay.host,
5141 session_get_net_consumer_hostname(session),
5142 sizeof(info_return->location.relay.host));
5143 if (fmt_ret) {
5144 ERR("Failed to copy host name to rotate_get_info reply");
5145 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5146 cmd_ret = LTTNG_ERR_SET_URL;
5147 goto end;
5148 }
5149
5150 session_get_net_consumer_ports(session, &ctrl_port, &data_port);
5151 info_return->location.relay.ports.control = ctrl_port;
5152 info_return->location.relay.ports.data = data_port;
5153 info_return->location_type =
5154 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
5155 chunk_path = strdup(session->last_chunk_path);
5156 if (!chunk_path) {
5157 ERR("Failed to allocate the path of the last archived trace chunk");
5158 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5159 cmd_ret = LTTNG_ERR_UNK;
5160 goto end;
5161 }
5162 break;
5163 }
5164 default:
5165 abort();
5166 }
5167
5168 fmt_ret = lttng_strncpy(current_tracing_path_reply,
5169 chunk_path, current_tracing_path_reply_len);
5170 free(chunk_path);
5171 if (fmt_ret) {
5172 ERR("Failed to copy path of the last archived trace chunk to rotate_get_info reply");
5173 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5174 cmd_ret = LTTNG_ERR_UNK;
5175 goto end;
5176 }
5177
5178 break;
5179 }
5180 case LTTNG_ROTATION_STATE_ERROR:
5181 DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"",
5182 rotation_id, session->name);
5183 break;
5184 default:
5185 abort();
5186 }
5187
5188 cmd_ret = LTTNG_OK;
5189 end:
5190 info_return->status = (int32_t) rotation_state;
5191 return cmd_ret;
5192 }
5193
5194 /*
5195 * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library.
5196 *
5197 * Configure the automatic rotation parameters.
5198 * 'activate' to true means activate the rotation schedule type with 'new_value'.
5199 * 'activate' to false means deactivate the rotation schedule and validate that
5200 * 'new_value' has the same value as the currently active value.
5201 *
5202 * Return 0 on success or else a positive LTTNG_ERR code.
5203 */
5204 int cmd_rotation_set_schedule(struct ltt_session *session,
5205 bool activate, enum lttng_rotation_schedule_type schedule_type,
5206 uint64_t new_value,
5207 struct notification_thread_handle *notification_thread_handle)
5208 {
5209 int ret;
5210 uint64_t *parameter_value;
5211
5212 assert(session);
5213
5214 DBG("Cmd rotate set schedule session %s", session->name);
5215
5216 if (session->live_timer || !session->output_traces) {
5217 DBG("Failing ROTATION_SET_SCHEDULE command as the rotation feature is not available for this session");
5218 ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
5219 goto end;
5220 }
5221
5222 switch (schedule_type) {
5223 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5224 parameter_value = &session->rotate_size;
5225 break;
5226 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5227 parameter_value = &session->rotate_timer_period;
5228 if (new_value >= UINT_MAX) {
5229 DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)",
5230 new_value, UINT_MAX);
5231 ret = LTTNG_ERR_INVALID;
5232 goto end;
5233 }
5234 break;
5235 default:
5236 WARN("Failing ROTATION_SET_SCHEDULE command on unknown schedule type");
5237 ret = LTTNG_ERR_INVALID;
5238 goto end;
5239 }
5240
5241 /* Improper use of the API. */
5242 if (new_value == -1ULL) {
5243 WARN("Failing ROTATION_SET_SCHEDULE command as the value requested is -1");
5244 ret = LTTNG_ERR_INVALID;
5245 goto end;
5246 }
5247
5248 /*
5249 * As indicated in struct ltt_session's comments, a value of == 0 means
5250 * this schedule rotation type is not in use.
5251 *
5252 * Reject the command if we were asked to activate a schedule that was
5253 * already active.
5254 */
5255 if (activate && *parameter_value != 0) {
5256 DBG("Failing ROTATION_SET_SCHEDULE (activate) command as the schedule is already active");
5257 ret = LTTNG_ERR_ROTATION_SCHEDULE_SET;
5258 goto end;
5259 }
5260
5261 /*
5262 * Reject the command if we were asked to deactivate a schedule that was
5263 * not active.
5264 */
5265 if (!activate && *parameter_value == 0) {
5266 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as the schedule is already inactive");
5267 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
5268 goto end;
5269 }
5270
5271 /*
5272 * Reject the command if we were asked to deactivate a schedule that
5273 * doesn't exist.
5274 */
5275 if (!activate && *parameter_value != new_value) {
5276 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as an inexistant schedule was provided");
5277 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
5278 goto end;
5279 }
5280
5281 *parameter_value = activate ? new_value : 0;
5282
5283 switch (schedule_type) {
5284 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5285 if (activate && session->active) {
5286 /*
5287 * Only start the timer if the session is active,
5288 * otherwise it will be started when the session starts.
5289 */
5290 ret = timer_session_rotation_schedule_timer_start(
5291 session, new_value);
5292 if (ret) {
5293 ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command");
5294 ret = LTTNG_ERR_UNK;
5295 goto end;
5296 }
5297 } else {
5298 ret = timer_session_rotation_schedule_timer_stop(
5299 session);
5300 if (ret) {
5301 ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command");
5302 ret = LTTNG_ERR_UNK;
5303 goto end;
5304 }
5305 }
5306 break;
5307 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5308 if (activate) {
5309 ret = subscribe_session_consumed_size_rotation(session,
5310 new_value, notification_thread_handle);
5311 if (ret) {
5312 ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command");
5313 ret = LTTNG_ERR_UNK;
5314 goto end;
5315 }
5316 } else {
5317 ret = unsubscribe_session_consumed_size_rotation(session,
5318 notification_thread_handle);
5319 if (ret) {
5320 ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command");
5321 ret = LTTNG_ERR_UNK;
5322 goto end;
5323 }
5324
5325 }
5326 break;
5327 default:
5328 /* Would have been caught before. */
5329 abort();
5330 }
5331
5332 ret = LTTNG_OK;
5333
5334 goto end;
5335
5336 end:
5337 return ret;
5338 }
5339
5340 /* Wait for a given path to be removed before continuing. */
5341 static enum lttng_error_code wait_on_path(void *path_data)
5342 {
5343 const char *shm_path = path_data;
5344
5345 DBG("Waiting for the shm path at %s to be removed before completing session destruction",
5346 shm_path);
5347 while (true) {
5348 int ret;
5349 struct stat st;
5350
5351 ret = stat(shm_path, &st);
5352 if (ret) {
5353 if (errno != ENOENT) {
5354 PERROR("stat() returned an error while checking for the existence of the shm path");
5355 } else {
5356 DBG("shm path no longer exists, completing the destruction of session");
5357 }
5358 break;
5359 } else {
5360 if (!S_ISDIR(st.st_mode)) {
5361 ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal",
5362 shm_path);
5363 break;
5364 }
5365 }
5366 usleep(SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US);
5367 }
5368 return LTTNG_OK;
5369 }
5370
5371 /*
5372 * Returns a pointer to a handler to run on completion of a command.
5373 * Returns NULL if no handler has to be run for the last command executed.
5374 */
5375 const struct cmd_completion_handler *cmd_pop_completion_handler(void)
5376 {
5377 struct cmd_completion_handler *handler = current_completion_handler;
5378
5379 current_completion_handler = NULL;
5380 return handler;
5381 }
5382
5383 /*
5384 * Init command subsystem.
5385 */
5386 void cmd_init(void)
5387 {
5388 /*
5389 * Set network sequence index to 1 for streams to match a relayd
5390 * socket on the consumer side.
5391 */
5392 pthread_mutex_lock(&relayd_net_seq_idx_lock);
5393 relayd_net_seq_idx = 1;
5394 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
5395
5396 DBG("Command subsystem initialized");
5397 }
LTTng 2.0 tools and control repository
This page took 0.210157 seconds and 4 git commands to generate.