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