projects / lttng-tools.git / blob
? search:


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