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