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