projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Create the session and domain directories on start
[lttng-tools.git] / src / bin / lttng-sessiond / cmd.c
1 /*
2 * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License, version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 51
16 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #define _LGPL_SOURCE
20 #include <assert.h>
21 #include <inttypes.h>
22 #include <urcu/list.h>
23 #include <urcu/uatomic.h>
24
25 #include <common/defaults.h>
26 #include <common/common.h>
27 #include <common/sessiond-comm/sessiond-comm.h>
28 #include <common/relayd/relayd.h>
29 #include <common/utils.h>
30 #include <common/compat/string.h>
31 #include <common/kernel-ctl/kernel-ctl.h>
32 #include <common/dynamic-buffer.h>
33 #include <common/buffer-view.h>
34 #include <lttng/trigger/trigger-internal.h>
35 #include <lttng/condition/condition.h>
36 #include <lttng/action/action.h>
37 #include <lttng/channel.h>
38 #include <lttng/channel-internal.h>
39 #include <common/string-utils/string-utils.h>
40
41 #include "channel.h"
42 #include "consumer.h"
43 #include "event.h"
44 #include "health-sessiond.h"
45 #include "kernel.h"
46 #include "kernel-consumer.h"
47 #include "lttng-sessiond.h"
48 #include "utils.h"
49 #include "syscall.h"
50 #include "agent.h"
51 #include "buffer-registry.h"
52 #include "notification-thread.h"
53 #include "notification-thread-commands.h"
54
55 #include "cmd.h"
56
57 /*
58 * Used to keep a unique index for each relayd socket created where this value
59 * is associated with streams on the consumer so it can match the right relayd
60 * to send to. It must be accessed with the relayd_net_seq_idx_lock
61 * held.
62 */
63 static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
64 static uint64_t relayd_net_seq_idx;
65
66 static int validate_ust_event_name(const char *);
67 static int cmd_enable_event_internal(struct ltt_session *session,
68 struct lttng_domain *domain,
69 char *channel_name, struct lttng_event *event,
70 char *filter_expression,
71 struct lttng_filter_bytecode *filter,
72 struct lttng_event_exclusion *exclusion,
73 int wpipe);
74
75 /*
76 * Create a session path used by list_lttng_sessions for the case that the
77 * session consumer is on the network.
78 */
79 static int build_network_session_path(char *dst, size_t size,
80 struct ltt_session *session)
81 {
82 int ret, kdata_port, udata_port;
83 struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
84 char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
85
86 assert(session);
87 assert(dst);
88
89 memset(tmp_urls, 0, sizeof(tmp_urls));
90 memset(tmp_uurl, 0, sizeof(tmp_uurl));
91
92 kdata_port = udata_port = DEFAULT_NETWORK_DATA_PORT;
93
94 if (session->kernel_session && session->kernel_session->consumer) {
95 kuri = &session->kernel_session->consumer->dst.net.control;
96 kdata_port = session->kernel_session->consumer->dst.net.data.port;
97 }
98
99 if (session->ust_session && session->ust_session->consumer) {
100 uuri = &session->ust_session->consumer->dst.net.control;
101 udata_port = session->ust_session->consumer->dst.net.data.port;
102 }
103
104 if (uuri == NULL && kuri == NULL) {
105 uri = &session->consumer->dst.net.control;
106 kdata_port = session->consumer->dst.net.data.port;
107 } else if (kuri && uuri) {
108 ret = uri_compare(kuri, uuri);
109 if (ret) {
110 /* Not Equal */
111 uri = kuri;
112 /* Build uuri URL string */
113 ret = uri_to_str_url(uuri, tmp_uurl, sizeof(tmp_uurl));
114 if (ret < 0) {
115 goto error;
116 }
117 } else {
118 uri = kuri;
119 }
120 } else if (kuri && uuri == NULL) {
121 uri = kuri;
122 } else if (uuri && kuri == NULL) {
123 uri = uuri;
124 }
125
126 ret = uri_to_str_url(uri, tmp_urls, sizeof(tmp_urls));
127 if (ret < 0) {
128 goto error;
129 }
130
131 /*
132 * Do we have a UST url set. If yes, this means we have both kernel and UST
133 * to print.
134 */
135 if (*tmp_uurl != '\0') {
136 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
137 tmp_urls, kdata_port, tmp_uurl, udata_port);
138 } else {
139 int dport;
140 if (kuri || (!kuri && !uuri)) {
141 dport = kdata_port;
142 } else {
143 /* No kernel URI, use the UST port. */
144 dport = udata_port;
145 }
146 ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, dport);
147 }
148
149 error:
150 return ret;
151 }
152
153 /*
154 * Get run-time attributes if the session has been started (discarded events,
155 * lost packets).
156 */
157 static int get_kernel_runtime_stats(struct ltt_session *session,
158 struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
159 uint64_t *lost_packets)
160 {
161 int ret;
162
163 if (!session->has_been_started) {
164 ret = 0;
165 *discarded_events = 0;
166 *lost_packets = 0;
167 goto end;
168 }
169
170 ret = consumer_get_discarded_events(session->id, kchan->key,
171 session->kernel_session->consumer,
172 discarded_events);
173 if (ret < 0) {
174 goto end;
175 }
176
177 ret = consumer_get_lost_packets(session->id, kchan->key,
178 session->kernel_session->consumer,
179 lost_packets);
180 if (ret < 0) {
181 goto end;
182 }
183
184 end:
185 return ret;
186 }
187
188 /*
189 * Get run-time attributes if the session has been started (discarded events,
190 * lost packets).
191 */
192 static int get_ust_runtime_stats(struct ltt_session *session,
193 struct ltt_ust_channel *uchan, uint64_t *discarded_events,
194 uint64_t *lost_packets)
195 {
196 int ret;
197 struct ltt_ust_session *usess;
198
199 if (!discarded_events || !lost_packets) {
200 ret = -1;
201 goto end;
202 }
203
204 usess = session->ust_session;
205 assert(discarded_events);
206 assert(lost_packets);
207
208 if (!usess || !session->has_been_started) {
209 *discarded_events = 0;
210 *lost_packets = 0;
211 ret = 0;
212 goto end;
213 }
214
215 if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
216 ret = ust_app_uid_get_channel_runtime_stats(usess->id,
217 &usess->buffer_reg_uid_list,
218 usess->consumer, uchan->id,
219 uchan->attr.overwrite,
220 discarded_events,
221 lost_packets);
222 } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
223 ret = ust_app_pid_get_channel_runtime_stats(usess,
224 uchan, usess->consumer,
225 uchan->attr.overwrite,
226 discarded_events,
227 lost_packets);
228 if (ret < 0) {
229 goto end;
230 }
231 *discarded_events += uchan->per_pid_closed_app_discarded;
232 *lost_packets += uchan->per_pid_closed_app_lost;
233 } else {
234 ERR("Unsupported buffer type");
235 assert(0);
236 ret = -1;
237 goto end;
238 }
239
240 end:
241 return ret;
242 }
243
244 /*
245 * Fill lttng_channel array of all channels.
246 */
247 static ssize_t list_lttng_channels(enum lttng_domain_type domain,
248 struct ltt_session *session, struct lttng_channel *channels,
249 struct lttng_channel_extended *chan_exts)
250 {
251 int i = 0, ret = 0;
252 struct ltt_kernel_channel *kchan;
253
254 DBG("Listing channels for session %s", session->name);
255
256 switch (domain) {
257 case LTTNG_DOMAIN_KERNEL:
258 /* Kernel channels */
259 if (session->kernel_session != NULL) {
260 cds_list_for_each_entry(kchan,
261 &session->kernel_session->channel_list.head, list) {
262 uint64_t discarded_events, lost_packets;
263 struct lttng_channel_extended *extended;
264
265 extended = (struct lttng_channel_extended *)
266 kchan->channel->attr.extended.ptr;
267
268 ret = get_kernel_runtime_stats(session, kchan,
269 &discarded_events, &lost_packets);
270 if (ret < 0) {
271 goto end;
272 }
273 /* Copy lttng_channel struct to array */
274 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
275 channels[i].enabled = kchan->enabled;
276 chan_exts[i].discarded_events =
277 discarded_events;
278 chan_exts[i].lost_packets = lost_packets;
279 chan_exts[i].monitor_timer_interval =
280 extended->monitor_timer_interval;
281 chan_exts[i].blocking_timeout = 0;
282 i++;
283 }
284 }
285 break;
286 case LTTNG_DOMAIN_UST:
287 {
288 struct lttng_ht_iter iter;
289 struct ltt_ust_channel *uchan;
290
291 rcu_read_lock();
292 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
293 &iter.iter, uchan, node.node) {
294 uint64_t discarded_events = 0, lost_packets = 0;
295
296 if (lttng_strncpy(channels[i].name, uchan->name,
297 LTTNG_SYMBOL_NAME_LEN)) {
298 break;
299 }
300 channels[i].attr.overwrite = uchan->attr.overwrite;
301 channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
302 channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
303 channels[i].attr.switch_timer_interval =
304 uchan->attr.switch_timer_interval;
305 channels[i].attr.read_timer_interval =
306 uchan->attr.read_timer_interval;
307 channels[i].enabled = uchan->enabled;
308 channels[i].attr.tracefile_size = uchan->tracefile_size;
309 channels[i].attr.tracefile_count = uchan->tracefile_count;
310
311 /*
312 * Map enum lttng_ust_output to enum lttng_event_output.
313 */
314 switch (uchan->attr.output) {
315 case LTTNG_UST_MMAP:
316 channels[i].attr.output = LTTNG_EVENT_MMAP;
317 break;
318 default:
319 /*
320 * LTTNG_UST_MMAP is the only supported UST
321 * output mode.
322 */
323 assert(0);
324 break;
325 }
326
327 chan_exts[i].monitor_timer_interval =
328 uchan->monitor_timer_interval;
329 chan_exts[i].blocking_timeout =
330 uchan->attr.u.s.blocking_timeout;
331
332 ret = get_ust_runtime_stats(session, uchan,
333 &discarded_events, &lost_packets);
334 if (ret < 0) {
335 break;
336 }
337 chan_exts[i].discarded_events = discarded_events;
338 chan_exts[i].lost_packets = lost_packets;
339 i++;
340 }
341 rcu_read_unlock();
342 break;
343 }
344 default:
345 break;
346 }
347
348 end:
349 if (ret < 0) {
350 return -LTTNG_ERR_FATAL;
351 } else {
352 return LTTNG_OK;
353 }
354 }
355
356 static void increment_extended_len(const char *filter_expression,
357 struct lttng_event_exclusion *exclusion, size_t *extended_len)
358 {
359 *extended_len += sizeof(struct lttcomm_event_extended_header);
360
361 if (filter_expression) {
362 *extended_len += strlen(filter_expression) + 1;
363 }
364
365 if (exclusion) {
366 *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN;
367 }
368 }
369
370 static void append_extended_info(const char *filter_expression,
371 struct lttng_event_exclusion *exclusion, void **extended_at)
372 {
373 struct lttcomm_event_extended_header extended_header;
374 size_t filter_len = 0;
375 size_t nb_exclusions = 0;
376
377 if (filter_expression) {
378 filter_len = strlen(filter_expression) + 1;
379 }
380
381 if (exclusion) {
382 nb_exclusions = exclusion->count;
383 }
384
385 /* Set header fields */
386 extended_header.filter_len = filter_len;
387 extended_header.nb_exclusions = nb_exclusions;
388
389 /* Copy header */
390 memcpy(*extended_at, &extended_header, sizeof(extended_header));
391 *extended_at += sizeof(extended_header);
392
393 /* Copy filter string */
394 if (filter_expression) {
395 memcpy(*extended_at, filter_expression, filter_len);
396 *extended_at += filter_len;
397 }
398
399 /* Copy exclusion names */
400 if (exclusion) {
401 size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN;
402
403 memcpy(*extended_at, &exclusion->names, len);
404 *extended_at += len;
405 }
406 }
407
408 /*
409 * Create a list of agent domain events.
410 *
411 * Return number of events in list on success or else a negative value.
412 */
413 static int list_lttng_agent_events(struct agent *agt,
414 struct lttng_event **events, size_t *total_size)
415 {
416 int i = 0, ret = 0;
417 unsigned int nb_event = 0;
418 struct agent_event *event;
419 struct lttng_event *tmp_events;
420 struct lttng_ht_iter iter;
421 size_t extended_len = 0;
422 void *extended_at;
423
424 assert(agt);
425 assert(events);
426
427 DBG3("Listing agent events");
428
429 rcu_read_lock();
430 nb_event = lttng_ht_get_count(agt->events);
431 rcu_read_unlock();
432 if (nb_event == 0) {
433 ret = nb_event;
434 *total_size = 0;
435 goto error;
436 }
437
438 /* Compute required extended infos size */
439 extended_len = nb_event * sizeof(struct lttcomm_event_extended_header);
440
441 /*
442 * This is only valid because the commands which add events are
443 * processed in the same thread as the listing.
444 */
445 rcu_read_lock();
446 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
447 increment_extended_len(event->filter_expression, NULL,
448 &extended_len);
449 }
450 rcu_read_unlock();
451
452 *total_size = nb_event * sizeof(*tmp_events) + extended_len;
453 tmp_events = zmalloc(*total_size);
454 if (!tmp_events) {
455 PERROR("zmalloc agent events session");
456 ret = -LTTNG_ERR_FATAL;
457 goto error;
458 }
459
460 extended_at = ((uint8_t *) tmp_events) +
461 nb_event * sizeof(struct lttng_event);
462
463 rcu_read_lock();
464 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
465 strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
466 tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
467 tmp_events[i].enabled = event->enabled;
468 tmp_events[i].loglevel = event->loglevel_value;
469 tmp_events[i].loglevel_type = event->loglevel_type;
470 i++;
471
472 /* Append extended info */
473 append_extended_info(event->filter_expression, NULL,
474 &extended_at);
475 }
476 rcu_read_unlock();
477
478 *events = tmp_events;
479 ret = nb_event;
480
481 error:
482 assert(nb_event == i);
483 return ret;
484 }
485
486 /*
487 * Create a list of ust global domain events.
488 */
489 static int list_lttng_ust_global_events(char *channel_name,
490 struct ltt_ust_domain_global *ust_global,
491 struct lttng_event **events, size_t *total_size)
492 {
493 int i = 0, ret = 0;
494 unsigned int nb_event = 0;
495 struct lttng_ht_iter iter;
496 struct lttng_ht_node_str *node;
497 struct ltt_ust_channel *uchan;
498 struct ltt_ust_event *uevent;
499 struct lttng_event *tmp;
500 size_t extended_len = 0;
501 void *extended_at;
502
503 DBG("Listing UST global events for channel %s", channel_name);
504
505 rcu_read_lock();
506
507 lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
508 node = lttng_ht_iter_get_node_str(&iter);
509 if (node == NULL) {
510 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
511 goto end;
512 }
513
514 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
515
516 nb_event = lttng_ht_get_count(uchan->events);
517 if (nb_event == 0) {
518 ret = nb_event;
519 *total_size = 0;
520 goto end;
521 }
522
523 DBG3("Listing UST global %d events", nb_event);
524
525 /* Compute required extended infos size */
526 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
527 if (uevent->internal) {
528 nb_event--;
529 continue;
530 }
531
532 increment_extended_len(uevent->filter_expression,
533 uevent->exclusion, &extended_len);
534 }
535 if (nb_event == 0) {
536 /* All events are internal, skip. */
537 ret = 0;
538 *total_size = 0;
539 goto end;
540 }
541
542 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
543 tmp = zmalloc(*total_size);
544 if (tmp == NULL) {
545 ret = -LTTNG_ERR_FATAL;
546 goto end;
547 }
548
549 extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event);
550
551 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
552 if (uevent->internal) {
553 /* This event should remain hidden from clients */
554 continue;
555 }
556 strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
557 tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
558 tmp[i].enabled = uevent->enabled;
559
560 switch (uevent->attr.instrumentation) {
561 case LTTNG_UST_TRACEPOINT:
562 tmp[i].type = LTTNG_EVENT_TRACEPOINT;
563 break;
564 case LTTNG_UST_PROBE:
565 tmp[i].type = LTTNG_EVENT_PROBE;
566 break;
567 case LTTNG_UST_FUNCTION:
568 tmp[i].type = LTTNG_EVENT_FUNCTION;
569 break;
570 }
571
572 tmp[i].loglevel = uevent->attr.loglevel;
573 switch (uevent->attr.loglevel_type) {
574 case LTTNG_UST_LOGLEVEL_ALL:
575 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
576 break;
577 case LTTNG_UST_LOGLEVEL_RANGE:
578 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
579 break;
580 case LTTNG_UST_LOGLEVEL_SINGLE:
581 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
582 break;
583 }
584 if (uevent->filter) {
585 tmp[i].filter = 1;
586 }
587 if (uevent->exclusion) {
588 tmp[i].exclusion = 1;
589 }
590 i++;
591
592 /* Append extended info */
593 append_extended_info(uevent->filter_expression,
594 uevent->exclusion, &extended_at);
595 }
596
597 ret = nb_event;
598 *events = tmp;
599 end:
600 rcu_read_unlock();
601 return ret;
602 }
603
604 /*
605 * Fill lttng_event array of all kernel events in the channel.
606 */
607 static int list_lttng_kernel_events(char *channel_name,
608 struct ltt_kernel_session *kernel_session,
609 struct lttng_event **events, size_t *total_size)
610 {
611 int i = 0, ret;
612 unsigned int nb_event;
613 struct ltt_kernel_event *event;
614 struct ltt_kernel_channel *kchan;
615 size_t extended_len = 0;
616 void *extended_at;
617
618 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
619 if (kchan == NULL) {
620 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
621 goto error;
622 }
623
624 nb_event = kchan->event_count;
625
626 DBG("Listing events for channel %s", kchan->channel->name);
627
628 if (nb_event == 0) {
629 *total_size = 0;
630 *events = NULL;
631 goto end;
632 }
633
634 /* Compute required extended infos size */
635 cds_list_for_each_entry(event, &kchan->events_list.head, list) {
636 increment_extended_len(event->filter_expression, NULL,
637 &extended_len);
638 }
639
640 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
641 *events = zmalloc(*total_size);
642 if (*events == NULL) {
643 ret = LTTNG_ERR_FATAL;
644 goto error;
645 }
646
647 extended_at = ((void *) *events) +
648 nb_event * sizeof(struct lttng_event);
649
650 /* Kernel channels */
651 cds_list_for_each_entry(event, &kchan->events_list.head , list) {
652 strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
653 (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
654 (*events)[i].enabled = event->enabled;
655 (*events)[i].filter =
656 (unsigned char) !!event->filter_expression;
657
658 switch (event->event->instrumentation) {
659 case LTTNG_KERNEL_TRACEPOINT:
660 (*events)[i].type = LTTNG_EVENT_TRACEPOINT;
661 break;
662 case LTTNG_KERNEL_KRETPROBE:
663 (*events)[i].type = LTTNG_EVENT_FUNCTION;
664 memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
665 sizeof(struct lttng_kernel_kprobe));
666 break;
667 case LTTNG_KERNEL_KPROBE:
668 (*events)[i].type = LTTNG_EVENT_PROBE;
669 memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
670 sizeof(struct lttng_kernel_kprobe));
671 break;
672 case LTTNG_KERNEL_FUNCTION:
673 (*events)[i].type = LTTNG_EVENT_FUNCTION;
674 memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
675 sizeof(struct lttng_kernel_function));
676 break;
677 case LTTNG_KERNEL_NOOP:
678 (*events)[i].type = LTTNG_EVENT_NOOP;
679 break;
680 case LTTNG_KERNEL_SYSCALL:
681 (*events)[i].type = LTTNG_EVENT_SYSCALL;
682 break;
683 case LTTNG_KERNEL_ALL:
684 assert(0);
685 break;
686 }
687 i++;
688
689 /* Append extended info */
690 append_extended_info(event->filter_expression, NULL,
691 &extended_at);
692 }
693
694 end:
695 return nb_event;
696
697 error:
698 /* Negate the error code to differentiate the size from an error */
699 return -ret;
700 }
701
702 /*
703 * Add URI so the consumer output object. Set the correct path depending on the
704 * domain adding the default trace directory.
705 */
706 static int add_uri_to_consumer(struct consumer_output *consumer,
707 struct lttng_uri *uri, enum lttng_domain_type domain,
708 const char *session_name)
709 {
710 int ret = LTTNG_OK;
711 const char *default_trace_dir;
712
713 assert(uri);
714
715 if (consumer == NULL) {
716 DBG("No consumer detected. Don't add URI. Stopping.");
717 ret = LTTNG_ERR_NO_CONSUMER;
718 goto error;
719 }
720
721 switch (domain) {
722 case LTTNG_DOMAIN_KERNEL:
723 default_trace_dir = DEFAULT_KERNEL_TRACE_DIR;
724 break;
725 case LTTNG_DOMAIN_UST:
726 default_trace_dir = DEFAULT_UST_TRACE_DIR;
727 break;
728 default:
729 /*
730 * This case is possible is we try to add the URI to the global tracing
731 * session consumer object which in this case there is no subdir.
732 */
733 default_trace_dir = "";
734 }
735
736 switch (uri->dtype) {
737 case LTTNG_DST_IPV4:
738 case LTTNG_DST_IPV6:
739 DBG2("Setting network URI to consumer");
740
741 if (consumer->type == CONSUMER_DST_NET) {
742 if ((uri->stype == LTTNG_STREAM_CONTROL &&
743 consumer->dst.net.control_isset) ||
744 (uri->stype == LTTNG_STREAM_DATA &&
745 consumer->dst.net.data_isset)) {
746 ret = LTTNG_ERR_URL_EXIST;
747 goto error;
748 }
749 } else {
750 memset(&consumer->dst.net, 0, sizeof(consumer->dst.net));
751 }
752
753 consumer->type = CONSUMER_DST_NET;
754
755 /* Set URI into consumer output object */
756 ret = consumer_set_network_uri(consumer, uri);
757 if (ret < 0) {
758 ret = -ret;
759 goto error;
760 } else if (ret == 1) {
761 /*
762 * URI was the same in the consumer so we do not append the subdir
763 * again so to not duplicate output dir.
764 */
765 ret = LTTNG_OK;
766 goto error;
767 }
768
769 if (uri->stype == LTTNG_STREAM_CONTROL && strlen(uri->subdir) == 0) {
770 ret = consumer_set_subdir(consumer, session_name);
771 if (ret < 0) {
772 ret = LTTNG_ERR_FATAL;
773 goto error;
774 }
775 }
776
777 if (uri->stype == LTTNG_STREAM_CONTROL) {
778 /* On a new subdir, reappend the default trace dir. */
779 strncat(consumer->subdir, default_trace_dir,
780 sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
781 DBG3("Append domain trace name to subdir %s", consumer->subdir);
782 }
783
784 break;
785 case LTTNG_DST_PATH:
786 DBG2("Setting trace directory path from URI to %s", uri->dst.path);
787 memset(consumer->dst.session_root_path, 0,
788 sizeof(consumer->dst.session_root_path));
789 /* Explicit length checks for strcpy and strcat. */
790 if (strlen(uri->dst.path) + strlen(default_trace_dir)
791 >= sizeof(consumer->dst.session_root_path)) {
792 ret = LTTNG_ERR_FATAL;
793 goto error;
794 }
795 strcpy(consumer->dst.session_root_path, uri->dst.path);
796 /* Append default trace dir */
797 strcat(consumer->dst.session_root_path, default_trace_dir);
798 /* Flag consumer as local. */
799 consumer->type = CONSUMER_DST_LOCAL;
800 break;
801 }
802
803 ret = LTTNG_OK;
804
805 error:
806 return ret;
807 }
808
809 /*
810 * Init tracing by creating trace directory and sending fds kernel consumer.
811 */
812 static int init_kernel_tracing(struct ltt_kernel_session *session)
813 {
814 int ret = 0;
815 struct lttng_ht_iter iter;
816 struct consumer_socket *socket;
817
818 assert(session);
819
820 rcu_read_lock();
821
822 if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
823 cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
824 socket, node.node) {
825 pthread_mutex_lock(socket->lock);
826 ret = kernel_consumer_send_session(socket, session);
827 pthread_mutex_unlock(socket->lock);
828 if (ret < 0) {
829 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
830 goto error;
831 }
832 }
833 }
834
835 error:
836 rcu_read_unlock();
837 return ret;
838 }
839
840 /*
841 * Create a socket to the relayd using the URI.
842 *
843 * On success, the relayd_sock pointer is set to the created socket.
844 * Else, it's stays untouched and a lttcomm error code is returned.
845 */
846 static int create_connect_relayd(struct lttng_uri *uri,
847 struct lttcomm_relayd_sock **relayd_sock,
848 struct consumer_output *consumer)
849 {
850 int ret;
851 struct lttcomm_relayd_sock *rsock;
852
853 rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
854 RELAYD_VERSION_COMM_MINOR);
855 if (!rsock) {
856 ret = LTTNG_ERR_FATAL;
857 goto error;
858 }
859
860 /*
861 * Connect to relayd so we can proceed with a session creation. This call
862 * can possibly block for an arbitrary amount of time to set the health
863 * state to be in poll execution.
864 */
865 health_poll_entry();
866 ret = relayd_connect(rsock);
867 health_poll_exit();
868 if (ret < 0) {
869 ERR("Unable to reach lttng-relayd");
870 ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
871 goto free_sock;
872 }
873
874 /* Create socket for control stream. */
875 if (uri->stype == LTTNG_STREAM_CONTROL) {
876 DBG3("Creating relayd stream socket from URI");
877
878 /* Check relayd version */
879 ret = relayd_version_check(rsock);
880 if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) {
881 goto close_sock;
882 } else if (ret < 0) {
883 ERR("Unable to reach lttng-relayd");
884 ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
885 goto close_sock;
886 }
887 consumer->relay_major_version = rsock->major;
888 consumer->relay_minor_version = rsock->minor;
889 } else if (uri->stype == LTTNG_STREAM_DATA) {
890 DBG3("Creating relayd data socket from URI");
891 } else {
892 /* Command is not valid */
893 ERR("Relayd invalid stream type: %d", uri->stype);
894 ret = LTTNG_ERR_INVALID;
895 goto close_sock;
896 }
897
898 *relayd_sock = rsock;
899
900 return LTTNG_OK;
901
902 close_sock:
903 /* The returned value is not useful since we are on an error path. */
904 (void) relayd_close(rsock);
905 free_sock:
906 free(rsock);
907 error:
908 return ret;
909 }
910
911 /*
912 * Connect to the relayd using URI and send the socket to the right consumer.
913 *
914 * The consumer socket lock must be held by the caller.
915 */
916 static int send_consumer_relayd_socket(enum lttng_domain_type domain,
917 unsigned int session_id, struct lttng_uri *relayd_uri,
918 struct consumer_output *consumer,
919 struct consumer_socket *consumer_sock,
920 char *session_name, char *hostname, int session_live_timer)
921 {
922 int ret;
923 struct lttcomm_relayd_sock *rsock = NULL;
924
925 /* Connect to relayd and make version check if uri is the control. */
926 ret = create_connect_relayd(relayd_uri, &rsock, consumer);
927 if (ret != LTTNG_OK) {
928 goto relayd_comm_error;
929 }
930 assert(rsock);
931
932 /* Set the network sequence index if not set. */
933 if (consumer->net_seq_index == (uint64_t) -1ULL) {
934 pthread_mutex_lock(&relayd_net_seq_idx_lock);
935 /*
936 * Increment net_seq_idx because we are about to transfer the
937 * new relayd socket to the consumer.
938 * Assign unique key so the consumer can match streams.
939 */
940 consumer->net_seq_index = ++relayd_net_seq_idx;
941 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
942 }
943
944 /* Send relayd socket to consumer. */
945 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
946 relayd_uri->stype, session_id,
947 session_name, hostname, session_live_timer);
948 if (ret < 0) {
949 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
950 goto close_sock;
951 }
952
953 /* Flag that the corresponding socket was sent. */
954 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
955 consumer_sock->control_sock_sent = 1;
956 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
957 consumer_sock->data_sock_sent = 1;
958 }
959
960 ret = LTTNG_OK;
961
962 /*
963 * Close socket which was dup on the consumer side. The session daemon does
964 * NOT keep track of the relayd socket(s) once transfer to the consumer.
965 */
966
967 close_sock:
968 if (ret != LTTNG_OK) {
969 /*
970 * The consumer output for this session should not be used anymore
971 * since the relayd connection failed thus making any tracing or/and
972 * streaming not usable.
973 */
974 consumer->enabled = 0;
975 }
976 (void) relayd_close(rsock);
977 free(rsock);
978
979 relayd_comm_error:
980 return ret;
981 }
982
983 /*
984 * Send both relayd sockets to a specific consumer and domain. This is a
985 * helper function to facilitate sending the information to the consumer for a
986 * session.
987 *
988 * The consumer socket lock must be held by the caller.
989 */
990 static int send_consumer_relayd_sockets(enum lttng_domain_type domain,
991 unsigned int session_id, struct consumer_output *consumer,
992 struct consumer_socket *sock, char *session_name,
993 char *hostname, int session_live_timer)
994 {
995 int ret = LTTNG_OK;
996
997 assert(consumer);
998 assert(sock);
999
1000 /* Sending control relayd socket. */
1001 if (!sock->control_sock_sent) {
1002 ret = send_consumer_relayd_socket(domain, session_id,
1003 &consumer->dst.net.control, consumer, sock,
1004 session_name, hostname, session_live_timer);
1005 if (ret != LTTNG_OK) {
1006 goto error;
1007 }
1008 }
1009
1010 /* Sending data relayd socket. */
1011 if (!sock->data_sock_sent) {
1012 ret = send_consumer_relayd_socket(domain, session_id,
1013 &consumer->dst.net.data, consumer, sock,
1014 session_name, hostname, session_live_timer);
1015 if (ret != LTTNG_OK) {
1016 goto error;
1017 }
1018 }
1019
1020 error:
1021 return ret;
1022 }
1023
1024 /*
1025 * Setup relayd connections for a tracing session. First creates the socket to
1026 * the relayd and send them to the right domain consumer. Consumer type MUST be
1027 * network.
1028 */
1029 int cmd_setup_relayd(struct ltt_session *session)
1030 {
1031 int ret = LTTNG_OK;
1032 struct ltt_ust_session *usess;
1033 struct ltt_kernel_session *ksess;
1034 struct consumer_socket *socket;
1035 struct lttng_ht_iter iter;
1036
1037 assert(session);
1038
1039 usess = session->ust_session;
1040 ksess = session->kernel_session;
1041
1042 DBG("Setting relayd for session %s", session->name);
1043
1044 rcu_read_lock();
1045
1046 if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
1047 && usess->consumer->enabled) {
1048 /* For each consumer socket, send relayd sockets */
1049 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
1050 socket, node.node) {
1051 pthread_mutex_lock(socket->lock);
1052 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
1053 usess->consumer, socket,
1054 session->name, session->hostname,
1055 session->live_timer);
1056 pthread_mutex_unlock(socket->lock);
1057 if (ret != LTTNG_OK) {
1058 goto error;
1059 }
1060 /* Session is now ready for network streaming. */
1061 session->net_handle = 1;
1062 }
1063 session->consumer->relay_major_version =
1064 usess->consumer->relay_major_version;
1065 session->consumer->relay_minor_version =
1066 usess->consumer->relay_minor_version;
1067 }
1068
1069 if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
1070 && ksess->consumer->enabled) {
1071 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1072 socket, node.node) {
1073 pthread_mutex_lock(socket->lock);
1074 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
1075 ksess->consumer, socket,
1076 session->name, session->hostname,
1077 session->live_timer);
1078 pthread_mutex_unlock(socket->lock);
1079 if (ret != LTTNG_OK) {
1080 goto error;
1081 }
1082 /* Session is now ready for network streaming. */
1083 session->net_handle = 1;
1084 }
1085 session->consumer->relay_major_version =
1086 ksess->consumer->relay_major_version;
1087 session->consumer->relay_minor_version =
1088 ksess->consumer->relay_minor_version;
1089 }
1090
1091 error:
1092 rcu_read_unlock();
1093 return ret;
1094 }
1095
1096 /*
1097 * Start a kernel session by opening all necessary streams.
1098 */
1099 static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe)
1100 {
1101 int ret;
1102 struct ltt_kernel_channel *kchan;
1103
1104 /* Open kernel metadata */
1105 if (ksess->metadata == NULL && ksess->output_traces) {
1106 ret = kernel_open_metadata(ksess);
1107 if (ret < 0) {
1108 ret = LTTNG_ERR_KERN_META_FAIL;
1109 goto error;
1110 }
1111 }
1112
1113 /* Open kernel metadata stream */
1114 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
1115 ret = kernel_open_metadata_stream(ksess);
1116 if (ret < 0) {
1117 ERR("Kernel create metadata stream failed");
1118 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1119 goto error;
1120 }
1121 }
1122
1123 /* For each channel */
1124 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1125 if (kchan->stream_count == 0) {
1126 ret = kernel_open_channel_stream(kchan);
1127 if (ret < 0) {
1128 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1129 goto error;
1130 }
1131 /* Update the stream global counter */
1132 ksess->stream_count_global += ret;
1133 }
1134 }
1135
1136 /* Setup kernel consumer socket and send fds to it */
1137 ret = init_kernel_tracing(ksess);
1138 if (ret != 0) {
1139 ret = LTTNG_ERR_KERN_START_FAIL;
1140 goto error;
1141 }
1142
1143 /* This start the kernel tracing */
1144 ret = kernel_start_session(ksess);
1145 if (ret < 0) {
1146 ret = LTTNG_ERR_KERN_START_FAIL;
1147 goto error;
1148 }
1149
1150 /* Quiescent wait after starting trace */
1151 kernel_wait_quiescent(kernel_tracer_fd);
1152
1153 ksess->active = 1;
1154
1155 ret = LTTNG_OK;
1156
1157 error:
1158 return ret;
1159 }
1160
1161 /*
1162 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1163 */
1164 int cmd_disable_channel(struct ltt_session *session,
1165 enum lttng_domain_type domain, char *channel_name)
1166 {
1167 int ret;
1168 struct ltt_ust_session *usess;
1169
1170 usess = session->ust_session;
1171
1172 rcu_read_lock();
1173
1174 switch (domain) {
1175 case LTTNG_DOMAIN_KERNEL:
1176 {
1177 ret = channel_kernel_disable(session->kernel_session,
1178 channel_name);
1179 if (ret != LTTNG_OK) {
1180 goto error;
1181 }
1182
1183 kernel_wait_quiescent(kernel_tracer_fd);
1184 break;
1185 }
1186 case LTTNG_DOMAIN_UST:
1187 {
1188 struct ltt_ust_channel *uchan;
1189 struct lttng_ht *chan_ht;
1190
1191 chan_ht = usess->domain_global.channels;
1192
1193 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
1194 if (uchan == NULL) {
1195 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1196 goto error;
1197 }
1198
1199 ret = channel_ust_disable(usess, uchan);
1200 if (ret != LTTNG_OK) {
1201 goto error;
1202 }
1203 break;
1204 }
1205 default:
1206 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1207 goto error;
1208 }
1209
1210 ret = LTTNG_OK;
1211
1212 error:
1213 rcu_read_unlock();
1214 return ret;
1215 }
1216
1217 /*
1218 * Command LTTNG_TRACK_PID processed by the client thread.
1219 *
1220 * Called with session lock held.
1221 */
1222 int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
1223 int pid)
1224 {
1225 int ret;
1226
1227 rcu_read_lock();
1228
1229 switch (domain) {
1230 case LTTNG_DOMAIN_KERNEL:
1231 {
1232 struct ltt_kernel_session *ksess;
1233
1234 ksess = session->kernel_session;
1235
1236 ret = kernel_track_pid(ksess, pid);
1237 if (ret != LTTNG_OK) {
1238 goto error;
1239 }
1240
1241 kernel_wait_quiescent(kernel_tracer_fd);
1242 break;
1243 }
1244 case LTTNG_DOMAIN_UST:
1245 {
1246 struct ltt_ust_session *usess;
1247
1248 usess = session->ust_session;
1249
1250 ret = trace_ust_track_pid(usess, pid);
1251 if (ret != LTTNG_OK) {
1252 goto error;
1253 }
1254 break;
1255 }
1256 default:
1257 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1258 goto error;
1259 }
1260
1261 ret = LTTNG_OK;
1262
1263 error:
1264 rcu_read_unlock();
1265 return ret;
1266 }
1267
1268 /*
1269 * Command LTTNG_UNTRACK_PID processed by the client thread.
1270 *
1271 * Called with session lock held.
1272 */
1273 int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
1274 int pid)
1275 {
1276 int ret;
1277
1278 rcu_read_lock();
1279
1280 switch (domain) {
1281 case LTTNG_DOMAIN_KERNEL:
1282 {
1283 struct ltt_kernel_session *ksess;
1284
1285 ksess = session->kernel_session;
1286
1287 ret = kernel_untrack_pid(ksess, pid);
1288 if (ret != LTTNG_OK) {
1289 goto error;
1290 }
1291
1292 kernel_wait_quiescent(kernel_tracer_fd);
1293 break;
1294 }
1295 case LTTNG_DOMAIN_UST:
1296 {
1297 struct ltt_ust_session *usess;
1298
1299 usess = session->ust_session;
1300
1301 ret = trace_ust_untrack_pid(usess, pid);
1302 if (ret != LTTNG_OK) {
1303 goto error;
1304 }
1305 break;
1306 }
1307 default:
1308 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1309 goto error;
1310 }
1311
1312 ret = LTTNG_OK;
1313
1314 error:
1315 rcu_read_unlock();
1316 return ret;
1317 }
1318
1319 /*
1320 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1321 *
1322 * The wpipe arguments is used as a notifier for the kernel thread.
1323 */
1324 int cmd_enable_channel(struct ltt_session *session,
1325 struct lttng_domain *domain, struct lttng_channel *attr, int wpipe)
1326 {
1327 int ret;
1328 struct ltt_ust_session *usess = session->ust_session;
1329 struct lttng_ht *chan_ht;
1330 size_t len;
1331
1332 assert(session);
1333 assert(attr);
1334 assert(domain);
1335
1336 len = lttng_strnlen(attr->name, sizeof(attr->name));
1337
1338 /* Validate channel name */
1339 if (attr->name[0] == '.' ||
1340 memchr(attr->name, '/', len) != NULL) {
1341 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1342 goto end;
1343 }
1344
1345 DBG("Enabling channel %s for session %s", attr->name, session->name);
1346
1347 rcu_read_lock();
1348
1349 /*
1350 * Don't try to enable a channel if the session has been started at
1351 * some point in time before. The tracer does not allow it.
1352 */
1353 if (session->has_been_started) {
1354 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1355 goto error;
1356 }
1357
1358 /*
1359 * If the session is a live session, remove the switch timer, the
1360 * live timer does the same thing but sends also synchronisation
1361 * beacons for inactive streams.
1362 */
1363 if (session->live_timer > 0) {
1364 attr->attr.live_timer_interval = session->live_timer;
1365 attr->attr.switch_timer_interval = 0;
1366 }
1367
1368 /* Check for feature support */
1369 switch (domain->type) {
1370 case LTTNG_DOMAIN_KERNEL:
1371 {
1372 if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) {
1373 /* Sampling position of buffer is not supported */
1374 WARN("Kernel tracer does not support buffer monitoring. "
1375 "Setting the monitor interval timer to 0 "
1376 "(disabled) for channel '%s' of session '%s'",
1377 attr-> name, session->name);
1378 lttng_channel_set_monitor_timer_interval(attr, 0);
1379 }
1380 break;
1381 }
1382 case LTTNG_DOMAIN_UST:
1383 case LTTNG_DOMAIN_JUL:
1384 case LTTNG_DOMAIN_LOG4J:
1385 case LTTNG_DOMAIN_PYTHON:
1386 break;
1387 default:
1388 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1389 goto error;
1390 }
1391
1392 switch (domain->type) {
1393 case LTTNG_DOMAIN_KERNEL:
1394 {
1395 struct ltt_kernel_channel *kchan;
1396
1397 kchan = trace_kernel_get_channel_by_name(attr->name,
1398 session->kernel_session);
1399 if (kchan == NULL) {
1400 ret = channel_kernel_create(session->kernel_session, attr, wpipe);
1401 if (attr->name[0] != '\0') {
1402 session->kernel_session->has_non_default_channel = 1;
1403 }
1404 } else {
1405 ret = channel_kernel_enable(session->kernel_session, kchan);
1406 }
1407
1408 if (ret != LTTNG_OK) {
1409 goto error;
1410 }
1411
1412 kernel_wait_quiescent(kernel_tracer_fd);
1413 break;
1414 }
1415 case LTTNG_DOMAIN_UST:
1416 case LTTNG_DOMAIN_JUL:
1417 case LTTNG_DOMAIN_LOG4J:
1418 case LTTNG_DOMAIN_PYTHON:
1419 {
1420 struct ltt_ust_channel *uchan;
1421
1422 /*
1423 * FIXME
1424 *
1425 * Current agent implementation limitations force us to allow
1426 * only one channel at once in "agent" subdomains. Each
1427 * subdomain has a default channel name which must be strictly
1428 * adhered to.
1429 */
1430 if (domain->type == LTTNG_DOMAIN_JUL) {
1431 if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
1432 LTTNG_SYMBOL_NAME_LEN)) {
1433 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1434 goto error;
1435 }
1436 } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
1437 if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
1438 LTTNG_SYMBOL_NAME_LEN)) {
1439 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1440 goto error;
1441 }
1442 } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
1443 if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
1444 LTTNG_SYMBOL_NAME_LEN)) {
1445 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1446 goto error;
1447 }
1448 }
1449
1450 chan_ht = usess->domain_global.channels;
1451
1452 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
1453 if (uchan == NULL) {
1454 ret = channel_ust_create(usess, attr, domain->buf_type);
1455 if (attr->name[0] != '\0') {
1456 usess->has_non_default_channel = 1;
1457 }
1458 } else {
1459 ret = channel_ust_enable(usess, uchan);
1460 }
1461 break;
1462 }
1463 default:
1464 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1465 goto error;
1466 }
1467
1468 error:
1469 rcu_read_unlock();
1470 end:
1471 return ret;
1472 }
1473
1474 /*
1475 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1476 */
1477 int cmd_disable_event(struct ltt_session *session,
1478 enum lttng_domain_type domain, char *channel_name,
1479 struct lttng_event *event)
1480 {
1481 int ret;
1482 char *event_name;
1483
1484 DBG("Disable event command for event \'%s\'", event->name);
1485
1486 event_name = event->name;
1487
1488 /* Error out on unhandled search criteria */
1489 if (event->loglevel_type || event->loglevel != -1 || event->enabled
1490 || event->pid || event->filter || event->exclusion) {
1491 ret = LTTNG_ERR_UNK;
1492 goto error;
1493 }
1494
1495 rcu_read_lock();
1496
1497 switch (domain) {
1498 case LTTNG_DOMAIN_KERNEL:
1499 {
1500 struct ltt_kernel_channel *kchan;
1501 struct ltt_kernel_session *ksess;
1502
1503 ksess = session->kernel_session;
1504
1505 /*
1506 * If a non-default channel has been created in the
1507 * session, explicitely require that -c chan_name needs
1508 * to be provided.
1509 */
1510 if (ksess->has_non_default_channel && channel_name[0] == '\0') {
1511 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1512 goto error_unlock;
1513 }
1514
1515 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1516 if (kchan == NULL) {
1517 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
1518 goto error_unlock;
1519 }
1520
1521 switch (event->type) {
1522 case LTTNG_EVENT_ALL:
1523 case LTTNG_EVENT_TRACEPOINT:
1524 case LTTNG_EVENT_SYSCALL:
1525 case LTTNG_EVENT_PROBE:
1526 case LTTNG_EVENT_FUNCTION:
1527 case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
1528 if (event_name[0] == '\0') {
1529 ret = event_kernel_disable_event(kchan,
1530 NULL, event->type);
1531 } else {
1532 ret = event_kernel_disable_event(kchan,
1533 event_name, event->type);
1534 }
1535 if (ret != LTTNG_OK) {
1536 goto error_unlock;
1537 }
1538 break;
1539 default:
1540 ret = LTTNG_ERR_UNK;
1541 goto error_unlock;
1542 }
1543
1544 kernel_wait_quiescent(kernel_tracer_fd);
1545 break;
1546 }
1547 case LTTNG_DOMAIN_UST:
1548 {
1549 struct ltt_ust_channel *uchan;
1550 struct ltt_ust_session *usess;
1551
1552 usess = session->ust_session;
1553
1554 if (validate_ust_event_name(event_name)) {
1555 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1556 goto error_unlock;
1557 }
1558
1559 /*
1560 * If a non-default channel has been created in the
1561 * session, explicitly require that -c chan_name needs
1562 * to be provided.
1563 */
1564 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1565 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1566 goto error_unlock;
1567 }
1568
1569 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1570 channel_name);
1571 if (uchan == NULL) {
1572 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1573 goto error_unlock;
1574 }
1575
1576 switch (event->type) {
1577 case LTTNG_EVENT_ALL:
1578 /*
1579 * An empty event name means that everything
1580 * should be disabled.
1581 */
1582 if (event->name[0] == '\0') {
1583 ret = event_ust_disable_all_tracepoints(usess, uchan);
1584 } else {
1585 ret = event_ust_disable_tracepoint(usess, uchan,
1586 event_name);
1587 }
1588 if (ret != LTTNG_OK) {
1589 goto error_unlock;
1590 }
1591 break;
1592 default:
1593 ret = LTTNG_ERR_UNK;
1594 goto error_unlock;
1595 }
1596
1597 DBG3("Disable UST event %s in channel %s completed", event_name,
1598 channel_name);
1599 break;
1600 }
1601 case LTTNG_DOMAIN_LOG4J:
1602 case LTTNG_DOMAIN_JUL:
1603 case LTTNG_DOMAIN_PYTHON:
1604 {
1605 struct agent *agt;
1606 struct ltt_ust_session *usess = session->ust_session;
1607
1608 assert(usess);
1609
1610 switch (event->type) {
1611 case LTTNG_EVENT_ALL:
1612 break;
1613 default:
1614 ret = LTTNG_ERR_UNK;
1615 goto error_unlock;
1616 }
1617
1618 agt = trace_ust_find_agent(usess, domain);
1619 if (!agt) {
1620 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
1621 goto error_unlock;
1622 }
1623 /*
1624 * An empty event name means that everything
1625 * should be disabled.
1626 */
1627 if (event->name[0] == '\0') {
1628 ret = event_agent_disable_all(usess, agt);
1629 } else {
1630 ret = event_agent_disable(usess, agt, event_name);
1631 }
1632 if (ret != LTTNG_OK) {
1633 goto error_unlock;
1634 }
1635
1636 break;
1637 }
1638 default:
1639 ret = LTTNG_ERR_UND;
1640 goto error_unlock;
1641 }
1642
1643 ret = LTTNG_OK;
1644
1645 error_unlock:
1646 rcu_read_unlock();
1647 error:
1648 return ret;
1649 }
1650
1651 /*
1652 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1653 */
1654 int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
1655 char *channel_name, struct lttng_event_context *ctx, int kwpipe)
1656 {
1657 int ret, chan_kern_created = 0, chan_ust_created = 0;
1658 char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
1659
1660 /*
1661 * Don't try to add a context if the session has been started at
1662 * some point in time before. The tracer does not allow it and would
1663 * result in a corrupted trace.
1664 */
1665 if (session->has_been_started) {
1666 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1667 goto end;
1668 }
1669
1670 if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
1671 app_ctx_provider_name = ctx->u.app_ctx.provider_name;
1672 app_ctx_name = ctx->u.app_ctx.ctx_name;
1673 }
1674
1675 switch (domain) {
1676 case LTTNG_DOMAIN_KERNEL:
1677 assert(session->kernel_session);
1678
1679 if (session->kernel_session->channel_count == 0) {
1680 /* Create default channel */
1681 ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
1682 if (ret != LTTNG_OK) {
1683 goto error;
1684 }
1685 chan_kern_created = 1;
1686 }
1687 /* Add kernel context to kernel tracer */
1688 ret = context_kernel_add(session->kernel_session, ctx, channel_name);
1689 if (ret != LTTNG_OK) {
1690 goto error;
1691 }
1692 break;
1693 case LTTNG_DOMAIN_JUL:
1694 case LTTNG_DOMAIN_LOG4J:
1695 {
1696 /*
1697 * Validate channel name.
1698 * If no channel name is given and the domain is JUL or LOG4J,
1699 * set it to the appropriate domain-specific channel name. If
1700 * a name is provided but does not match the expexted channel
1701 * name, return an error.
1702 */
1703 if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
1704 strcmp(channel_name,
1705 DEFAULT_JUL_CHANNEL_NAME)) {
1706 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1707 goto error;
1708 } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
1709 strcmp(channel_name,
1710 DEFAULT_LOG4J_CHANNEL_NAME)) {
1711 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1712 goto error;
1713 }
1714 /* break is _not_ missing here. */
1715 }
1716 case LTTNG_DOMAIN_UST:
1717 {
1718 struct ltt_ust_session *usess = session->ust_session;
1719 unsigned int chan_count;
1720
1721 assert(usess);
1722
1723 chan_count = lttng_ht_get_count(usess->domain_global.channels);
1724 if (chan_count == 0) {
1725 struct lttng_channel *attr;
1726 /* Create default channel */
1727 attr = channel_new_default_attr(domain, usess->buffer_type);
1728 if (attr == NULL) {
1729 ret = LTTNG_ERR_FATAL;
1730 goto error;
1731 }
1732
1733 ret = channel_ust_create(usess, attr, usess->buffer_type);
1734 if (ret != LTTNG_OK) {
1735 free(attr);
1736 goto error;
1737 }
1738 channel_attr_destroy(attr);
1739 chan_ust_created = 1;
1740 }
1741
1742 ret = context_ust_add(usess, domain, ctx, channel_name);
1743 free(app_ctx_provider_name);
1744 free(app_ctx_name);
1745 app_ctx_name = NULL;
1746 app_ctx_provider_name = NULL;
1747 if (ret != LTTNG_OK) {
1748 goto error;
1749 }
1750 break;
1751 }
1752 default:
1753 ret = LTTNG_ERR_UND;
1754 goto error;
1755 }
1756
1757 ret = LTTNG_OK;
1758 goto end;
1759
1760 error:
1761 if (chan_kern_created) {
1762 struct ltt_kernel_channel *kchan =
1763 trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
1764 session->kernel_session);
1765 /* Created previously, this should NOT fail. */
1766 assert(kchan);
1767 kernel_destroy_channel(kchan);
1768 }
1769
1770 if (chan_ust_created) {
1771 struct ltt_ust_channel *uchan =
1772 trace_ust_find_channel_by_name(
1773 session->ust_session->domain_global.channels,
1774 DEFAULT_CHANNEL_NAME);
1775 /* Created previously, this should NOT fail. */
1776 assert(uchan);
1777 /* Remove from the channel list of the session. */
1778 trace_ust_delete_channel(session->ust_session->domain_global.channels,
1779 uchan);
1780 trace_ust_destroy_channel(uchan);
1781 }
1782 end:
1783 free(app_ctx_provider_name);
1784 free(app_ctx_name);
1785 return ret;
1786 }
1787
1788 static inline bool name_starts_with(const char *name, const char *prefix)
1789 {
1790 const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
1791
1792 return !strncmp(name, prefix, max_cmp_len);
1793 }
1794
1795 /* Perform userspace-specific event name validation */
1796 static int validate_ust_event_name(const char *name)
1797 {
1798 int ret = 0;
1799
1800 if (!name) {
1801 ret = -1;
1802 goto end;
1803 }
1804
1805 /*
1806 * Check name against all internal UST event component namespaces used
1807 * by the agents.
1808 */
1809 if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
1810 name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
1811 name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
1812 ret = -1;
1813 }
1814
1815 end:
1816 return ret;
1817 }
1818
1819 /*
1820 * Internal version of cmd_enable_event() with a supplemental
1821 * "internal_event" flag which is used to enable internal events which should
1822 * be hidden from clients. Such events are used in the agent implementation to
1823 * enable the events through which all "agent" events are funeled.
1824 */
1825 static int _cmd_enable_event(struct ltt_session *session,
1826 struct lttng_domain *domain,
1827 char *channel_name, struct lttng_event *event,
1828 char *filter_expression,
1829 struct lttng_filter_bytecode *filter,
1830 struct lttng_event_exclusion *exclusion,
1831 int wpipe, bool internal_event)
1832 {
1833 int ret = 0, channel_created = 0;
1834 struct lttng_channel *attr = NULL;
1835
1836 assert(session);
1837 assert(event);
1838 assert(channel_name);
1839
1840 /* If we have a filter, we must have its filter expression */
1841 assert(!(!!filter_expression ^ !!filter));
1842
1843 /* Normalize event name as a globbing pattern */
1844 strutils_normalize_star_glob_pattern(event->name);
1845
1846 /* Normalize exclusion names as globbing patterns */
1847 if (exclusion) {
1848 size_t i;
1849
1850 for (i = 0; i < exclusion->count; i++) {
1851 char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i);
1852
1853 strutils_normalize_star_glob_pattern(name);
1854 }
1855 }
1856
1857 DBG("Enable event command for event \'%s\'", event->name);
1858
1859 rcu_read_lock();
1860
1861 switch (domain->type) {
1862 case LTTNG_DOMAIN_KERNEL:
1863 {
1864 struct ltt_kernel_channel *kchan;
1865
1866 /*
1867 * If a non-default channel has been created in the
1868 * session, explicitely require that -c chan_name needs
1869 * to be provided.
1870 */
1871 if (session->kernel_session->has_non_default_channel
1872 && channel_name[0] == '\0') {
1873 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1874 goto error;
1875 }
1876
1877 kchan = trace_kernel_get_channel_by_name(channel_name,
1878 session->kernel_session);
1879 if (kchan == NULL) {
1880 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
1881 LTTNG_BUFFER_GLOBAL);
1882 if (attr == NULL) {
1883 ret = LTTNG_ERR_FATAL;
1884 goto error;
1885 }
1886 if (lttng_strncpy(attr->name, channel_name,
1887 sizeof(attr->name))) {
1888 ret = LTTNG_ERR_INVALID;
1889 goto error;
1890 }
1891
1892 ret = cmd_enable_channel(session, domain, attr, wpipe);
1893 if (ret != LTTNG_OK) {
1894 goto error;
1895 }
1896 channel_created = 1;
1897 }
1898
1899 /* Get the newly created kernel channel pointer */
1900 kchan = trace_kernel_get_channel_by_name(channel_name,
1901 session->kernel_session);
1902 if (kchan == NULL) {
1903 /* This sould not happen... */
1904 ret = LTTNG_ERR_FATAL;
1905 goto error;
1906 }
1907
1908 switch (event->type) {
1909 case LTTNG_EVENT_ALL:
1910 {
1911 char *filter_expression_a = NULL;
1912 struct lttng_filter_bytecode *filter_a = NULL;
1913
1914 /*
1915 * We need to duplicate filter_expression and filter,
1916 * because ownership is passed to first enable
1917 * event.
1918 */
1919 if (filter_expression) {
1920 filter_expression_a = strdup(filter_expression);
1921 if (!filter_expression_a) {
1922 ret = LTTNG_ERR_FATAL;
1923 goto error;
1924 }
1925 }
1926 if (filter) {
1927 filter_a = zmalloc(sizeof(*filter_a) + filter->len);
1928 if (!filter_a) {
1929 free(filter_expression_a);
1930 ret = LTTNG_ERR_FATAL;
1931 goto error;
1932 }
1933 memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
1934 }
1935 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
1936 ret = event_kernel_enable_event(kchan, event,
1937 filter_expression, filter);
1938 /* We have passed ownership */
1939 filter_expression = NULL;
1940 filter = NULL;
1941 if (ret != LTTNG_OK) {
1942 if (channel_created) {
1943 /* Let's not leak a useless channel. */
1944 kernel_destroy_channel(kchan);
1945 }
1946 free(filter_expression_a);
1947 free(filter_a);
1948 goto error;
1949 }
1950 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
1951 ret = event_kernel_enable_event(kchan, event,
1952 filter_expression_a, filter_a);
1953 /* We have passed ownership */
1954 filter_expression_a = NULL;
1955 filter_a = NULL;
1956 if (ret != LTTNG_OK) {
1957 goto error;
1958 }
1959 break;
1960 }
1961 case LTTNG_EVENT_PROBE:
1962 case LTTNG_EVENT_FUNCTION:
1963 case LTTNG_EVENT_FUNCTION_ENTRY:
1964 case LTTNG_EVENT_TRACEPOINT:
1965 ret = event_kernel_enable_event(kchan, event,
1966 filter_expression, filter);
1967 /* We have passed ownership */
1968 filter_expression = NULL;
1969 filter = NULL;
1970 if (ret != LTTNG_OK) {
1971 if (channel_created) {
1972 /* Let's not leak a useless channel. */
1973 kernel_destroy_channel(kchan);
1974 }
1975 goto error;
1976 }
1977 break;
1978 case LTTNG_EVENT_SYSCALL:
1979 ret = event_kernel_enable_event(kchan, event,
1980 filter_expression, filter);
1981 /* We have passed ownership */
1982 filter_expression = NULL;
1983 filter = NULL;
1984 if (ret != LTTNG_OK) {
1985 goto error;
1986 }
1987 break;
1988 default:
1989 ret = LTTNG_ERR_UNK;
1990 goto error;
1991 }
1992
1993 kernel_wait_quiescent(kernel_tracer_fd);
1994 break;
1995 }
1996 case LTTNG_DOMAIN_UST:
1997 {
1998 struct ltt_ust_channel *uchan;
1999 struct ltt_ust_session *usess = session->ust_session;
2000
2001 assert(usess);
2002
2003 /*
2004 * If a non-default channel has been created in the
2005 * session, explicitely require that -c chan_name needs
2006 * to be provided.
2007 */
2008 if (usess->has_non_default_channel && channel_name[0] == '\0') {
2009 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2010 goto error;
2011 }
2012
2013 /* Get channel from global UST domain */
2014 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2015 channel_name);
2016 if (uchan == NULL) {
2017 /* Create default channel */
2018 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2019 usess->buffer_type);
2020 if (attr == NULL) {
2021 ret = LTTNG_ERR_FATAL;
2022 goto error;
2023 }
2024 if (lttng_strncpy(attr->name, channel_name,
2025 sizeof(attr->name))) {
2026 ret = LTTNG_ERR_INVALID;
2027 goto error;
2028 }
2029
2030 ret = cmd_enable_channel(session, domain, attr, wpipe);
2031 if (ret != LTTNG_OK) {
2032 goto error;
2033 }
2034
2035 /* Get the newly created channel reference back */
2036 uchan = trace_ust_find_channel_by_name(
2037 usess->domain_global.channels, channel_name);
2038 assert(uchan);
2039 }
2040
2041 if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
2042 /*
2043 * Don't allow users to add UST events to channels which
2044 * are assigned to a userspace subdomain (JUL, Log4J,
2045 * Python, etc.).
2046 */
2047 ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
2048 goto error;
2049 }
2050
2051 if (!internal_event) {
2052 /*
2053 * Ensure the event name is not reserved for internal
2054 * use.
2055 */
2056 ret = validate_ust_event_name(event->name);
2057 if (ret) {
2058 WARN("Userspace event name %s failed validation.",
2059 event->name ?
2060 event->name : "NULL");
2061 ret = LTTNG_ERR_INVALID_EVENT_NAME;
2062 goto error;
2063 }
2064 }
2065
2066 /* At this point, the session and channel exist on the tracer */
2067 ret = event_ust_enable_tracepoint(usess, uchan, event,
2068 filter_expression, filter, exclusion,
2069 internal_event);
2070 /* We have passed ownership */
2071 filter_expression = NULL;
2072 filter = NULL;
2073 exclusion = NULL;
2074 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2075 goto already_enabled;
2076 } else if (ret != LTTNG_OK) {
2077 goto error;
2078 }
2079 break;
2080 }
2081 case LTTNG_DOMAIN_LOG4J:
2082 case LTTNG_DOMAIN_JUL:
2083 case LTTNG_DOMAIN_PYTHON:
2084 {
2085 const char *default_event_name, *default_chan_name;
2086 struct agent *agt;
2087 struct lttng_event uevent;
2088 struct lttng_domain tmp_dom;
2089 struct ltt_ust_session *usess = session->ust_session;
2090
2091 assert(usess);
2092
2093 agt = trace_ust_find_agent(usess, domain->type);
2094 if (!agt) {
2095 agt = agent_create(domain->type);
2096 if (!agt) {
2097 ret = LTTNG_ERR_NOMEM;
2098 goto error;
2099 }
2100 agent_add(agt, usess->agents);
2101 }
2102
2103 /* Create the default tracepoint. */
2104 memset(&uevent, 0, sizeof(uevent));
2105 uevent.type = LTTNG_EVENT_TRACEPOINT;
2106 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
2107 default_event_name = event_get_default_agent_ust_name(
2108 domain->type);
2109 if (!default_event_name) {
2110 ret = LTTNG_ERR_FATAL;
2111 goto error;
2112 }
2113 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
2114 uevent.name[sizeof(uevent.name) - 1] = '\0';
2115
2116 /*
2117 * The domain type is changed because we are about to enable the
2118 * default channel and event for the JUL domain that are hardcoded.
2119 * This happens in the UST domain.
2120 */
2121 memcpy(&tmp_dom, domain, sizeof(tmp_dom));
2122 tmp_dom.type = LTTNG_DOMAIN_UST;
2123
2124 switch (domain->type) {
2125 case LTTNG_DOMAIN_LOG4J:
2126 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
2127 break;
2128 case LTTNG_DOMAIN_JUL:
2129 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
2130 break;
2131 case LTTNG_DOMAIN_PYTHON:
2132 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2133 break;
2134 default:
2135 /* The switch/case we are in makes this impossible */
2136 assert(0);
2137 }
2138
2139 {
2140 char *filter_expression_copy = NULL;
2141 struct lttng_filter_bytecode *filter_copy = NULL;
2142
2143 if (filter) {
2144 const size_t filter_size = sizeof(
2145 struct lttng_filter_bytecode)
2146 + filter->len;
2147
2148 filter_copy = zmalloc(filter_size);
2149 if (!filter_copy) {
2150 ret = LTTNG_ERR_NOMEM;
2151 goto error;
2152 }
2153 memcpy(filter_copy, filter, filter_size);
2154
2155 filter_expression_copy =
2156 strdup(filter_expression);
2157 if (!filter_expression) {
2158 ret = LTTNG_ERR_NOMEM;
2159 }
2160
2161 if (!filter_expression_copy || !filter_copy) {
2162 free(filter_expression_copy);
2163 free(filter_copy);
2164 goto error;
2165 }
2166 }
2167
2168 ret = cmd_enable_event_internal(session, &tmp_dom,
2169 (char *) default_chan_name,
2170 &uevent, filter_expression_copy,
2171 filter_copy, NULL, wpipe);
2172 }
2173
2174 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2175 goto already_enabled;
2176 } else if (ret != LTTNG_OK) {
2177 goto error;
2178 }
2179
2180 /* The wild card * means that everything should be enabled. */
2181 if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
2182 ret = event_agent_enable_all(usess, agt, event, filter,
2183 filter_expression);
2184 } else {
2185 ret = event_agent_enable(usess, agt, event, filter,
2186 filter_expression);
2187 }
2188 filter = NULL;
2189 filter_expression = NULL;
2190 if (ret != LTTNG_OK) {
2191 goto error;
2192 }
2193
2194 break;
2195 }
2196 default:
2197 ret = LTTNG_ERR_UND;
2198 goto error;
2199 }
2200
2201 ret = LTTNG_OK;
2202
2203 already_enabled:
2204 error:
2205 free(filter_expression);
2206 free(filter);
2207 free(exclusion);
2208 channel_attr_destroy(attr);
2209 rcu_read_unlock();
2210 return ret;
2211 }
2212
2213 /*
2214 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2215 * We own filter, exclusion, and filter_expression.
2216 */
2217 int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
2218 char *channel_name, struct lttng_event *event,
2219 char *filter_expression,
2220 struct lttng_filter_bytecode *filter,
2221 struct lttng_event_exclusion *exclusion,
2222 int wpipe)
2223 {
2224 return _cmd_enable_event(session, domain, channel_name, event,
2225 filter_expression, filter, exclusion, wpipe, false);
2226 }
2227
2228 /*
2229 * Enable an event which is internal to LTTng. An internal should
2230 * never be made visible to clients and are immune to checks such as
2231 * reserved names.
2232 */
2233 static int cmd_enable_event_internal(struct ltt_session *session,
2234 struct lttng_domain *domain,
2235 char *channel_name, struct lttng_event *event,
2236 char *filter_expression,
2237 struct lttng_filter_bytecode *filter,
2238 struct lttng_event_exclusion *exclusion,
2239 int wpipe)
2240 {
2241 return _cmd_enable_event(session, domain, channel_name, event,
2242 filter_expression, filter, exclusion, wpipe, true);
2243 }
2244
2245 /*
2246 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2247 */
2248 ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
2249 struct lttng_event **events)
2250 {
2251 int ret;
2252 ssize_t nb_events = 0;
2253
2254 switch (domain) {
2255 case LTTNG_DOMAIN_KERNEL:
2256 nb_events = kernel_list_events(kernel_tracer_fd, events);
2257 if (nb_events < 0) {
2258 ret = LTTNG_ERR_KERN_LIST_FAIL;
2259 goto error;
2260 }
2261 break;
2262 case LTTNG_DOMAIN_UST:
2263 nb_events = ust_app_list_events(events);
2264 if (nb_events < 0) {
2265 ret = LTTNG_ERR_UST_LIST_FAIL;
2266 goto error;
2267 }
2268 break;
2269 case LTTNG_DOMAIN_LOG4J:
2270 case LTTNG_DOMAIN_JUL:
2271 case LTTNG_DOMAIN_PYTHON:
2272 nb_events = agent_list_events(events, domain);
2273 if (nb_events < 0) {
2274 ret = LTTNG_ERR_UST_LIST_FAIL;
2275 goto error;
2276 }
2277 break;
2278 default:
2279 ret = LTTNG_ERR_UND;
2280 goto error;
2281 }
2282
2283 return nb_events;
2284
2285 error:
2286 /* Return negative value to differentiate return code */
2287 return -ret;
2288 }
2289
2290 /*
2291 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2292 */
2293 ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2294 struct lttng_event_field **fields)
2295 {
2296 int ret;
2297 ssize_t nb_fields = 0;
2298
2299 switch (domain) {
2300 case LTTNG_DOMAIN_UST:
2301 nb_fields = ust_app_list_event_fields(fields);
2302 if (nb_fields < 0) {
2303 ret = LTTNG_ERR_UST_LIST_FAIL;
2304 goto error;
2305 }
2306 break;
2307 case LTTNG_DOMAIN_KERNEL:
2308 default: /* fall-through */
2309 ret = LTTNG_ERR_UND;
2310 goto error;
2311 }
2312
2313 return nb_fields;
2314
2315 error:
2316 /* Return negative value to differentiate return code */
2317 return -ret;
2318 }
2319
2320 ssize_t cmd_list_syscalls(struct lttng_event **events)
2321 {
2322 return syscall_table_list(events);
2323 }
2324
2325 /*
2326 * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
2327 *
2328 * Called with session lock held.
2329 */
2330 ssize_t cmd_list_tracker_pids(struct ltt_session *session,
2331 enum lttng_domain_type domain, int32_t **pids)
2332 {
2333 int ret;
2334 ssize_t nr_pids = 0;
2335
2336 switch (domain) {
2337 case LTTNG_DOMAIN_KERNEL:
2338 {
2339 struct ltt_kernel_session *ksess;
2340
2341 ksess = session->kernel_session;
2342 nr_pids = kernel_list_tracker_pids(ksess, pids);
2343 if (nr_pids < 0) {
2344 ret = LTTNG_ERR_KERN_LIST_FAIL;
2345 goto error;
2346 }
2347 break;
2348 }
2349 case LTTNG_DOMAIN_UST:
2350 {
2351 struct ltt_ust_session *usess;
2352
2353 usess = session->ust_session;
2354 nr_pids = trace_ust_list_tracker_pids(usess, pids);
2355 if (nr_pids < 0) {
2356 ret = LTTNG_ERR_UST_LIST_FAIL;
2357 goto error;
2358 }
2359 break;
2360 }
2361 case LTTNG_DOMAIN_LOG4J:
2362 case LTTNG_DOMAIN_JUL:
2363 case LTTNG_DOMAIN_PYTHON:
2364 default:
2365 ret = LTTNG_ERR_UND;
2366 goto error;
2367 }
2368
2369 return nr_pids;
2370
2371 error:
2372 /* Return negative value to differentiate return code */
2373 return -ret;
2374 }
2375
2376 static
2377 int domain_mkdir(const struct consumer_output *output,
2378 const struct ltt_session *session,
2379 uid_t uid, gid_t gid)
2380 {
2381 struct consumer_socket *socket;
2382 struct lttng_ht_iter iter;
2383 int ret;
2384 char *path = NULL;
2385
2386 if (!output || !output->socks) {
2387 ERR("No consumer output found");
2388 ret = -1;
2389 goto end;
2390 }
2391
2392 path = zmalloc(LTTNG_PATH_MAX * sizeof(char));
2393 if (!path) {
2394 ERR("Cannot allocate mkdir path");
2395 ret = -1;
2396 goto end;
2397 }
2398
2399 ret = snprintf(path, LTTNG_PATH_MAX, "%s%s%s",
2400 session_get_base_path(session),
2401 output->chunk_path, output->subdir);
2402 if (ret < 0 || ret >= LTTNG_PATH_MAX) {
2403 ERR("Format path");
2404 ret = -1;
2405 goto end;
2406 }
2407
2408 DBG("Domain mkdir %s for session %" PRIu64, path, session->id);
2409 rcu_read_lock();
2410 /*
2411 * We have to iterate to find a socket, but we only need to send the
2412 * rename command to one consumer, so we break after the first one.
2413 */
2414 cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) {
2415 pthread_mutex_lock(socket->lock);
2416 ret = consumer_mkdir(socket, session->id, output, path, uid, gid);
2417 pthread_mutex_unlock(socket->lock);
2418 if (ret) {
2419 ERR("Consumer mkdir");
2420 ret = -1;
2421 goto end_unlock;
2422 }
2423 break;
2424 }
2425
2426 ret = 0;
2427
2428 end_unlock:
2429 rcu_read_unlock();
2430 end:
2431 free(path);
2432 return ret;
2433 }
2434
2435 static
2436 int session_mkdir(const struct ltt_session *session)
2437 {
2438 int ret;
2439 struct consumer_output *output;
2440 uid_t uid;
2441 gid_t gid;
2442
2443 /*
2444 * Unsupported feature in lttng-relayd before 2.11, not an error since it
2445 * is only needed for session rotation and the user will get an error
2446 * on rotate.
2447 */
2448 if (session->consumer->type == CONSUMER_DST_NET &&
2449 session->consumer->relay_major_version == 2 &&
2450 session->consumer->relay_minor_version < 11) {
2451 ret = 0;
2452 goto end;
2453 }
2454
2455 if (session->kernel_session) {
2456 output = session->kernel_session->consumer;
2457 uid = session->kernel_session->uid;
2458 gid = session->kernel_session->gid;
2459 ret = domain_mkdir(output, session, uid, gid);
2460 if (ret) {
2461 ERR("Mkdir kernel");
2462 goto end;
2463 }
2464 }
2465
2466 if (session->ust_session) {
2467 output = session->ust_session->consumer;
2468 uid = session->ust_session->uid;
2469 gid = session->ust_session->gid;
2470 ret = domain_mkdir(output, session, uid, gid);
2471 if (ret) {
2472 ERR("Mkdir UST");
2473 goto end;
2474 }
2475 }
2476
2477 ret = 0;
2478
2479 end:
2480 return ret;
2481 }
2482
2483 /*
2484 * Command LTTNG_START_TRACE processed by the client thread.
2485 *
2486 * Called with session mutex held.
2487 */
2488 int cmd_start_trace(struct ltt_session *session)
2489 {
2490 int ret;
2491 unsigned long nb_chan = 0;
2492 struct ltt_kernel_session *ksession;
2493 struct ltt_ust_session *usess;
2494
2495 assert(session);
2496
2497 /* Ease our life a bit ;) */
2498 ksession = session->kernel_session;
2499 usess = session->ust_session;
2500
2501 /* Is the session already started? */
2502 if (session->active) {
2503 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2504 goto error;
2505 }
2506
2507 /*
2508 * Starting a session without channel is useless since after that it's not
2509 * possible to enable channel thus inform the client.
2510 */
2511 if (usess && usess->domain_global.channels) {
2512 nb_chan += lttng_ht_get_count(usess->domain_global.channels);
2513 }
2514 if (ksession) {
2515 nb_chan += ksession->channel_count;
2516 }
2517 if (!nb_chan) {
2518 ret = LTTNG_ERR_NO_CHANNEL;
2519 goto error;
2520 }
2521
2522 if (!session->has_been_started) {
2523 if (!session->snapshot_mode && session->output_traces) {
2524 ret = session_mkdir(session);
2525 if (ret) {
2526 ERR("Failed to create the session directories");
2527 ret = LTTNG_ERR_CREATE_DIR_FAIL;
2528 goto error;
2529 }
2530 }
2531 }
2532
2533 /* Kernel tracing */
2534 if (ksession != NULL) {
2535 DBG("Start kernel tracing session %s", session->name);
2536 ret = start_kernel_session(ksession, kernel_tracer_fd);
2537 if (ret != LTTNG_OK) {
2538 goto error;
2539 }
2540 }
2541
2542 /* Flag session that trace should start automatically */
2543 if (usess) {
2544 /*
2545 * Even though the start trace might fail, flag this session active so
2546 * other application coming in are started by default.
2547 */
2548 usess->active = 1;
2549
2550 ret = ust_app_start_trace_all(usess);
2551 if (ret < 0) {
2552 ret = LTTNG_ERR_UST_START_FAIL;
2553 goto error;
2554 }
2555 }
2556
2557 /* Flag this after a successful start. */
2558 session->has_been_started = 1;
2559 session->active = 1;
2560
2561 ret = LTTNG_OK;
2562
2563 error:
2564 return ret;
2565 }
2566
2567 /*
2568 * Command LTTNG_STOP_TRACE processed by the client thread.
2569 */
2570 int cmd_stop_trace(struct ltt_session *session)
2571 {
2572 int ret;
2573 struct ltt_kernel_channel *kchan;
2574 struct ltt_kernel_session *ksession;
2575 struct ltt_ust_session *usess;
2576
2577 assert(session);
2578
2579 /* Short cut */
2580 ksession = session->kernel_session;
2581 usess = session->ust_session;
2582
2583 /* Session is not active. Skip everythong and inform the client. */
2584 if (!session->active) {
2585 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2586 goto error;
2587 }
2588
2589 /* Kernel tracer */
2590 if (ksession && ksession->active) {
2591 DBG("Stop kernel tracing");
2592
2593 ret = kernel_stop_session(ksession);
2594 if (ret < 0) {
2595 ret = LTTNG_ERR_KERN_STOP_FAIL;
2596 goto error;
2597 }
2598
2599 kernel_wait_quiescent(kernel_tracer_fd);
2600
2601 /* Flush metadata after stopping (if exists) */
2602 if (ksession->metadata_stream_fd >= 0) {
2603 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
2604 if (ret < 0) {
2605 ERR("Kernel metadata flush failed");
2606 }
2607 }
2608
2609 /* Flush all buffers after stopping */
2610 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2611 ret = kernel_flush_buffer(kchan);
2612 if (ret < 0) {
2613 ERR("Kernel flush buffer error");
2614 }
2615 }
2616
2617 ksession->active = 0;
2618 }
2619
2620 if (usess && usess->active) {
2621 /*
2622 * Even though the stop trace might fail, flag this session inactive so
2623 * other application coming in are not started by default.
2624 */
2625 usess->active = 0;
2626
2627 ret = ust_app_stop_trace_all(usess);
2628 if (ret < 0) {
2629 ret = LTTNG_ERR_UST_STOP_FAIL;
2630 goto error;
2631 }
2632 }
2633
2634 /* Flag inactive after a successful stop. */
2635 session->active = 0;
2636 ret = LTTNG_OK;
2637
2638 error:
2639 return ret;
2640 }
2641
2642 /*
2643 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2644 */
2645 int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2646 struct lttng_uri *uris)
2647 {
2648 int ret, i;
2649 struct ltt_kernel_session *ksess = session->kernel_session;
2650 struct ltt_ust_session *usess = session->ust_session;
2651
2652 assert(session);
2653 assert(uris);
2654 assert(nb_uri > 0);
2655
2656 /* Can't set consumer URI if the session is active. */
2657 if (session->active) {
2658 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2659 goto error;
2660 }
2661
2662 /* Set the "global" consumer URIs */
2663 for (i = 0; i < nb_uri; i++) {
2664 ret = add_uri_to_consumer(session->consumer,
2665 &uris[i], 0, session->name);
2666 if (ret != LTTNG_OK) {
2667 goto error;
2668 }
2669 }
2670
2671 /* Set UST session URIs */
2672 if (session->ust_session) {
2673 for (i = 0; i < nb_uri; i++) {
2674 ret = add_uri_to_consumer(
2675 session->ust_session->consumer,
2676 &uris[i], LTTNG_DOMAIN_UST,
2677 session->name);
2678 if (ret != LTTNG_OK) {
2679 goto error;
2680 }
2681 }
2682 }
2683
2684 /* Set kernel session URIs */
2685 if (session->kernel_session) {
2686 for (i = 0; i < nb_uri; i++) {
2687 ret = add_uri_to_consumer(
2688 session->kernel_session->consumer,
2689 &uris[i], LTTNG_DOMAIN_KERNEL,
2690 session->name);
2691 if (ret != LTTNG_OK) {
2692 goto error;
2693 }
2694 }
2695 }
2696
2697 /*
2698 * Make sure to set the session in output mode after we set URI since a
2699 * session can be created without URL (thus flagged in no output mode).
2700 */
2701 session->output_traces = 1;
2702 if (ksess) {
2703 ksess->output_traces = 1;
2704 }
2705
2706 if (usess) {
2707 usess->output_traces = 1;
2708 }
2709
2710 /* All good! */
2711 ret = LTTNG_OK;
2712
2713 error:
2714 return ret;
2715 }
2716
2717 /*
2718 * Command LTTNG_CREATE_SESSION processed by the client thread.
2719 */
2720 int cmd_create_session_uri(char *name, struct lttng_uri *uris,
2721 size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer)
2722 {
2723 int ret;
2724 struct ltt_session *session;
2725
2726 assert(name);
2727 assert(creds);
2728
2729 /*
2730 * Verify if the session already exist
2731 *
2732 * XXX: There is no need for the session lock list here since the caller
2733 * (process_client_msg) is holding it. We might want to change that so a
2734 * single command does not lock the entire session list.
2735 */
2736 session = session_find_by_name(name);
2737 if (session != NULL) {
2738 ret = LTTNG_ERR_EXIST_SESS;
2739 goto find_error;
2740 }
2741
2742 /* Create tracing session in the registry */
2743 ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds),
2744 LTTNG_SOCK_GET_GID_CRED(creds));
2745 if (ret != LTTNG_OK) {
2746 goto session_error;
2747 }
2748
2749 /*
2750 * Get the newly created session pointer back
2751 *
2752 * XXX: There is no need for the session lock list here since the caller
2753 * (process_client_msg) is holding it. We might want to change that so a
2754 * single command does not lock the entire session list.
2755 */
2756 session = session_find_by_name(name);
2757 assert(session);
2758
2759 session->live_timer = live_timer;
2760 /* Create default consumer output for the session not yet created. */
2761 session->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
2762 if (session->consumer == NULL) {
2763 ret = LTTNG_ERR_FATAL;
2764 goto consumer_error;
2765 }
2766
2767 if (uris) {
2768 ret = cmd_set_consumer_uri(session, nb_uri, uris);
2769 if (ret != LTTNG_OK) {
2770 goto consumer_error;
2771 }
2772 session->output_traces = 1;
2773 } else {
2774 session->output_traces = 0;
2775 DBG2("Session %s created with no output", session->name);
2776 }
2777
2778 session->consumer->enabled = 1;
2779
2780 return LTTNG_OK;
2781
2782 consumer_error:
2783 session_destroy(session);
2784 session_error:
2785 find_error:
2786 return ret;
2787 }
2788
2789 /*
2790 * Command LTTNG_CREATE_SESSION_SNAPSHOT processed by the client thread.
2791 */
2792 int cmd_create_session_snapshot(char *name, struct lttng_uri *uris,
2793 size_t nb_uri, lttng_sock_cred *creds)
2794 {
2795 int ret;
2796 struct ltt_session *session;
2797 struct snapshot_output *new_output = NULL;
2798
2799 assert(name);
2800 assert(creds);
2801
2802 /*
2803 * Create session in no output mode with URIs set to NULL. The uris we've
2804 * received are for a default snapshot output if one.
2805 */
2806 ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
2807 if (ret != LTTNG_OK) {
2808 goto error;
2809 }
2810
2811 /* Get the newly created session pointer back. This should NEVER fail. */
2812 session = session_find_by_name(name);
2813 assert(session);
2814
2815 /* Flag session for snapshot mode. */
2816 session->snapshot_mode = 1;
2817
2818 /* Skip snapshot output creation if no URI is given. */
2819 if (nb_uri == 0) {
2820 goto end;
2821 }
2822
2823 new_output = snapshot_output_alloc();
2824 if (!new_output) {
2825 ret = LTTNG_ERR_NOMEM;
2826 goto error_snapshot_alloc;
2827 }
2828
2829 ret = snapshot_output_init_with_uri(DEFAULT_SNAPSHOT_MAX_SIZE, NULL,
2830 uris, nb_uri, session->consumer, new_output, &session->snapshot);
2831 if (ret < 0) {
2832 if (ret == -ENOMEM) {
2833 ret = LTTNG_ERR_NOMEM;
2834 } else {
2835 ret = LTTNG_ERR_INVALID;
2836 }
2837 goto error_snapshot;
2838 }
2839
2840 rcu_read_lock();
2841 snapshot_add_output(&session->snapshot, new_output);
2842 rcu_read_unlock();
2843
2844 end:
2845 return LTTNG_OK;
2846
2847 error_snapshot:
2848 snapshot_output_destroy(new_output);
2849 error_snapshot_alloc:
2850 session_destroy(session);
2851 error:
2852 return ret;
2853 }
2854
2855 /*
2856 * Command LTTNG_DESTROY_SESSION processed by the client thread.
2857 *
2858 * Called with session lock held.
2859 */
2860 int cmd_destroy_session(struct ltt_session *session, int wpipe)
2861 {
2862 int ret;
2863 struct ltt_ust_session *usess;
2864 struct ltt_kernel_session *ksess;
2865
2866 /* Safety net */
2867 assert(session);
2868
2869 usess = session->ust_session;
2870 ksess = session->kernel_session;
2871
2872 /* Clean kernel session teardown */
2873 kernel_destroy_session(ksess);
2874
2875 /* UST session teardown */
2876 if (usess) {
2877 /* Close any relayd session */
2878 consumer_output_send_destroy_relayd(usess->consumer);
2879
2880 /* Destroy every UST application related to this session. */
2881 ret = ust_app_destroy_trace_all(usess);
2882 if (ret) {
2883 ERR("Error in ust_app_destroy_trace_all");
2884 }
2885
2886 /* Clean up the rest. */
2887 trace_ust_destroy_session(usess);
2888 }
2889
2890 /*
2891 * Must notify the kernel thread here to update it's poll set in order to
2892 * remove the channel(s)' fd just destroyed.
2893 */
2894 ret = notify_thread_pipe(wpipe);
2895 if (ret < 0) {
2896 PERROR("write kernel poll pipe");
2897 }
2898
2899 ret = session_destroy(session);
2900
2901 return ret;
2902 }
2903
2904 /*
2905 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
2906 */
2907 int cmd_register_consumer(struct ltt_session *session,
2908 enum lttng_domain_type domain, const char *sock_path,
2909 struct consumer_data *cdata)
2910 {
2911 int ret, sock;
2912 struct consumer_socket *socket = NULL;
2913
2914 assert(session);
2915 assert(cdata);
2916 assert(sock_path);
2917
2918 switch (domain) {
2919 case LTTNG_DOMAIN_KERNEL:
2920 {
2921 struct ltt_kernel_session *ksess = session->kernel_session;
2922
2923 assert(ksess);
2924
2925 /* Can't register a consumer if there is already one */
2926 if (ksess->consumer_fds_sent != 0) {
2927 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2928 goto error;
2929 }
2930
2931 sock = lttcomm_connect_unix_sock(sock_path);
2932 if (sock < 0) {
2933 ret = LTTNG_ERR_CONNECT_FAIL;
2934 goto error;
2935 }
2936 cdata->cmd_sock = sock;
2937
2938 socket = consumer_allocate_socket(&cdata->cmd_sock);
2939 if (socket == NULL) {
2940 ret = close(sock);
2941 if (ret < 0) {
2942 PERROR("close register consumer");
2943 }
2944 cdata->cmd_sock = -1;
2945 ret = LTTNG_ERR_FATAL;
2946 goto error;
2947 }
2948
2949 socket->lock = zmalloc(sizeof(pthread_mutex_t));
2950 if (socket->lock == NULL) {
2951 PERROR("zmalloc pthread mutex");
2952 ret = LTTNG_ERR_FATAL;
2953 goto error;
2954 }
2955 pthread_mutex_init(socket->lock, NULL);
2956 socket->registered = 1;
2957
2958 rcu_read_lock();
2959 consumer_add_socket(socket, ksess->consumer);
2960 rcu_read_unlock();
2961
2962 pthread_mutex_lock(&cdata->pid_mutex);
2963 cdata->pid = -1;
2964 pthread_mutex_unlock(&cdata->pid_mutex);
2965
2966 break;
2967 }
2968 default:
2969 /* TODO: Userspace tracing */
2970 ret = LTTNG_ERR_UND;
2971 goto error;
2972 }
2973
2974 return LTTNG_OK;
2975
2976 error:
2977 if (socket) {
2978 consumer_destroy_socket(socket);
2979 }
2980 return ret;
2981 }
2982
2983 /*
2984 * Command LTTNG_LIST_DOMAINS processed by the client thread.
2985 */
2986 ssize_t cmd_list_domains(struct ltt_session *session,
2987 struct lttng_domain **domains)
2988 {
2989 int ret, index = 0;
2990 ssize_t nb_dom = 0;
2991 struct agent *agt;
2992 struct lttng_ht_iter iter;
2993
2994 if (session->kernel_session != NULL) {
2995 DBG3("Listing domains found kernel domain");
2996 nb_dom++;
2997 }
2998
2999 if (session->ust_session != NULL) {
3000 DBG3("Listing domains found UST global domain");
3001 nb_dom++;
3002
3003 rcu_read_lock();
3004 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3005 agt, node.node) {
3006 if (agt->being_used) {
3007 nb_dom++;
3008 }
3009 }
3010 rcu_read_unlock();
3011 }
3012
3013 if (!nb_dom) {
3014 goto end;
3015 }
3016
3017 *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
3018 if (*domains == NULL) {
3019 ret = LTTNG_ERR_FATAL;
3020 goto error;
3021 }
3022
3023 if (session->kernel_session != NULL) {
3024 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
3025
3026 /* Kernel session buffer type is always GLOBAL */
3027 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
3028
3029 index++;
3030 }
3031
3032 if (session->ust_session != NULL) {
3033 (*domains)[index].type = LTTNG_DOMAIN_UST;
3034 (*domains)[index].buf_type = session->ust_session->buffer_type;
3035 index++;
3036
3037 rcu_read_lock();
3038 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3039 agt, node.node) {
3040 if (agt->being_used) {
3041 (*domains)[index].type = agt->domain;
3042 (*domains)[index].buf_type = session->ust_session->buffer_type;
3043 index++;
3044 }
3045 }
3046 rcu_read_unlock();
3047 }
3048 end:
3049 return nb_dom;
3050
3051 error:
3052 /* Return negative value to differentiate return code */
3053 return -ret;
3054 }
3055
3056
3057 /*
3058 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3059 */
3060 ssize_t cmd_list_channels(enum lttng_domain_type domain,
3061 struct ltt_session *session, struct lttng_channel **channels)
3062 {
3063 ssize_t nb_chan = 0, payload_size = 0, ret;
3064
3065 switch (domain) {
3066 case LTTNG_DOMAIN_KERNEL:
3067 if (session->kernel_session != NULL) {
3068 nb_chan = session->kernel_session->channel_count;
3069 }
3070 DBG3("Number of kernel channels %zd", nb_chan);
3071 if (nb_chan <= 0) {
3072 ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
3073 goto end;
3074 }
3075 break;
3076 case LTTNG_DOMAIN_UST:
3077 if (session->ust_session != NULL) {
3078 rcu_read_lock();
3079 nb_chan = lttng_ht_get_count(
3080 session->ust_session->domain_global.channels);
3081 rcu_read_unlock();
3082 }
3083 DBG3("Number of UST global channels %zd", nb_chan);
3084 if (nb_chan < 0) {
3085 ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
3086 goto end;
3087 }
3088 break;
3089 default:
3090 ret = -LTTNG_ERR_UND;
3091 goto end;
3092 }
3093
3094 if (nb_chan > 0) {
3095 const size_t channel_size = sizeof(struct lttng_channel) +
3096 sizeof(struct lttng_channel_extended);
3097 struct lttng_channel_extended *channel_exts;
3098
3099 payload_size = nb_chan * channel_size;
3100 *channels = zmalloc(payload_size);
3101 if (*channels == NULL) {
3102 ret = -LTTNG_ERR_FATAL;
3103 goto end;
3104 }
3105
3106 channel_exts = ((void *) *channels) +
3107 (nb_chan * sizeof(struct lttng_channel));
3108 ret = list_lttng_channels(domain, session, *channels, channel_exts);
3109 if (ret != LTTNG_OK) {
3110 free(*channels);
3111 *channels = NULL;
3112 goto end;
3113 }
3114 } else {
3115 *channels = NULL;
3116 }
3117
3118 ret = payload_size;
3119 end:
3120 return ret;
3121 }
3122
3123 /*
3124 * Command LTTNG_LIST_EVENTS processed by the client thread.
3125 */
3126 ssize_t cmd_list_events(enum lttng_domain_type domain,
3127 struct ltt_session *session, char *channel_name,
3128 struct lttng_event **events, size_t *total_size)
3129 {
3130 int ret = 0;
3131 ssize_t nb_event = 0;
3132
3133 switch (domain) {
3134 case LTTNG_DOMAIN_KERNEL:
3135 if (session->kernel_session != NULL) {
3136 nb_event = list_lttng_kernel_events(channel_name,
3137 session->kernel_session, events,
3138 total_size);
3139 }
3140 break;
3141 case LTTNG_DOMAIN_UST:
3142 {
3143 if (session->ust_session != NULL) {
3144 nb_event = list_lttng_ust_global_events(channel_name,
3145 &session->ust_session->domain_global, events,
3146 total_size);
3147 }
3148 break;
3149 }
3150 case LTTNG_DOMAIN_LOG4J:
3151 case LTTNG_DOMAIN_JUL:
3152 case LTTNG_DOMAIN_PYTHON:
3153 if (session->ust_session) {
3154 struct lttng_ht_iter iter;
3155 struct agent *agt;
3156
3157 rcu_read_lock();
3158 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3159 &iter.iter, agt, node.node) {
3160 if (agt->domain == domain) {
3161 nb_event = list_lttng_agent_events(
3162 agt, events,
3163 total_size);
3164 break;
3165 }
3166 }
3167 rcu_read_unlock();
3168 }
3169 break;
3170 default:
3171 ret = LTTNG_ERR_UND;
3172 goto error;
3173 }
3174
3175 return nb_event;
3176
3177 error:
3178 /* Return negative value to differentiate return code */
3179 return -ret;
3180 }
3181
3182 /*
3183 * Using the session list, filled a lttng_session array to send back to the
3184 * client for session listing.
3185 *
3186 * The session list lock MUST be acquired before calling this function. Use
3187 * session_lock_list() and session_unlock_list().
3188 */
3189 void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid,
3190 gid_t gid)
3191 {
3192 int ret;
3193 unsigned int i = 0;
3194 struct ltt_session *session;
3195 struct ltt_session_list *list = session_get_list();
3196
3197 DBG("Getting all available session for UID %d GID %d",
3198 uid, gid);
3199 /*
3200 * Iterate over session list and append data after the control struct in
3201 * the buffer.
3202 */
3203 cds_list_for_each_entry(session, &list->head, list) {
3204 /*
3205 * Only list the sessions the user can control.
3206 */
3207 if (!session_access_ok(session, uid, gid)) {
3208 continue;
3209 }
3210
3211 struct ltt_kernel_session *ksess = session->kernel_session;
3212 struct ltt_ust_session *usess = session->ust_session;
3213
3214 if (session->consumer->type == CONSUMER_DST_NET ||
3215 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3216 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3217 ret = build_network_session_path(sessions[i].path,
3218 sizeof(sessions[i].path), session);
3219 } else {
3220 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
3221 session->consumer->dst.session_root_path);
3222 }
3223 if (ret < 0) {
3224 PERROR("snprintf session path");
3225 continue;
3226 }
3227
3228 strncpy(sessions[i].name, session->name, NAME_MAX);
3229 sessions[i].name[NAME_MAX - 1] = '\0';
3230 sessions[i].enabled = session->active;
3231 sessions[i].snapshot_mode = session->snapshot_mode;
3232 sessions[i].live_timer_interval = session->live_timer;
3233 i++;
3234 }
3235 }
3236
3237 /*
3238 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
3239 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
3240 */
3241 int cmd_data_pending(struct ltt_session *session)
3242 {
3243 int ret;
3244 struct ltt_kernel_session *ksess = session->kernel_session;
3245 struct ltt_ust_session *usess = session->ust_session;
3246
3247 assert(session);
3248
3249 /* Session MUST be stopped to ask for data availability. */
3250 if (session->active) {
3251 ret = LTTNG_ERR_SESSION_STARTED;
3252 goto error;
3253 } else {
3254 /*
3255 * If stopped, just make sure we've started before else the above call
3256 * will always send that there is data pending.
3257 *
3258 * The consumer assumes that when the data pending command is received,
3259 * the trace has been started before or else no output data is written
3260 * by the streams which is a condition for data pending. So, this is
3261 * *VERY* important that we don't ask the consumer before a start
3262 * trace.
3263 */
3264 if (!session->has_been_started) {
3265 ret = 0;
3266 goto error;
3267 }
3268 }
3269
3270 if (ksess && ksess->consumer) {
3271 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
3272 if (ret == 1) {
3273 /* Data is still being extracted for the kernel. */
3274 goto error;
3275 }
3276 }
3277
3278 if (usess && usess->consumer) {
3279 ret = consumer_is_data_pending(usess->id, usess->consumer);
3280 if (ret == 1) {
3281 /* Data is still being extracted for the kernel. */
3282 goto error;
3283 }
3284 }
3285
3286 /* Data is ready to be read by a viewer */
3287 ret = 0;
3288
3289 error:
3290 return ret;
3291 }
3292
3293 /*
3294 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
3295 *
3296 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3297 */
3298 int cmd_snapshot_add_output(struct ltt_session *session,
3299 struct lttng_snapshot_output *output, uint32_t *id)
3300 {
3301 int ret;
3302 struct snapshot_output *new_output;
3303
3304 assert(session);
3305 assert(output);
3306
3307 DBG("Cmd snapshot add output for session %s", session->name);
3308
3309 /*
3310 * Can't create an output if the session is not set in no-output mode.
3311 */
3312 if (session->output_traces) {
3313 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3314 goto error;
3315 }
3316
3317 /* Only one output is allowed until we have the "tee" feature. */
3318 if (session->snapshot.nb_output == 1) {
3319 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
3320 goto error;
3321 }
3322
3323 new_output = snapshot_output_alloc();
3324 if (!new_output) {
3325 ret = LTTNG_ERR_NOMEM;
3326 goto error;
3327 }
3328
3329 ret = snapshot_output_init(output->max_size, output->name,
3330 output->ctrl_url, output->data_url, session->consumer, new_output,
3331 &session->snapshot);
3332 if (ret < 0) {
3333 if (ret == -ENOMEM) {
3334 ret = LTTNG_ERR_NOMEM;
3335 } else {
3336 ret = LTTNG_ERR_INVALID;
3337 }
3338 goto free_error;
3339 }
3340
3341 rcu_read_lock();
3342 snapshot_add_output(&session->snapshot, new_output);
3343 if (id) {
3344 *id = new_output->id;
3345 }
3346 rcu_read_unlock();
3347
3348 return LTTNG_OK;
3349
3350 free_error:
3351 snapshot_output_destroy(new_output);
3352 error:
3353 return ret;
3354 }
3355
3356 /*
3357 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
3358 *
3359 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3360 */
3361 int cmd_snapshot_del_output(struct ltt_session *session,
3362 struct lttng_snapshot_output *output)
3363 {
3364 int ret;
3365 struct snapshot_output *sout = NULL;
3366
3367 assert(session);
3368 assert(output);
3369
3370 rcu_read_lock();
3371
3372 /*
3373 * Permission denied to create an output if the session is not
3374 * set in no output mode.
3375 */
3376 if (session->output_traces) {
3377 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3378 goto error;
3379 }
3380
3381 if (output->id) {
3382 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
3383 session->name);
3384 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
3385 } else if (*output->name != '\0') {
3386 DBG("Cmd snapshot del output name %s for session %s", output->name,
3387 session->name);
3388 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
3389 }
3390 if (!sout) {
3391 ret = LTTNG_ERR_INVALID;
3392 goto error;
3393 }
3394
3395 snapshot_delete_output(&session->snapshot, sout);
3396 snapshot_output_destroy(sout);
3397 ret = LTTNG_OK;
3398
3399 error:
3400 rcu_read_unlock();
3401 return ret;
3402 }
3403
3404 /*
3405 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
3406 *
3407 * If no output is available, outputs is untouched and 0 is returned.
3408 *
3409 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
3410 */
3411 ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
3412 struct lttng_snapshot_output **outputs)
3413 {
3414 int ret, idx = 0;
3415 struct lttng_snapshot_output *list = NULL;
3416 struct lttng_ht_iter iter;
3417 struct snapshot_output *output;
3418
3419 assert(session);
3420 assert(outputs);
3421
3422 DBG("Cmd snapshot list outputs for session %s", session->name);
3423
3424 /*
3425 * Permission denied to create an output if the session is not
3426 * set in no output mode.
3427 */
3428 if (session->output_traces) {
3429 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3430 goto end;
3431 }
3432
3433 if (session->snapshot.nb_output == 0) {
3434 ret = 0;
3435 goto end;
3436 }
3437
3438 list = zmalloc(session->snapshot.nb_output * sizeof(*list));
3439 if (!list) {
3440 ret = -LTTNG_ERR_NOMEM;
3441 goto end;
3442 }
3443
3444 /* Copy list from session to the new list object. */
3445 rcu_read_lock();
3446 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
3447 output, node.node) {
3448 assert(output->consumer);
3449 list[idx].id = output->id;
3450 list[idx].max_size = output->max_size;
3451 if (lttng_strncpy(list[idx].name, output->name,
3452 sizeof(list[idx].name))) {
3453 ret = -LTTNG_ERR_INVALID;
3454 goto error;
3455 }
3456 if (output->consumer->type == CONSUMER_DST_LOCAL) {
3457 if (lttng_strncpy(list[idx].ctrl_url,
3458 output->consumer->dst.session_root_path,
3459 sizeof(list[idx].ctrl_url))) {
3460 ret = -LTTNG_ERR_INVALID;
3461 goto error;
3462 }
3463 } else {
3464 /* Control URI. */
3465 ret = uri_to_str_url(&output->consumer->dst.net.control,
3466 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
3467 if (ret < 0) {
3468 ret = -LTTNG_ERR_NOMEM;
3469 goto error;
3470 }
3471
3472 /* Data URI. */
3473 ret = uri_to_str_url(&output->consumer->dst.net.data,
3474 list[idx].data_url, sizeof(list[idx].data_url));
3475 if (ret < 0) {
3476 ret = -LTTNG_ERR_NOMEM;
3477 goto error;
3478 }
3479 }
3480 idx++;
3481 }
3482
3483 *outputs = list;
3484 list = NULL;
3485 ret = session->snapshot.nb_output;
3486 error:
3487 rcu_read_unlock();
3488 free(list);
3489 end:
3490 return ret;
3491 }
3492
3493 /*
3494 * Check if we can regenerate the metadata for this session.
3495 * Only kernel, UST per-uid and non-live sessions are supported.
3496 *
3497 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
3498 */
3499 static
3500 int check_regenerate_metadata_support(struct ltt_session *session)
3501 {
3502 int ret;
3503
3504 assert(session);
3505
3506 if (session->live_timer != 0) {
3507 ret = LTTNG_ERR_LIVE_SESSION;
3508 goto end;
3509 }
3510 if (!session->active) {
3511 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3512 goto end;
3513 }
3514 if (session->ust_session) {
3515 switch (session->ust_session->buffer_type) {
3516 case LTTNG_BUFFER_PER_UID:
3517 break;
3518 case LTTNG_BUFFER_PER_PID:
3519 ret = LTTNG_ERR_PER_PID_SESSION;
3520 goto end;
3521 default:
3522 assert(0);
3523 ret = LTTNG_ERR_UNK;
3524 goto end;
3525 }
3526 }
3527 if (session->consumer->type == CONSUMER_DST_NET &&
3528 session->consumer->relay_minor_version < 8) {
3529 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
3530 goto end;
3531 }
3532 ret = 0;
3533
3534 end:
3535 return ret;
3536 }
3537
3538 static
3539 int clear_metadata_file(int fd)
3540 {
3541 int ret;
3542
3543 ret = lseek(fd, 0, SEEK_SET);
3544 if (ret < 0) {
3545 PERROR("lseek");
3546 goto end;
3547 }
3548
3549 ret = ftruncate(fd, 0);
3550 if (ret < 0) {
3551 PERROR("ftruncate");
3552 goto end;
3553 }
3554
3555 end:
3556 return ret;
3557 }
3558
3559 static
3560 int ust_regenerate_metadata(struct ltt_ust_session *usess)
3561 {
3562 int ret = 0;
3563 struct buffer_reg_uid *uid_reg = NULL;
3564 struct buffer_reg_session *session_reg = NULL;
3565
3566 rcu_read_lock();
3567 cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
3568 struct ust_registry_session *registry;
3569 struct ust_registry_channel *chan;
3570 struct lttng_ht_iter iter_chan;
3571
3572 session_reg = uid_reg->registry;
3573 registry = session_reg->reg.ust;
3574
3575 pthread_mutex_lock(&registry->lock);
3576 registry->metadata_len_sent = 0;
3577 memset(registry->metadata, 0, registry->metadata_alloc_len);
3578 registry->metadata_len = 0;
3579 registry->metadata_version++;
3580 if (registry->metadata_fd > 0) {
3581 /* Clear the metadata file's content. */
3582 ret = clear_metadata_file(registry->metadata_fd);
3583 if (ret) {
3584 pthread_mutex_unlock(&registry->lock);
3585 goto end;
3586 }
3587 }
3588
3589 ret = ust_metadata_session_statedump(registry, NULL,
3590 registry->major, registry->minor);
3591 if (ret) {
3592 pthread_mutex_unlock(&registry->lock);
3593 ERR("Failed to generate session metadata (err = %d)",
3594 ret);
3595 goto end;
3596 }
3597 cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
3598 chan, node.node) {
3599 struct ust_registry_event *event;
3600 struct lttng_ht_iter iter_event;
3601
3602 ret = ust_metadata_channel_statedump(registry, chan);
3603 if (ret) {
3604 pthread_mutex_unlock(&registry->lock);
3605 ERR("Failed to generate channel metadata "
3606 "(err = %d)", ret);
3607 goto end;
3608 }
3609 cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter,
3610 event, node.node) {
3611 ret = ust_metadata_event_statedump(registry,
3612 chan, event);
3613 if (ret) {
3614 pthread_mutex_unlock(&registry->lock);
3615 ERR("Failed to generate event metadata "
3616 "(err = %d)", ret);
3617 goto end;
3618 }
3619 }
3620 }
3621 pthread_mutex_unlock(&registry->lock);
3622 }
3623
3624 end:
3625 rcu_read_unlock();
3626 return ret;
3627 }
3628
3629 /*
3630 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
3631 *
3632 * Ask the consumer to truncate the existing metadata file(s) and
3633 * then regenerate the metadata. Live and per-pid sessions are not
3634 * supported and return an error.
3635 *
3636 * Return 0 on success or else a LTTNG_ERR code.
3637 */
3638 int cmd_regenerate_metadata(struct ltt_session *session)
3639 {
3640 int ret;
3641
3642 assert(session);
3643
3644 ret = check_regenerate_metadata_support(session);
3645 if (ret) {
3646 goto end;
3647 }
3648
3649 if (session->kernel_session) {
3650 ret = kernctl_session_regenerate_metadata(
3651 session->kernel_session->fd);
3652 if (ret < 0) {
3653 ERR("Failed to regenerate the kernel metadata");
3654 goto end;
3655 }
3656 }
3657
3658 if (session->ust_session) {
3659 ret = ust_regenerate_metadata(session->ust_session);
3660 if (ret < 0) {
3661 ERR("Failed to regenerate the UST metadata");
3662 goto end;
3663 }
3664 }
3665 DBG("Cmd metadata regenerate for session %s", session->name);
3666 ret = LTTNG_OK;
3667
3668 end:
3669 return ret;
3670 }
3671
3672 /*
3673 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
3674 *
3675 * Ask the tracer to regenerate a new statedump.
3676 *
3677 * Return 0 on success or else a LTTNG_ERR code.
3678 */
3679 int cmd_regenerate_statedump(struct ltt_session *session)
3680 {
3681 int ret;
3682
3683 assert(session);
3684
3685 if (!session->active) {
3686 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3687 goto end;
3688 }
3689
3690 if (session->kernel_session) {
3691 ret = kernctl_session_regenerate_statedump(
3692 session->kernel_session->fd);
3693 /*
3694 * Currently, the statedump in kernel can only fail if out
3695 * of memory.
3696 */
3697 if (ret < 0) {
3698 if (ret == -ENOMEM) {
3699 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
3700 } else {
3701 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3702 }
3703 ERR("Failed to regenerate the kernel statedump");
3704 goto end;
3705 }
3706 }
3707
3708 if (session->ust_session) {
3709 ret = ust_app_regenerate_statedump_all(session->ust_session);
3710 /*
3711 * Currently, the statedump in UST always returns 0.
3712 */
3713 if (ret < 0) {
3714 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3715 ERR("Failed to regenerate the UST statedump");
3716 goto end;
3717 }
3718 }
3719 DBG("Cmd regenerate statedump for session %s", session->name);
3720 ret = LTTNG_OK;
3721
3722 end:
3723 return ret;
3724 }
3725
3726 int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
3727 struct notification_thread_handle *notification_thread)
3728 {
3729 int ret;
3730 size_t trigger_len;
3731 ssize_t sock_recv_len;
3732 struct lttng_trigger *trigger = NULL;
3733 struct lttng_buffer_view view;
3734 struct lttng_dynamic_buffer trigger_buffer;
3735
3736 lttng_dynamic_buffer_init(&trigger_buffer);
3737 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3738 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3739 if (ret) {
3740 ret = LTTNG_ERR_NOMEM;
3741 goto end;
3742 }
3743
3744 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3745 trigger_len);
3746 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3747 ERR("Failed to receive \"register trigger\" command payload");
3748 /* TODO: should this be a new error enum ? */
3749 ret = LTTNG_ERR_INVALID_TRIGGER;
3750 goto end;
3751 }
3752
3753 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3754 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3755 trigger_len) {
3756 ERR("Invalid trigger payload received in \"register trigger\" command");
3757 ret = LTTNG_ERR_INVALID_TRIGGER;
3758 goto end;
3759 }
3760
3761 ret = notification_thread_command_register_trigger(notification_thread,
3762 trigger);
3763 /* Ownership of trigger was transferred. */
3764 trigger = NULL;
3765 end:
3766 lttng_trigger_destroy(trigger);
3767 lttng_dynamic_buffer_reset(&trigger_buffer);
3768 return ret;
3769 }
3770
3771 int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
3772 struct notification_thread_handle *notification_thread)
3773 {
3774 int ret;
3775 size_t trigger_len;
3776 ssize_t sock_recv_len;
3777 struct lttng_trigger *trigger = NULL;
3778 struct lttng_buffer_view view;
3779 struct lttng_dynamic_buffer trigger_buffer;
3780
3781 lttng_dynamic_buffer_init(&trigger_buffer);
3782 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3783 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3784 if (ret) {
3785 ret = LTTNG_ERR_NOMEM;
3786 goto end;
3787 }
3788
3789 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3790 trigger_len);
3791 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3792 ERR("Failed to receive \"unregister trigger\" command payload");
3793 /* TODO: should this be a new error enum ? */
3794 ret = LTTNG_ERR_INVALID_TRIGGER;
3795 goto end;
3796 }
3797
3798 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3799 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3800 trigger_len) {
3801 ERR("Invalid trigger payload received in \"unregister trigger\" command");
3802 ret = LTTNG_ERR_INVALID_TRIGGER;
3803 goto end;
3804 }
3805
3806 ret = notification_thread_command_unregister_trigger(notification_thread,
3807 trigger);
3808 end:
3809 lttng_trigger_destroy(trigger);
3810 lttng_dynamic_buffer_reset(&trigger_buffer);
3811 return ret;
3812 }
3813
3814 /*
3815 * Send relayd sockets from snapshot output to consumer. Ignore request if the
3816 * snapshot output is *not* set with a remote destination.
3817 *
3818 * Return 0 on success or a LTTNG_ERR code.
3819 */
3820 static int set_relayd_for_snapshot(struct consumer_output *consumer,
3821 struct snapshot_output *snap_output, struct ltt_session *session)
3822 {
3823 int ret = LTTNG_OK;
3824 struct lttng_ht_iter iter;
3825 struct consumer_socket *socket;
3826
3827 assert(consumer);
3828 assert(snap_output);
3829 assert(session);
3830
3831 DBG2("Set relayd object from snapshot output");
3832
3833 /* Ignore if snapshot consumer output is not network. */
3834 if (snap_output->consumer->type != CONSUMER_DST_NET) {
3835 goto error;
3836 }
3837
3838 /*
3839 * For each consumer socket, create and send the relayd object of the
3840 * snapshot output.
3841 */
3842 rcu_read_lock();
3843 cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter,
3844 socket, node.node) {
3845 pthread_mutex_lock(socket->lock);
3846 ret = send_consumer_relayd_sockets(0, session->id,
3847 snap_output->consumer, socket,
3848 session->name, session->hostname,
3849 session->live_timer);
3850 pthread_mutex_unlock(socket->lock);
3851 if (ret != LTTNG_OK) {
3852 rcu_read_unlock();
3853 goto error;
3854 }
3855 }
3856 rcu_read_unlock();
3857
3858 error:
3859 return ret;
3860 }
3861
3862 /*
3863 * Record a kernel snapshot.
3864 *
3865 * Return LTTNG_OK on success or a LTTNG_ERR code.
3866 */
3867 static int record_kernel_snapshot(struct ltt_kernel_session *ksess,
3868 struct snapshot_output *output, struct ltt_session *session,
3869 int wait, uint64_t nb_packets_per_stream)
3870 {
3871 int ret;
3872
3873 assert(ksess);
3874 assert(output);
3875 assert(session);
3876
3877
3878 /*
3879 * Copy kernel session sockets so we can communicate with the right
3880 * consumer for the snapshot record command.
3881 */
3882 ret = consumer_copy_sockets(output->consumer, ksess->consumer);
3883 if (ret < 0) {
3884 ret = LTTNG_ERR_NOMEM;
3885 goto error;
3886 }
3887
3888 ret = set_relayd_for_snapshot(ksess->consumer, output, session);
3889 if (ret != LTTNG_OK) {
3890 goto error_snapshot;
3891 }
3892
3893 ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream);
3894 if (ret != LTTNG_OK) {
3895 goto error_snapshot;
3896 }
3897
3898 ret = LTTNG_OK;
3899 goto end;
3900
3901 error_snapshot:
3902 /* Clean up copied sockets so this output can use some other later on. */
3903 consumer_destroy_output_sockets(output->consumer);
3904 error:
3905 end:
3906 return ret;
3907 }
3908
3909 /*
3910 * Record a UST snapshot.
3911 *
3912 * Return 0 on success or a LTTNG_ERR error code.
3913 */
3914 static int record_ust_snapshot(struct ltt_ust_session *usess,
3915 struct snapshot_output *output, struct ltt_session *session,
3916 int wait, uint64_t nb_packets_per_stream)
3917 {
3918 int ret;
3919
3920 assert(usess);
3921 assert(output);
3922 assert(session);
3923
3924 /*
3925 * Copy UST session sockets so we can communicate with the right
3926 * consumer for the snapshot record command.
3927 */
3928 ret = consumer_copy_sockets(output->consumer, usess->consumer);
3929 if (ret < 0) {
3930 ret = LTTNG_ERR_NOMEM;
3931 goto error;
3932 }
3933
3934 ret = set_relayd_for_snapshot(usess->consumer, output, session);
3935 if (ret != LTTNG_OK) {
3936 goto error_snapshot;
3937 }
3938
3939 ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream);
3940 if (ret < 0) {
3941 switch (-ret) {
3942 case EINVAL:
3943 ret = LTTNG_ERR_INVALID;
3944 break;
3945 default:
3946 ret = LTTNG_ERR_SNAPSHOT_FAIL;
3947 break;
3948 }
3949 goto error_snapshot;
3950 }
3951
3952 ret = LTTNG_OK;
3953
3954 error_snapshot:
3955 /* Clean up copied sockets so this output can use some other later on. */
3956 consumer_destroy_output_sockets(output->consumer);
3957 error:
3958 return ret;
3959 }
3960
3961 static
3962 uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session,
3963 uint64_t cur_nr_packets)
3964 {
3965 uint64_t tot_size = 0;
3966
3967 if (session->kernel_session) {
3968 struct ltt_kernel_channel *chan;
3969 struct ltt_kernel_session *ksess = session->kernel_session;
3970
3971 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
3972 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
3973 /*
3974 * Don't take channel into account if we
3975 * already grab all its packets.
3976 */
3977 continue;
3978 }
3979 tot_size += chan->channel->attr.subbuf_size
3980 * chan->stream_count;
3981 }
3982 }
3983
3984 if (session->ust_session) {
3985 struct ltt_ust_session *usess = session->ust_session;
3986
3987 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
3988 cur_nr_packets);
3989 }
3990
3991 return tot_size;
3992 }
3993
3994 /*
3995 * Calculate the number of packets we can grab from each stream that
3996 * fits within the overall snapshot max size.
3997 *
3998 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
3999 * the number of packets per stream.
4000 *
4001 * TODO: this approach is not perfect: we consider the worse case
4002 * (packet filling the sub-buffers) as an upper bound, but we could do
4003 * better if we do this calculation while we actually grab the packet
4004 * content: we would know how much padding we don't actually store into
4005 * the file.
4006 *
4007 * This algorithm is currently bounded by the number of packets per
4008 * stream.
4009 *
4010 * Since we call this algorithm before actually grabbing the data, it's
4011 * an approximation: for instance, applications could appear/disappear
4012 * in between this call and actually grabbing data.
4013 */
4014 static
4015 int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t max_size)
4016 {
4017 int64_t size_left;
4018 uint64_t cur_nb_packets = 0;
4019
4020 if (!max_size) {
4021 return 0; /* Infinite */
4022 }
4023
4024 size_left = max_size;
4025 for (;;) {
4026 uint64_t one_more_packet_tot_size;
4027
4028 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(session,
4029 cur_nb_packets);
4030 if (!one_more_packet_tot_size) {
4031 /* We are already grabbing all packets. */
4032 break;
4033 }
4034 size_left -= one_more_packet_tot_size;
4035 if (size_left < 0) {
4036 break;
4037 }
4038 cur_nb_packets++;
4039 }
4040 if (!cur_nb_packets) {
4041 /* Not enough room to grab one packet of each stream, error. */
4042 return -1;
4043 }
4044 return cur_nb_packets;
4045 }
4046
4047 /*
4048 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
4049 *
4050 * The wait parameter is ignored so this call always wait for the snapshot to
4051 * complete before returning.
4052 *
4053 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4054 */
4055 int cmd_snapshot_record(struct ltt_session *session,
4056 struct lttng_snapshot_output *output, int wait)
4057 {
4058 int ret = LTTNG_OK;
4059 unsigned int use_tmp_output = 0;
4060 struct snapshot_output tmp_output;
4061 unsigned int snapshot_success = 0;
4062 char datetime[16];
4063
4064 assert(session);
4065 assert(output);
4066
4067 DBG("Cmd snapshot record for session %s", session->name);
4068
4069 /* Get the datetime for the snapshot output directory. */
4070 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
4071 sizeof(datetime));
4072 if (!ret) {
4073 ret = LTTNG_ERR_INVALID;
4074 goto error;
4075 }
4076
4077 /*
4078 * Permission denied to create an output if the session is not
4079 * set in no output mode.
4080 */
4081 if (session->output_traces) {
4082 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
4083 goto error;
4084 }
4085
4086 /* The session needs to be started at least once. */
4087 if (!session->has_been_started) {
4088 ret = LTTNG_ERR_START_SESSION_ONCE;
4089 goto error;
4090 }
4091
4092 /* Use temporary output for the session. */
4093 if (*output->ctrl_url != '\0') {
4094 ret = snapshot_output_init(output->max_size, output->name,
4095 output->ctrl_url, output->data_url, session->consumer,
4096 &tmp_output, NULL);
4097 if (ret < 0) {
4098 if (ret == -ENOMEM) {
4099 ret = LTTNG_ERR_NOMEM;
4100 } else {
4101 ret = LTTNG_ERR_INVALID;
4102 }
4103 goto error;
4104 }
4105 /* Use the global session count for the temporary snapshot. */
4106 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
4107
4108 /* Use the global datetime */
4109 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
4110 use_tmp_output = 1;
4111 }
4112
4113 if (use_tmp_output) {
4114 int64_t nb_packets_per_stream;
4115
4116 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4117 tmp_output.max_size);
4118 if (nb_packets_per_stream < 0) {
4119 ret = LTTNG_ERR_MAX_SIZE_INVALID;
4120 goto error;
4121 }
4122
4123 if (session->kernel_session) {
4124 ret = record_kernel_snapshot(session->kernel_session,
4125 &tmp_output, session,
4126 wait, nb_packets_per_stream);
4127 if (ret != LTTNG_OK) {
4128 goto error;
4129 }
4130 }
4131
4132 if (session->ust_session) {
4133 ret = record_ust_snapshot(session->ust_session,
4134 &tmp_output, session,
4135 wait, nb_packets_per_stream);
4136 if (ret != LTTNG_OK) {
4137 goto error;
4138 }
4139 }
4140
4141 snapshot_success = 1;
4142 } else {
4143 struct snapshot_output *sout;
4144 struct lttng_ht_iter iter;
4145
4146 rcu_read_lock();
4147 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
4148 &iter.iter, sout, node.node) {
4149 int64_t nb_packets_per_stream;
4150
4151 /*
4152 * Make a local copy of the output and assign the possible
4153 * temporary value given by the caller.
4154 */
4155 memset(&tmp_output, 0, sizeof(tmp_output));
4156 memcpy(&tmp_output, sout, sizeof(tmp_output));
4157
4158 if (output->max_size != (uint64_t) -1ULL) {
4159 tmp_output.max_size = output->max_size;
4160 }
4161
4162 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4163 tmp_output.max_size);
4164 if (nb_packets_per_stream < 0) {
4165 ret = LTTNG_ERR_MAX_SIZE_INVALID;
4166 rcu_read_unlock();
4167 goto error;
4168 }
4169
4170 /* Use temporary name. */
4171 if (*output->name != '\0') {
4172 if (lttng_strncpy(tmp_output.name, output->name,
4173 sizeof(tmp_output.name))) {
4174 ret = LTTNG_ERR_INVALID;
4175 rcu_read_unlock();
4176 goto error;
4177 }
4178 }
4179
4180 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
4181 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
4182
4183 if (session->kernel_session) {
4184 ret = record_kernel_snapshot(session->kernel_session,
4185 &tmp_output, session,
4186 wait, nb_packets_per_stream);
4187 if (ret != LTTNG_OK) {
4188 rcu_read_unlock();
4189 goto error;
4190 }
4191 }
4192
4193 if (session->ust_session) {
4194 ret = record_ust_snapshot(session->ust_session,
4195 &tmp_output, session,
4196 wait, nb_packets_per_stream);
4197 if (ret != LTTNG_OK) {
4198 rcu_read_unlock();
4199 goto error;
4200 }
4201 }
4202 snapshot_success = 1;
4203 }
4204 rcu_read_unlock();
4205 }
4206
4207 if (snapshot_success) {
4208 session->snapshot.nb_snapshot++;
4209 } else {
4210 ret = LTTNG_ERR_SNAPSHOT_FAIL;
4211 }
4212
4213 error:
4214 return ret;
4215 }
4216
4217 /*
4218 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
4219 */
4220 int cmd_set_session_shm_path(struct ltt_session *session,
4221 const char *shm_path)
4222 {
4223 /* Safety net */
4224 assert(session);
4225
4226 /*
4227 * Can only set shm path before session is started.
4228 */
4229 if (session->has_been_started) {
4230 return LTTNG_ERR_SESSION_STARTED;
4231 }
4232
4233 strncpy(session->shm_path, shm_path,
4234 sizeof(session->shm_path));
4235 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
4236
4237 return 0;
4238 }
4239
4240 /*
4241 * Init command subsystem.
4242 */
4243 void cmd_init(void)
4244 {
4245 /*
4246 * Set network sequence index to 1 for streams to match a relayd
4247 * socket on the consumer side.
4248 */
4249 pthread_mutex_lock(&relayd_net_seq_idx_lock);
4250 relayd_net_seq_idx = 1;
4251 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
4252
4253 DBG("Command subsystem initialized");
4254 }
LTTng 2.0 tools and control repository
This page took 0.167172 seconds and 5 git commands to generate.