projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Command to make a directory on the consumer or relay
[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 /* Kernel tracing */
2523 if (ksession != NULL) {
2524 ret = start_kernel_session(ksession, kernel_tracer_fd);
2525 if (ret != LTTNG_OK) {
2526 goto error;
2527 }
2528 }
2529
2530 /* Flag session that trace should start automatically */
2531 if (usess) {
2532 /*
2533 * Even though the start trace might fail, flag this session active so
2534 * other application coming in are started by default.
2535 */
2536 usess->active = 1;
2537
2538 ret = ust_app_start_trace_all(usess);
2539 if (ret < 0) {
2540 ret = LTTNG_ERR_UST_START_FAIL;
2541 goto error;
2542 }
2543 }
2544
2545 /* Flag this after a successful start. */
2546 session->has_been_started = 1;
2547 session->active = 1;
2548
2549 ret = LTTNG_OK;
2550
2551 error:
2552 return ret;
2553 }
2554
2555 /*
2556 * Command LTTNG_STOP_TRACE processed by the client thread.
2557 */
2558 int cmd_stop_trace(struct ltt_session *session)
2559 {
2560 int ret;
2561 struct ltt_kernel_channel *kchan;
2562 struct ltt_kernel_session *ksession;
2563 struct ltt_ust_session *usess;
2564
2565 assert(session);
2566
2567 /* Short cut */
2568 ksession = session->kernel_session;
2569 usess = session->ust_session;
2570
2571 /* Session is not active. Skip everythong and inform the client. */
2572 if (!session->active) {
2573 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2574 goto error;
2575 }
2576
2577 /* Kernel tracer */
2578 if (ksession && ksession->active) {
2579 DBG("Stop kernel tracing");
2580
2581 ret = kernel_stop_session(ksession);
2582 if (ret < 0) {
2583 ret = LTTNG_ERR_KERN_STOP_FAIL;
2584 goto error;
2585 }
2586
2587 kernel_wait_quiescent(kernel_tracer_fd);
2588
2589 /* Flush metadata after stopping (if exists) */
2590 if (ksession->metadata_stream_fd >= 0) {
2591 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
2592 if (ret < 0) {
2593 ERR("Kernel metadata flush failed");
2594 }
2595 }
2596
2597 /* Flush all buffers after stopping */
2598 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2599 ret = kernel_flush_buffer(kchan);
2600 if (ret < 0) {
2601 ERR("Kernel flush buffer error");
2602 }
2603 }
2604
2605 ksession->active = 0;
2606 }
2607
2608 if (usess && usess->active) {
2609 /*
2610 * Even though the stop trace might fail, flag this session inactive so
2611 * other application coming in are not started by default.
2612 */
2613 usess->active = 0;
2614
2615 ret = ust_app_stop_trace_all(usess);
2616 if (ret < 0) {
2617 ret = LTTNG_ERR_UST_STOP_FAIL;
2618 goto error;
2619 }
2620 }
2621
2622 /* Flag inactive after a successful stop. */
2623 session->active = 0;
2624 ret = LTTNG_OK;
2625
2626 error:
2627 return ret;
2628 }
2629
2630 /*
2631 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2632 */
2633 int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2634 struct lttng_uri *uris)
2635 {
2636 int ret, i;
2637 struct ltt_kernel_session *ksess = session->kernel_session;
2638 struct ltt_ust_session *usess = session->ust_session;
2639
2640 assert(session);
2641 assert(uris);
2642 assert(nb_uri > 0);
2643
2644 /* Can't set consumer URI if the session is active. */
2645 if (session->active) {
2646 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2647 goto error;
2648 }
2649
2650 /* Set the "global" consumer URIs */
2651 for (i = 0; i < nb_uri; i++) {
2652 ret = add_uri_to_consumer(session->consumer,
2653 &uris[i], 0, session->name);
2654 if (ret != LTTNG_OK) {
2655 goto error;
2656 }
2657 }
2658
2659 /* Set UST session URIs */
2660 if (session->ust_session) {
2661 for (i = 0; i < nb_uri; i++) {
2662 ret = add_uri_to_consumer(
2663 session->ust_session->consumer,
2664 &uris[i], LTTNG_DOMAIN_UST,
2665 session->name);
2666 if (ret != LTTNG_OK) {
2667 goto error;
2668 }
2669 }
2670 }
2671
2672 /* Set kernel session URIs */
2673 if (session->kernel_session) {
2674 for (i = 0; i < nb_uri; i++) {
2675 ret = add_uri_to_consumer(
2676 session->kernel_session->consumer,
2677 &uris[i], LTTNG_DOMAIN_KERNEL,
2678 session->name);
2679 if (ret != LTTNG_OK) {
2680 goto error;
2681 }
2682 }
2683 }
2684
2685 /*
2686 * Make sure to set the session in output mode after we set URI since a
2687 * session can be created without URL (thus flagged in no output mode).
2688 */
2689 session->output_traces = 1;
2690 if (ksess) {
2691 ksess->output_traces = 1;
2692 }
2693
2694 if (usess) {
2695 usess->output_traces = 1;
2696 }
2697
2698 /* All good! */
2699 ret = LTTNG_OK;
2700
2701 error:
2702 return ret;
2703 }
2704
2705 /*
2706 * Command LTTNG_CREATE_SESSION processed by the client thread.
2707 */
2708 int cmd_create_session_uri(char *name, struct lttng_uri *uris,
2709 size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer)
2710 {
2711 int ret;
2712 struct ltt_session *session;
2713
2714 assert(name);
2715 assert(creds);
2716
2717 /*
2718 * Verify if the session already exist
2719 *
2720 * XXX: There is no need for the session lock list here since the caller
2721 * (process_client_msg) is holding it. We might want to change that so a
2722 * single command does not lock the entire session list.
2723 */
2724 session = session_find_by_name(name);
2725 if (session != NULL) {
2726 ret = LTTNG_ERR_EXIST_SESS;
2727 goto find_error;
2728 }
2729
2730 /* Create tracing session in the registry */
2731 ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds),
2732 LTTNG_SOCK_GET_GID_CRED(creds));
2733 if (ret != LTTNG_OK) {
2734 goto session_error;
2735 }
2736
2737 /*
2738 * Get the newly created session pointer back
2739 *
2740 * XXX: There is no need for the session lock list here since the caller
2741 * (process_client_msg) is holding it. We might want to change that so a
2742 * single command does not lock the entire session list.
2743 */
2744 session = session_find_by_name(name);
2745 assert(session);
2746
2747 session->live_timer = live_timer;
2748 /* Create default consumer output for the session not yet created. */
2749 session->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
2750 if (session->consumer == NULL) {
2751 ret = LTTNG_ERR_FATAL;
2752 goto consumer_error;
2753 }
2754
2755 if (uris) {
2756 ret = cmd_set_consumer_uri(session, nb_uri, uris);
2757 if (ret != LTTNG_OK) {
2758 goto consumer_error;
2759 }
2760 session->output_traces = 1;
2761 } else {
2762 session->output_traces = 0;
2763 DBG2("Session %s created with no output", session->name);
2764 }
2765
2766 session->consumer->enabled = 1;
2767
2768 return LTTNG_OK;
2769
2770 consumer_error:
2771 session_destroy(session);
2772 session_error:
2773 find_error:
2774 return ret;
2775 }
2776
2777 /*
2778 * Command LTTNG_CREATE_SESSION_SNAPSHOT processed by the client thread.
2779 */
2780 int cmd_create_session_snapshot(char *name, struct lttng_uri *uris,
2781 size_t nb_uri, lttng_sock_cred *creds)
2782 {
2783 int ret;
2784 struct ltt_session *session;
2785 struct snapshot_output *new_output = NULL;
2786
2787 assert(name);
2788 assert(creds);
2789
2790 /*
2791 * Create session in no output mode with URIs set to NULL. The uris we've
2792 * received are for a default snapshot output if one.
2793 */
2794 ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
2795 if (ret != LTTNG_OK) {
2796 goto error;
2797 }
2798
2799 /* Get the newly created session pointer back. This should NEVER fail. */
2800 session = session_find_by_name(name);
2801 assert(session);
2802
2803 /* Flag session for snapshot mode. */
2804 session->snapshot_mode = 1;
2805
2806 /* Skip snapshot output creation if no URI is given. */
2807 if (nb_uri == 0) {
2808 goto end;
2809 }
2810
2811 new_output = snapshot_output_alloc();
2812 if (!new_output) {
2813 ret = LTTNG_ERR_NOMEM;
2814 goto error_snapshot_alloc;
2815 }
2816
2817 ret = snapshot_output_init_with_uri(DEFAULT_SNAPSHOT_MAX_SIZE, NULL,
2818 uris, nb_uri, session->consumer, new_output, &session->snapshot);
2819 if (ret < 0) {
2820 if (ret == -ENOMEM) {
2821 ret = LTTNG_ERR_NOMEM;
2822 } else {
2823 ret = LTTNG_ERR_INVALID;
2824 }
2825 goto error_snapshot;
2826 }
2827
2828 rcu_read_lock();
2829 snapshot_add_output(&session->snapshot, new_output);
2830 rcu_read_unlock();
2831
2832 end:
2833 return LTTNG_OK;
2834
2835 error_snapshot:
2836 snapshot_output_destroy(new_output);
2837 error_snapshot_alloc:
2838 session_destroy(session);
2839 error:
2840 return ret;
2841 }
2842
2843 /*
2844 * Command LTTNG_DESTROY_SESSION processed by the client thread.
2845 *
2846 * Called with session lock held.
2847 */
2848 int cmd_destroy_session(struct ltt_session *session, int wpipe)
2849 {
2850 int ret;
2851 struct ltt_ust_session *usess;
2852 struct ltt_kernel_session *ksess;
2853
2854 /* Safety net */
2855 assert(session);
2856
2857 usess = session->ust_session;
2858 ksess = session->kernel_session;
2859
2860 /* Clean kernel session teardown */
2861 kernel_destroy_session(ksess);
2862
2863 /* UST session teardown */
2864 if (usess) {
2865 /* Close any relayd session */
2866 consumer_output_send_destroy_relayd(usess->consumer);
2867
2868 /* Destroy every UST application related to this session. */
2869 ret = ust_app_destroy_trace_all(usess);
2870 if (ret) {
2871 ERR("Error in ust_app_destroy_trace_all");
2872 }
2873
2874 /* Clean up the rest. */
2875 trace_ust_destroy_session(usess);
2876 }
2877
2878 /*
2879 * Must notify the kernel thread here to update it's poll set in order to
2880 * remove the channel(s)' fd just destroyed.
2881 */
2882 ret = notify_thread_pipe(wpipe);
2883 if (ret < 0) {
2884 PERROR("write kernel poll pipe");
2885 }
2886
2887 ret = session_destroy(session);
2888
2889 return ret;
2890 }
2891
2892 /*
2893 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
2894 */
2895 int cmd_register_consumer(struct ltt_session *session,
2896 enum lttng_domain_type domain, const char *sock_path,
2897 struct consumer_data *cdata)
2898 {
2899 int ret, sock;
2900 struct consumer_socket *socket = NULL;
2901
2902 assert(session);
2903 assert(cdata);
2904 assert(sock_path);
2905
2906 switch (domain) {
2907 case LTTNG_DOMAIN_KERNEL:
2908 {
2909 struct ltt_kernel_session *ksess = session->kernel_session;
2910
2911 assert(ksess);
2912
2913 /* Can't register a consumer if there is already one */
2914 if (ksess->consumer_fds_sent != 0) {
2915 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2916 goto error;
2917 }
2918
2919 sock = lttcomm_connect_unix_sock(sock_path);
2920 if (sock < 0) {
2921 ret = LTTNG_ERR_CONNECT_FAIL;
2922 goto error;
2923 }
2924 cdata->cmd_sock = sock;
2925
2926 socket = consumer_allocate_socket(&cdata->cmd_sock);
2927 if (socket == NULL) {
2928 ret = close(sock);
2929 if (ret < 0) {
2930 PERROR("close register consumer");
2931 }
2932 cdata->cmd_sock = -1;
2933 ret = LTTNG_ERR_FATAL;
2934 goto error;
2935 }
2936
2937 socket->lock = zmalloc(sizeof(pthread_mutex_t));
2938 if (socket->lock == NULL) {
2939 PERROR("zmalloc pthread mutex");
2940 ret = LTTNG_ERR_FATAL;
2941 goto error;
2942 }
2943 pthread_mutex_init(socket->lock, NULL);
2944 socket->registered = 1;
2945
2946 rcu_read_lock();
2947 consumer_add_socket(socket, ksess->consumer);
2948 rcu_read_unlock();
2949
2950 pthread_mutex_lock(&cdata->pid_mutex);
2951 cdata->pid = -1;
2952 pthread_mutex_unlock(&cdata->pid_mutex);
2953
2954 break;
2955 }
2956 default:
2957 /* TODO: Userspace tracing */
2958 ret = LTTNG_ERR_UND;
2959 goto error;
2960 }
2961
2962 return LTTNG_OK;
2963
2964 error:
2965 if (socket) {
2966 consumer_destroy_socket(socket);
2967 }
2968 return ret;
2969 }
2970
2971 /*
2972 * Command LTTNG_LIST_DOMAINS processed by the client thread.
2973 */
2974 ssize_t cmd_list_domains(struct ltt_session *session,
2975 struct lttng_domain **domains)
2976 {
2977 int ret, index = 0;
2978 ssize_t nb_dom = 0;
2979 struct agent *agt;
2980 struct lttng_ht_iter iter;
2981
2982 if (session->kernel_session != NULL) {
2983 DBG3("Listing domains found kernel domain");
2984 nb_dom++;
2985 }
2986
2987 if (session->ust_session != NULL) {
2988 DBG3("Listing domains found UST global domain");
2989 nb_dom++;
2990
2991 rcu_read_lock();
2992 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
2993 agt, node.node) {
2994 if (agt->being_used) {
2995 nb_dom++;
2996 }
2997 }
2998 rcu_read_unlock();
2999 }
3000
3001 if (!nb_dom) {
3002 goto end;
3003 }
3004
3005 *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
3006 if (*domains == NULL) {
3007 ret = LTTNG_ERR_FATAL;
3008 goto error;
3009 }
3010
3011 if (session->kernel_session != NULL) {
3012 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
3013
3014 /* Kernel session buffer type is always GLOBAL */
3015 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
3016
3017 index++;
3018 }
3019
3020 if (session->ust_session != NULL) {
3021 (*domains)[index].type = LTTNG_DOMAIN_UST;
3022 (*domains)[index].buf_type = session->ust_session->buffer_type;
3023 index++;
3024
3025 rcu_read_lock();
3026 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3027 agt, node.node) {
3028 if (agt->being_used) {
3029 (*domains)[index].type = agt->domain;
3030 (*domains)[index].buf_type = session->ust_session->buffer_type;
3031 index++;
3032 }
3033 }
3034 rcu_read_unlock();
3035 }
3036 end:
3037 return nb_dom;
3038
3039 error:
3040 /* Return negative value to differentiate return code */
3041 return -ret;
3042 }
3043
3044
3045 /*
3046 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3047 */
3048 ssize_t cmd_list_channels(enum lttng_domain_type domain,
3049 struct ltt_session *session, struct lttng_channel **channels)
3050 {
3051 ssize_t nb_chan = 0, payload_size = 0, ret;
3052
3053 switch (domain) {
3054 case LTTNG_DOMAIN_KERNEL:
3055 if (session->kernel_session != NULL) {
3056 nb_chan = session->kernel_session->channel_count;
3057 }
3058 DBG3("Number of kernel channels %zd", nb_chan);
3059 if (nb_chan <= 0) {
3060 ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
3061 goto end;
3062 }
3063 break;
3064 case LTTNG_DOMAIN_UST:
3065 if (session->ust_session != NULL) {
3066 rcu_read_lock();
3067 nb_chan = lttng_ht_get_count(
3068 session->ust_session->domain_global.channels);
3069 rcu_read_unlock();
3070 }
3071 DBG3("Number of UST global channels %zd", nb_chan);
3072 if (nb_chan < 0) {
3073 ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
3074 goto end;
3075 }
3076 break;
3077 default:
3078 ret = -LTTNG_ERR_UND;
3079 goto end;
3080 }
3081
3082 if (nb_chan > 0) {
3083 const size_t channel_size = sizeof(struct lttng_channel) +
3084 sizeof(struct lttng_channel_extended);
3085 struct lttng_channel_extended *channel_exts;
3086
3087 payload_size = nb_chan * channel_size;
3088 *channels = zmalloc(payload_size);
3089 if (*channels == NULL) {
3090 ret = -LTTNG_ERR_FATAL;
3091 goto end;
3092 }
3093
3094 channel_exts = ((void *) *channels) +
3095 (nb_chan * sizeof(struct lttng_channel));
3096 ret = list_lttng_channels(domain, session, *channels, channel_exts);
3097 if (ret != LTTNG_OK) {
3098 free(*channels);
3099 *channels = NULL;
3100 goto end;
3101 }
3102 } else {
3103 *channels = NULL;
3104 }
3105
3106 ret = payload_size;
3107 end:
3108 return ret;
3109 }
3110
3111 /*
3112 * Command LTTNG_LIST_EVENTS processed by the client thread.
3113 */
3114 ssize_t cmd_list_events(enum lttng_domain_type domain,
3115 struct ltt_session *session, char *channel_name,
3116 struct lttng_event **events, size_t *total_size)
3117 {
3118 int ret = 0;
3119 ssize_t nb_event = 0;
3120
3121 switch (domain) {
3122 case LTTNG_DOMAIN_KERNEL:
3123 if (session->kernel_session != NULL) {
3124 nb_event = list_lttng_kernel_events(channel_name,
3125 session->kernel_session, events,
3126 total_size);
3127 }
3128 break;
3129 case LTTNG_DOMAIN_UST:
3130 {
3131 if (session->ust_session != NULL) {
3132 nb_event = list_lttng_ust_global_events(channel_name,
3133 &session->ust_session->domain_global, events,
3134 total_size);
3135 }
3136 break;
3137 }
3138 case LTTNG_DOMAIN_LOG4J:
3139 case LTTNG_DOMAIN_JUL:
3140 case LTTNG_DOMAIN_PYTHON:
3141 if (session->ust_session) {
3142 struct lttng_ht_iter iter;
3143 struct agent *agt;
3144
3145 rcu_read_lock();
3146 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3147 &iter.iter, agt, node.node) {
3148 if (agt->domain == domain) {
3149 nb_event = list_lttng_agent_events(
3150 agt, events,
3151 total_size);
3152 break;
3153 }
3154 }
3155 rcu_read_unlock();
3156 }
3157 break;
3158 default:
3159 ret = LTTNG_ERR_UND;
3160 goto error;
3161 }
3162
3163 return nb_event;
3164
3165 error:
3166 /* Return negative value to differentiate return code */
3167 return -ret;
3168 }
3169
3170 /*
3171 * Using the session list, filled a lttng_session array to send back to the
3172 * client for session listing.
3173 *
3174 * The session list lock MUST be acquired before calling this function. Use
3175 * session_lock_list() and session_unlock_list().
3176 */
3177 void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid,
3178 gid_t gid)
3179 {
3180 int ret;
3181 unsigned int i = 0;
3182 struct ltt_session *session;
3183 struct ltt_session_list *list = session_get_list();
3184
3185 DBG("Getting all available session for UID %d GID %d",
3186 uid, gid);
3187 /*
3188 * Iterate over session list and append data after the control struct in
3189 * the buffer.
3190 */
3191 cds_list_for_each_entry(session, &list->head, list) {
3192 /*
3193 * Only list the sessions the user can control.
3194 */
3195 if (!session_access_ok(session, uid, gid)) {
3196 continue;
3197 }
3198
3199 struct ltt_kernel_session *ksess = session->kernel_session;
3200 struct ltt_ust_session *usess = session->ust_session;
3201
3202 if (session->consumer->type == CONSUMER_DST_NET ||
3203 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3204 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3205 ret = build_network_session_path(sessions[i].path,
3206 sizeof(sessions[i].path), session);
3207 } else {
3208 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
3209 session->consumer->dst.session_root_path);
3210 }
3211 if (ret < 0) {
3212 PERROR("snprintf session path");
3213 continue;
3214 }
3215
3216 strncpy(sessions[i].name, session->name, NAME_MAX);
3217 sessions[i].name[NAME_MAX - 1] = '\0';
3218 sessions[i].enabled = session->active;
3219 sessions[i].snapshot_mode = session->snapshot_mode;
3220 sessions[i].live_timer_interval = session->live_timer;
3221 i++;
3222 }
3223 }
3224
3225 /*
3226 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
3227 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
3228 */
3229 int cmd_data_pending(struct ltt_session *session)
3230 {
3231 int ret;
3232 struct ltt_kernel_session *ksess = session->kernel_session;
3233 struct ltt_ust_session *usess = session->ust_session;
3234
3235 assert(session);
3236
3237 /* Session MUST be stopped to ask for data availability. */
3238 if (session->active) {
3239 ret = LTTNG_ERR_SESSION_STARTED;
3240 goto error;
3241 } else {
3242 /*
3243 * If stopped, just make sure we've started before else the above call
3244 * will always send that there is data pending.
3245 *
3246 * The consumer assumes that when the data pending command is received,
3247 * the trace has been started before or else no output data is written
3248 * by the streams which is a condition for data pending. So, this is
3249 * *VERY* important that we don't ask the consumer before a start
3250 * trace.
3251 */
3252 if (!session->has_been_started) {
3253 ret = 0;
3254 goto error;
3255 }
3256 }
3257
3258 if (ksess && ksess->consumer) {
3259 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
3260 if (ret == 1) {
3261 /* Data is still being extracted for the kernel. */
3262 goto error;
3263 }
3264 }
3265
3266 if (usess && usess->consumer) {
3267 ret = consumer_is_data_pending(usess->id, usess->consumer);
3268 if (ret == 1) {
3269 /* Data is still being extracted for the kernel. */
3270 goto error;
3271 }
3272 }
3273
3274 /* Data is ready to be read by a viewer */
3275 ret = 0;
3276
3277 error:
3278 return ret;
3279 }
3280
3281 /*
3282 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
3283 *
3284 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3285 */
3286 int cmd_snapshot_add_output(struct ltt_session *session,
3287 struct lttng_snapshot_output *output, uint32_t *id)
3288 {
3289 int ret;
3290 struct snapshot_output *new_output;
3291
3292 assert(session);
3293 assert(output);
3294
3295 DBG("Cmd snapshot add output for session %s", session->name);
3296
3297 /*
3298 * Can't create an output if the session is not set in no-output mode.
3299 */
3300 if (session->output_traces) {
3301 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3302 goto error;
3303 }
3304
3305 /* Only one output is allowed until we have the "tee" feature. */
3306 if (session->snapshot.nb_output == 1) {
3307 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
3308 goto error;
3309 }
3310
3311 new_output = snapshot_output_alloc();
3312 if (!new_output) {
3313 ret = LTTNG_ERR_NOMEM;
3314 goto error;
3315 }
3316
3317 ret = snapshot_output_init(output->max_size, output->name,
3318 output->ctrl_url, output->data_url, session->consumer, new_output,
3319 &session->snapshot);
3320 if (ret < 0) {
3321 if (ret == -ENOMEM) {
3322 ret = LTTNG_ERR_NOMEM;
3323 } else {
3324 ret = LTTNG_ERR_INVALID;
3325 }
3326 goto free_error;
3327 }
3328
3329 rcu_read_lock();
3330 snapshot_add_output(&session->snapshot, new_output);
3331 if (id) {
3332 *id = new_output->id;
3333 }
3334 rcu_read_unlock();
3335
3336 return LTTNG_OK;
3337
3338 free_error:
3339 snapshot_output_destroy(new_output);
3340 error:
3341 return ret;
3342 }
3343
3344 /*
3345 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
3346 *
3347 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3348 */
3349 int cmd_snapshot_del_output(struct ltt_session *session,
3350 struct lttng_snapshot_output *output)
3351 {
3352 int ret;
3353 struct snapshot_output *sout = NULL;
3354
3355 assert(session);
3356 assert(output);
3357
3358 rcu_read_lock();
3359
3360 /*
3361 * Permission denied to create an output if the session is not
3362 * set in no output mode.
3363 */
3364 if (session->output_traces) {
3365 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3366 goto error;
3367 }
3368
3369 if (output->id) {
3370 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
3371 session->name);
3372 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
3373 } else if (*output->name != '\0') {
3374 DBG("Cmd snapshot del output name %s for session %s", output->name,
3375 session->name);
3376 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
3377 }
3378 if (!sout) {
3379 ret = LTTNG_ERR_INVALID;
3380 goto error;
3381 }
3382
3383 snapshot_delete_output(&session->snapshot, sout);
3384 snapshot_output_destroy(sout);
3385 ret = LTTNG_OK;
3386
3387 error:
3388 rcu_read_unlock();
3389 return ret;
3390 }
3391
3392 /*
3393 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
3394 *
3395 * If no output is available, outputs is untouched and 0 is returned.
3396 *
3397 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
3398 */
3399 ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
3400 struct lttng_snapshot_output **outputs)
3401 {
3402 int ret, idx = 0;
3403 struct lttng_snapshot_output *list = NULL;
3404 struct lttng_ht_iter iter;
3405 struct snapshot_output *output;
3406
3407 assert(session);
3408 assert(outputs);
3409
3410 DBG("Cmd snapshot list outputs for session %s", session->name);
3411
3412 /*
3413 * Permission denied to create an output if the session is not
3414 * set in no output mode.
3415 */
3416 if (session->output_traces) {
3417 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3418 goto end;
3419 }
3420
3421 if (session->snapshot.nb_output == 0) {
3422 ret = 0;
3423 goto end;
3424 }
3425
3426 list = zmalloc(session->snapshot.nb_output * sizeof(*list));
3427 if (!list) {
3428 ret = -LTTNG_ERR_NOMEM;
3429 goto end;
3430 }
3431
3432 /* Copy list from session to the new list object. */
3433 rcu_read_lock();
3434 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
3435 output, node.node) {
3436 assert(output->consumer);
3437 list[idx].id = output->id;
3438 list[idx].max_size = output->max_size;
3439 if (lttng_strncpy(list[idx].name, output->name,
3440 sizeof(list[idx].name))) {
3441 ret = -LTTNG_ERR_INVALID;
3442 goto error;
3443 }
3444 if (output->consumer->type == CONSUMER_DST_LOCAL) {
3445 if (lttng_strncpy(list[idx].ctrl_url,
3446 output->consumer->dst.session_root_path,
3447 sizeof(list[idx].ctrl_url))) {
3448 ret = -LTTNG_ERR_INVALID;
3449 goto error;
3450 }
3451 } else {
3452 /* Control URI. */
3453 ret = uri_to_str_url(&output->consumer->dst.net.control,
3454 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
3455 if (ret < 0) {
3456 ret = -LTTNG_ERR_NOMEM;
3457 goto error;
3458 }
3459
3460 /* Data URI. */
3461 ret = uri_to_str_url(&output->consumer->dst.net.data,
3462 list[idx].data_url, sizeof(list[idx].data_url));
3463 if (ret < 0) {
3464 ret = -LTTNG_ERR_NOMEM;
3465 goto error;
3466 }
3467 }
3468 idx++;
3469 }
3470
3471 *outputs = list;
3472 list = NULL;
3473 ret = session->snapshot.nb_output;
3474 error:
3475 rcu_read_unlock();
3476 free(list);
3477 end:
3478 return ret;
3479 }
3480
3481 /*
3482 * Check if we can regenerate the metadata for this session.
3483 * Only kernel, UST per-uid and non-live sessions are supported.
3484 *
3485 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
3486 */
3487 static
3488 int check_regenerate_metadata_support(struct ltt_session *session)
3489 {
3490 int ret;
3491
3492 assert(session);
3493
3494 if (session->live_timer != 0) {
3495 ret = LTTNG_ERR_LIVE_SESSION;
3496 goto end;
3497 }
3498 if (!session->active) {
3499 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3500 goto end;
3501 }
3502 if (session->ust_session) {
3503 switch (session->ust_session->buffer_type) {
3504 case LTTNG_BUFFER_PER_UID:
3505 break;
3506 case LTTNG_BUFFER_PER_PID:
3507 ret = LTTNG_ERR_PER_PID_SESSION;
3508 goto end;
3509 default:
3510 assert(0);
3511 ret = LTTNG_ERR_UNK;
3512 goto end;
3513 }
3514 }
3515 if (session->consumer->type == CONSUMER_DST_NET &&
3516 session->consumer->relay_minor_version < 8) {
3517 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
3518 goto end;
3519 }
3520 ret = 0;
3521
3522 end:
3523 return ret;
3524 }
3525
3526 static
3527 int clear_metadata_file(int fd)
3528 {
3529 int ret;
3530
3531 ret = lseek(fd, 0, SEEK_SET);
3532 if (ret < 0) {
3533 PERROR("lseek");
3534 goto end;
3535 }
3536
3537 ret = ftruncate(fd, 0);
3538 if (ret < 0) {
3539 PERROR("ftruncate");
3540 goto end;
3541 }
3542
3543 end:
3544 return ret;
3545 }
3546
3547 static
3548 int ust_regenerate_metadata(struct ltt_ust_session *usess)
3549 {
3550 int ret = 0;
3551 struct buffer_reg_uid *uid_reg = NULL;
3552 struct buffer_reg_session *session_reg = NULL;
3553
3554 rcu_read_lock();
3555 cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
3556 struct ust_registry_session *registry;
3557 struct ust_registry_channel *chan;
3558 struct lttng_ht_iter iter_chan;
3559
3560 session_reg = uid_reg->registry;
3561 registry = session_reg->reg.ust;
3562
3563 pthread_mutex_lock(&registry->lock);
3564 registry->metadata_len_sent = 0;
3565 memset(registry->metadata, 0, registry->metadata_alloc_len);
3566 registry->metadata_len = 0;
3567 registry->metadata_version++;
3568 if (registry->metadata_fd > 0) {
3569 /* Clear the metadata file's content. */
3570 ret = clear_metadata_file(registry->metadata_fd);
3571 if (ret) {
3572 pthread_mutex_unlock(&registry->lock);
3573 goto end;
3574 }
3575 }
3576
3577 ret = ust_metadata_session_statedump(registry, NULL,
3578 registry->major, registry->minor);
3579 if (ret) {
3580 pthread_mutex_unlock(&registry->lock);
3581 ERR("Failed to generate session metadata (err = %d)",
3582 ret);
3583 goto end;
3584 }
3585 cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
3586 chan, node.node) {
3587 struct ust_registry_event *event;
3588 struct lttng_ht_iter iter_event;
3589
3590 ret = ust_metadata_channel_statedump(registry, chan);
3591 if (ret) {
3592 pthread_mutex_unlock(&registry->lock);
3593 ERR("Failed to generate channel metadata "
3594 "(err = %d)", ret);
3595 goto end;
3596 }
3597 cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter,
3598 event, node.node) {
3599 ret = ust_metadata_event_statedump(registry,
3600 chan, event);
3601 if (ret) {
3602 pthread_mutex_unlock(&registry->lock);
3603 ERR("Failed to generate event metadata "
3604 "(err = %d)", ret);
3605 goto end;
3606 }
3607 }
3608 }
3609 pthread_mutex_unlock(&registry->lock);
3610 }
3611
3612 end:
3613 rcu_read_unlock();
3614 return ret;
3615 }
3616
3617 /*
3618 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
3619 *
3620 * Ask the consumer to truncate the existing metadata file(s) and
3621 * then regenerate the metadata. Live and per-pid sessions are not
3622 * supported and return an error.
3623 *
3624 * Return 0 on success or else a LTTNG_ERR code.
3625 */
3626 int cmd_regenerate_metadata(struct ltt_session *session)
3627 {
3628 int ret;
3629
3630 assert(session);
3631
3632 ret = check_regenerate_metadata_support(session);
3633 if (ret) {
3634 goto end;
3635 }
3636
3637 if (session->kernel_session) {
3638 ret = kernctl_session_regenerate_metadata(
3639 session->kernel_session->fd);
3640 if (ret < 0) {
3641 ERR("Failed to regenerate the kernel metadata");
3642 goto end;
3643 }
3644 }
3645
3646 if (session->ust_session) {
3647 ret = ust_regenerate_metadata(session->ust_session);
3648 if (ret < 0) {
3649 ERR("Failed to regenerate the UST metadata");
3650 goto end;
3651 }
3652 }
3653 DBG("Cmd metadata regenerate for session %s", session->name);
3654 ret = LTTNG_OK;
3655
3656 end:
3657 return ret;
3658 }
3659
3660 /*
3661 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
3662 *
3663 * Ask the tracer to regenerate a new statedump.
3664 *
3665 * Return 0 on success or else a LTTNG_ERR code.
3666 */
3667 int cmd_regenerate_statedump(struct ltt_session *session)
3668 {
3669 int ret;
3670
3671 assert(session);
3672
3673 if (!session->active) {
3674 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3675 goto end;
3676 }
3677
3678 if (session->kernel_session) {
3679 ret = kernctl_session_regenerate_statedump(
3680 session->kernel_session->fd);
3681 /*
3682 * Currently, the statedump in kernel can only fail if out
3683 * of memory.
3684 */
3685 if (ret < 0) {
3686 if (ret == -ENOMEM) {
3687 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
3688 } else {
3689 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3690 }
3691 ERR("Failed to regenerate the kernel statedump");
3692 goto end;
3693 }
3694 }
3695
3696 if (session->ust_session) {
3697 ret = ust_app_regenerate_statedump_all(session->ust_session);
3698 /*
3699 * Currently, the statedump in UST always returns 0.
3700 */
3701 if (ret < 0) {
3702 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3703 ERR("Failed to regenerate the UST statedump");
3704 goto end;
3705 }
3706 }
3707 DBG("Cmd regenerate statedump for session %s", session->name);
3708 ret = LTTNG_OK;
3709
3710 end:
3711 return ret;
3712 }
3713
3714 int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
3715 struct notification_thread_handle *notification_thread)
3716 {
3717 int ret;
3718 size_t trigger_len;
3719 ssize_t sock_recv_len;
3720 struct lttng_trigger *trigger = NULL;
3721 struct lttng_buffer_view view;
3722 struct lttng_dynamic_buffer trigger_buffer;
3723
3724 lttng_dynamic_buffer_init(&trigger_buffer);
3725 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3726 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3727 if (ret) {
3728 ret = LTTNG_ERR_NOMEM;
3729 goto end;
3730 }
3731
3732 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3733 trigger_len);
3734 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3735 ERR("Failed to receive \"register trigger\" command payload");
3736 /* TODO: should this be a new error enum ? */
3737 ret = LTTNG_ERR_INVALID_TRIGGER;
3738 goto end;
3739 }
3740
3741 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3742 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3743 trigger_len) {
3744 ERR("Invalid trigger payload received in \"register trigger\" command");
3745 ret = LTTNG_ERR_INVALID_TRIGGER;
3746 goto end;
3747 }
3748
3749 ret = notification_thread_command_register_trigger(notification_thread,
3750 trigger);
3751 /* Ownership of trigger was transferred. */
3752 trigger = NULL;
3753 end:
3754 lttng_trigger_destroy(trigger);
3755 lttng_dynamic_buffer_reset(&trigger_buffer);
3756 return ret;
3757 }
3758
3759 int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
3760 struct notification_thread_handle *notification_thread)
3761 {
3762 int ret;
3763 size_t trigger_len;
3764 ssize_t sock_recv_len;
3765 struct lttng_trigger *trigger = NULL;
3766 struct lttng_buffer_view view;
3767 struct lttng_dynamic_buffer trigger_buffer;
3768
3769 lttng_dynamic_buffer_init(&trigger_buffer);
3770 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3771 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3772 if (ret) {
3773 ret = LTTNG_ERR_NOMEM;
3774 goto end;
3775 }
3776
3777 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3778 trigger_len);
3779 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3780 ERR("Failed to receive \"unregister trigger\" command payload");
3781 /* TODO: should this be a new error enum ? */
3782 ret = LTTNG_ERR_INVALID_TRIGGER;
3783 goto end;
3784 }
3785
3786 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3787 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3788 trigger_len) {
3789 ERR("Invalid trigger payload received in \"unregister trigger\" command");
3790 ret = LTTNG_ERR_INVALID_TRIGGER;
3791 goto end;
3792 }
3793
3794 ret = notification_thread_command_unregister_trigger(notification_thread,
3795 trigger);
3796 end:
3797 lttng_trigger_destroy(trigger);
3798 lttng_dynamic_buffer_reset(&trigger_buffer);
3799 return ret;
3800 }
3801
3802 /*
3803 * Send relayd sockets from snapshot output to consumer. Ignore request if the
3804 * snapshot output is *not* set with a remote destination.
3805 *
3806 * Return 0 on success or a LTTNG_ERR code.
3807 */
3808 static int set_relayd_for_snapshot(struct consumer_output *consumer,
3809 struct snapshot_output *snap_output, struct ltt_session *session)
3810 {
3811 int ret = LTTNG_OK;
3812 struct lttng_ht_iter iter;
3813 struct consumer_socket *socket;
3814
3815 assert(consumer);
3816 assert(snap_output);
3817 assert(session);
3818
3819 DBG2("Set relayd object from snapshot output");
3820
3821 /* Ignore if snapshot consumer output is not network. */
3822 if (snap_output->consumer->type != CONSUMER_DST_NET) {
3823 goto error;
3824 }
3825
3826 /*
3827 * For each consumer socket, create and send the relayd object of the
3828 * snapshot output.
3829 */
3830 rcu_read_lock();
3831 cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter,
3832 socket, node.node) {
3833 pthread_mutex_lock(socket->lock);
3834 ret = send_consumer_relayd_sockets(0, session->id,
3835 snap_output->consumer, socket,
3836 session->name, session->hostname,
3837 session->live_timer);
3838 pthread_mutex_unlock(socket->lock);
3839 if (ret != LTTNG_OK) {
3840 rcu_read_unlock();
3841 goto error;
3842 }
3843 }
3844 rcu_read_unlock();
3845
3846 error:
3847 return ret;
3848 }
3849
3850 /*
3851 * Record a kernel snapshot.
3852 *
3853 * Return LTTNG_OK on success or a LTTNG_ERR code.
3854 */
3855 static int record_kernel_snapshot(struct ltt_kernel_session *ksess,
3856 struct snapshot_output *output, struct ltt_session *session,
3857 int wait, uint64_t nb_packets_per_stream)
3858 {
3859 int ret;
3860
3861 assert(ksess);
3862 assert(output);
3863 assert(session);
3864
3865
3866 /*
3867 * Copy kernel session sockets so we can communicate with the right
3868 * consumer for the snapshot record command.
3869 */
3870 ret = consumer_copy_sockets(output->consumer, ksess->consumer);
3871 if (ret < 0) {
3872 ret = LTTNG_ERR_NOMEM;
3873 goto error;
3874 }
3875
3876 ret = set_relayd_for_snapshot(ksess->consumer, output, session);
3877 if (ret != LTTNG_OK) {
3878 goto error_snapshot;
3879 }
3880
3881 ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream);
3882 if (ret != LTTNG_OK) {
3883 goto error_snapshot;
3884 }
3885
3886 ret = LTTNG_OK;
3887 goto end;
3888
3889 error_snapshot:
3890 /* Clean up copied sockets so this output can use some other later on. */
3891 consumer_destroy_output_sockets(output->consumer);
3892 error:
3893 end:
3894 return ret;
3895 }
3896
3897 /*
3898 * Record a UST snapshot.
3899 *
3900 * Return 0 on success or a LTTNG_ERR error code.
3901 */
3902 static int record_ust_snapshot(struct ltt_ust_session *usess,
3903 struct snapshot_output *output, struct ltt_session *session,
3904 int wait, uint64_t nb_packets_per_stream)
3905 {
3906 int ret;
3907
3908 assert(usess);
3909 assert(output);
3910 assert(session);
3911
3912 /*
3913 * Copy UST session sockets so we can communicate with the right
3914 * consumer for the snapshot record command.
3915 */
3916 ret = consumer_copy_sockets(output->consumer, usess->consumer);
3917 if (ret < 0) {
3918 ret = LTTNG_ERR_NOMEM;
3919 goto error;
3920 }
3921
3922 ret = set_relayd_for_snapshot(usess->consumer, output, session);
3923 if (ret != LTTNG_OK) {
3924 goto error_snapshot;
3925 }
3926
3927 ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream);
3928 if (ret < 0) {
3929 switch (-ret) {
3930 case EINVAL:
3931 ret = LTTNG_ERR_INVALID;
3932 break;
3933 default:
3934 ret = LTTNG_ERR_SNAPSHOT_FAIL;
3935 break;
3936 }
3937 goto error_snapshot;
3938 }
3939
3940 ret = LTTNG_OK;
3941
3942 error_snapshot:
3943 /* Clean up copied sockets so this output can use some other later on. */
3944 consumer_destroy_output_sockets(output->consumer);
3945 error:
3946 return ret;
3947 }
3948
3949 static
3950 uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session,
3951 uint64_t cur_nr_packets)
3952 {
3953 uint64_t tot_size = 0;
3954
3955 if (session->kernel_session) {
3956 struct ltt_kernel_channel *chan;
3957 struct ltt_kernel_session *ksess = session->kernel_session;
3958
3959 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
3960 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
3961 /*
3962 * Don't take channel into account if we
3963 * already grab all its packets.
3964 */
3965 continue;
3966 }
3967 tot_size += chan->channel->attr.subbuf_size
3968 * chan->stream_count;
3969 }
3970 }
3971
3972 if (session->ust_session) {
3973 struct ltt_ust_session *usess = session->ust_session;
3974
3975 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
3976 cur_nr_packets);
3977 }
3978
3979 return tot_size;
3980 }
3981
3982 /*
3983 * Calculate the number of packets we can grab from each stream that
3984 * fits within the overall snapshot max size.
3985 *
3986 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
3987 * the number of packets per stream.
3988 *
3989 * TODO: this approach is not perfect: we consider the worse case
3990 * (packet filling the sub-buffers) as an upper bound, but we could do
3991 * better if we do this calculation while we actually grab the packet
3992 * content: we would know how much padding we don't actually store into
3993 * the file.
3994 *
3995 * This algorithm is currently bounded by the number of packets per
3996 * stream.
3997 *
3998 * Since we call this algorithm before actually grabbing the data, it's
3999 * an approximation: for instance, applications could appear/disappear
4000 * in between this call and actually grabbing data.
4001 */
4002 static
4003 int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t max_size)
4004 {
4005 int64_t size_left;
4006 uint64_t cur_nb_packets = 0;
4007
4008 if (!max_size) {
4009 return 0; /* Infinite */
4010 }
4011
4012 size_left = max_size;
4013 for (;;) {
4014 uint64_t one_more_packet_tot_size;
4015
4016 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(session,
4017 cur_nb_packets);
4018 if (!one_more_packet_tot_size) {
4019 /* We are already grabbing all packets. */
4020 break;
4021 }
4022 size_left -= one_more_packet_tot_size;
4023 if (size_left < 0) {
4024 break;
4025 }
4026 cur_nb_packets++;
4027 }
4028 if (!cur_nb_packets) {
4029 /* Not enough room to grab one packet of each stream, error. */
4030 return -1;
4031 }
4032 return cur_nb_packets;
4033 }
4034
4035 /*
4036 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
4037 *
4038 * The wait parameter is ignored so this call always wait for the snapshot to
4039 * complete before returning.
4040 *
4041 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4042 */
4043 int cmd_snapshot_record(struct ltt_session *session,
4044 struct lttng_snapshot_output *output, int wait)
4045 {
4046 int ret = LTTNG_OK;
4047 unsigned int use_tmp_output = 0;
4048 struct snapshot_output tmp_output;
4049 unsigned int snapshot_success = 0;
4050 char datetime[16];
4051
4052 assert(session);
4053 assert(output);
4054
4055 DBG("Cmd snapshot record for session %s", session->name);
4056
4057 /* Get the datetime for the snapshot output directory. */
4058 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
4059 sizeof(datetime));
4060 if (!ret) {
4061 ret = LTTNG_ERR_INVALID;
4062 goto error;
4063 }
4064
4065 /*
4066 * Permission denied to create an output if the session is not
4067 * set in no output mode.
4068 */
4069 if (session->output_traces) {
4070 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
4071 goto error;
4072 }
4073
4074 /* The session needs to be started at least once. */
4075 if (!session->has_been_started) {
4076 ret = LTTNG_ERR_START_SESSION_ONCE;
4077 goto error;
4078 }
4079
4080 /* Use temporary output for the session. */
4081 if (*output->ctrl_url != '\0') {
4082 ret = snapshot_output_init(output->max_size, output->name,
4083 output->ctrl_url, output->data_url, session->consumer,
4084 &tmp_output, NULL);
4085 if (ret < 0) {
4086 if (ret == -ENOMEM) {
4087 ret = LTTNG_ERR_NOMEM;
4088 } else {
4089 ret = LTTNG_ERR_INVALID;
4090 }
4091 goto error;
4092 }
4093 /* Use the global session count for the temporary snapshot. */
4094 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
4095
4096 /* Use the global datetime */
4097 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
4098 use_tmp_output = 1;
4099 }
4100
4101 if (use_tmp_output) {
4102 int64_t nb_packets_per_stream;
4103
4104 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4105 tmp_output.max_size);
4106 if (nb_packets_per_stream < 0) {
4107 ret = LTTNG_ERR_MAX_SIZE_INVALID;
4108 goto error;
4109 }
4110
4111 if (session->kernel_session) {
4112 ret = record_kernel_snapshot(session->kernel_session,
4113 &tmp_output, session,
4114 wait, nb_packets_per_stream);
4115 if (ret != LTTNG_OK) {
4116 goto error;
4117 }
4118 }
4119
4120 if (session->ust_session) {
4121 ret = record_ust_snapshot(session->ust_session,
4122 &tmp_output, session,
4123 wait, nb_packets_per_stream);
4124 if (ret != LTTNG_OK) {
4125 goto error;
4126 }
4127 }
4128
4129 snapshot_success = 1;
4130 } else {
4131 struct snapshot_output *sout;
4132 struct lttng_ht_iter iter;
4133
4134 rcu_read_lock();
4135 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
4136 &iter.iter, sout, node.node) {
4137 int64_t nb_packets_per_stream;
4138
4139 /*
4140 * Make a local copy of the output and assign the possible
4141 * temporary value given by the caller.
4142 */
4143 memset(&tmp_output, 0, sizeof(tmp_output));
4144 memcpy(&tmp_output, sout, sizeof(tmp_output));
4145
4146 if (output->max_size != (uint64_t) -1ULL) {
4147 tmp_output.max_size = output->max_size;
4148 }
4149
4150 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4151 tmp_output.max_size);
4152 if (nb_packets_per_stream < 0) {
4153 ret = LTTNG_ERR_MAX_SIZE_INVALID;
4154 rcu_read_unlock();
4155 goto error;
4156 }
4157
4158 /* Use temporary name. */
4159 if (*output->name != '\0') {
4160 if (lttng_strncpy(tmp_output.name, output->name,
4161 sizeof(tmp_output.name))) {
4162 ret = LTTNG_ERR_INVALID;
4163 rcu_read_unlock();
4164 goto error;
4165 }
4166 }
4167
4168 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
4169 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
4170
4171 if (session->kernel_session) {
4172 ret = record_kernel_snapshot(session->kernel_session,
4173 &tmp_output, session,
4174 wait, nb_packets_per_stream);
4175 if (ret != LTTNG_OK) {
4176 rcu_read_unlock();
4177 goto error;
4178 }
4179 }
4180
4181 if (session->ust_session) {
4182 ret = record_ust_snapshot(session->ust_session,
4183 &tmp_output, session,
4184 wait, nb_packets_per_stream);
4185 if (ret != LTTNG_OK) {
4186 rcu_read_unlock();
4187 goto error;
4188 }
4189 }
4190 snapshot_success = 1;
4191 }
4192 rcu_read_unlock();
4193 }
4194
4195 if (snapshot_success) {
4196 session->snapshot.nb_snapshot++;
4197 } else {
4198 ret = LTTNG_ERR_SNAPSHOT_FAIL;
4199 }
4200
4201 error:
4202 return ret;
4203 }
4204
4205 /*
4206 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
4207 */
4208 int cmd_set_session_shm_path(struct ltt_session *session,
4209 const char *shm_path)
4210 {
4211 /* Safety net */
4212 assert(session);
4213
4214 /*
4215 * Can only set shm path before session is started.
4216 */
4217 if (session->has_been_started) {
4218 return LTTNG_ERR_SESSION_STARTED;
4219 }
4220
4221 strncpy(session->shm_path, shm_path,
4222 sizeof(session->shm_path));
4223 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
4224
4225 return 0;
4226 }
4227
4228 /*
4229 * Init command subsystem.
4230 */
4231 void cmd_init(void)
4232 {
4233 /*
4234 * Set network sequence index to 1 for streams to match a relayd
4235 * socket on the consumer side.
4236 */
4237 pthread_mutex_lock(&relayd_net_seq_idx_lock);
4238 relayd_net_seq_idx = 1;
4239 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
4240
4241 DBG("Command subsystem initialized");
4242 }
LTTng 2.0 tools and control repository
This page took 0.108853 seconds and 5 git commands to generate.