projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: add-context cannot be performed after a session has been started
[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->fd,
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->fd,
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.trace_path, 0,
788 sizeof(consumer->dst.trace_path));
789 /* Explicit length checks for strcpy and strcat. */
790 if (strlen(uri->dst.path) + strlen(default_trace_dir)
791 >= sizeof(consumer->dst.trace_path)) {
792 ret = LTTNG_ERR_FATAL;
793 goto error;
794 }
795 strcpy(consumer->dst.trace_path, uri->dst.path);
796 /* Append default trace dir */
797 strcat(consumer->dst.trace_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 < 0) {
881 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
882 goto close_sock;
883 }
884 consumer->relay_major_version = rsock->major;
885 consumer->relay_minor_version = rsock->minor;
886 } else if (uri->stype == LTTNG_STREAM_DATA) {
887 DBG3("Creating relayd data socket from URI");
888 } else {
889 /* Command is not valid */
890 ERR("Relayd invalid stream type: %d", uri->stype);
891 ret = LTTNG_ERR_INVALID;
892 goto close_sock;
893 }
894
895 *relayd_sock = rsock;
896
897 return LTTNG_OK;
898
899 close_sock:
900 /* The returned value is not useful since we are on an error path. */
901 (void) relayd_close(rsock);
902 free_sock:
903 free(rsock);
904 error:
905 return ret;
906 }
907
908 /*
909 * Connect to the relayd using URI and send the socket to the right consumer.
910 *
911 * The consumer socket lock must be held by the caller.
912 */
913 static int send_consumer_relayd_socket(enum lttng_domain_type domain,
914 unsigned int session_id, struct lttng_uri *relayd_uri,
915 struct consumer_output *consumer,
916 struct consumer_socket *consumer_sock,
917 char *session_name, char *hostname, int session_live_timer)
918 {
919 int ret;
920 struct lttcomm_relayd_sock *rsock = NULL;
921
922 /* Connect to relayd and make version check if uri is the control. */
923 ret = create_connect_relayd(relayd_uri, &rsock, consumer);
924 if (ret != LTTNG_OK) {
925 goto relayd_comm_error;
926 }
927 assert(rsock);
928
929 /* Set the network sequence index if not set. */
930 if (consumer->net_seq_index == (uint64_t) -1ULL) {
931 pthread_mutex_lock(&relayd_net_seq_idx_lock);
932 /*
933 * Increment net_seq_idx because we are about to transfer the
934 * new relayd socket to the consumer.
935 * Assign unique key so the consumer can match streams.
936 */
937 consumer->net_seq_index = ++relayd_net_seq_idx;
938 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
939 }
940
941 /* Send relayd socket to consumer. */
942 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
943 relayd_uri->stype, session_id,
944 session_name, hostname, session_live_timer);
945 if (ret < 0) {
946 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
947 goto close_sock;
948 }
949
950 /* Flag that the corresponding socket was sent. */
951 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
952 consumer_sock->control_sock_sent = 1;
953 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
954 consumer_sock->data_sock_sent = 1;
955 }
956
957 ret = LTTNG_OK;
958
959 /*
960 * Close socket which was dup on the consumer side. The session daemon does
961 * NOT keep track of the relayd socket(s) once transfer to the consumer.
962 */
963
964 close_sock:
965 if (ret != LTTNG_OK) {
966 /*
967 * The consumer output for this session should not be used anymore
968 * since the relayd connection failed thus making any tracing or/and
969 * streaming not usable.
970 */
971 consumer->enabled = 0;
972 }
973 (void) relayd_close(rsock);
974 free(rsock);
975
976 relayd_comm_error:
977 return ret;
978 }
979
980 /*
981 * Send both relayd sockets to a specific consumer and domain. This is a
982 * helper function to facilitate sending the information to the consumer for a
983 * session.
984 *
985 * The consumer socket lock must be held by the caller.
986 */
987 static int send_consumer_relayd_sockets(enum lttng_domain_type domain,
988 unsigned int session_id, struct consumer_output *consumer,
989 struct consumer_socket *sock, char *session_name,
990 char *hostname, int session_live_timer)
991 {
992 int ret = LTTNG_OK;
993
994 assert(consumer);
995 assert(sock);
996
997 /* Sending control relayd socket. */
998 if (!sock->control_sock_sent) {
999 ret = send_consumer_relayd_socket(domain, session_id,
1000 &consumer->dst.net.control, consumer, sock,
1001 session_name, hostname, session_live_timer);
1002 if (ret != LTTNG_OK) {
1003 goto error;
1004 }
1005 }
1006
1007 /* Sending data relayd socket. */
1008 if (!sock->data_sock_sent) {
1009 ret = send_consumer_relayd_socket(domain, session_id,
1010 &consumer->dst.net.data, consumer, sock,
1011 session_name, hostname, session_live_timer);
1012 if (ret != LTTNG_OK) {
1013 goto error;
1014 }
1015 }
1016
1017 error:
1018 return ret;
1019 }
1020
1021 /*
1022 * Setup relayd connections for a tracing session. First creates the socket to
1023 * the relayd and send them to the right domain consumer. Consumer type MUST be
1024 * network.
1025 */
1026 int cmd_setup_relayd(struct ltt_session *session)
1027 {
1028 int ret = LTTNG_OK;
1029 struct ltt_ust_session *usess;
1030 struct ltt_kernel_session *ksess;
1031 struct consumer_socket *socket;
1032 struct lttng_ht_iter iter;
1033
1034 assert(session);
1035
1036 usess = session->ust_session;
1037 ksess = session->kernel_session;
1038
1039 DBG("Setting relayd for session %s", session->name);
1040
1041 rcu_read_lock();
1042
1043 if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
1044 && usess->consumer->enabled) {
1045 /* For each consumer socket, send relayd sockets */
1046 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
1047 socket, node.node) {
1048 pthread_mutex_lock(socket->lock);
1049 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
1050 usess->consumer, socket,
1051 session->name, session->hostname,
1052 session->live_timer);
1053 pthread_mutex_unlock(socket->lock);
1054 if (ret != LTTNG_OK) {
1055 goto error;
1056 }
1057 /* Session is now ready for network streaming. */
1058 session->net_handle = 1;
1059 }
1060 session->consumer->relay_major_version =
1061 usess->consumer->relay_major_version;
1062 session->consumer->relay_minor_version =
1063 usess->consumer->relay_minor_version;
1064 }
1065
1066 if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
1067 && ksess->consumer->enabled) {
1068 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1069 socket, node.node) {
1070 pthread_mutex_lock(socket->lock);
1071 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
1072 ksess->consumer, socket,
1073 session->name, session->hostname,
1074 session->live_timer);
1075 pthread_mutex_unlock(socket->lock);
1076 if (ret != LTTNG_OK) {
1077 goto error;
1078 }
1079 /* Session is now ready for network streaming. */
1080 session->net_handle = 1;
1081 }
1082 session->consumer->relay_major_version =
1083 ksess->consumer->relay_major_version;
1084 session->consumer->relay_minor_version =
1085 ksess->consumer->relay_minor_version;
1086 }
1087
1088 error:
1089 rcu_read_unlock();
1090 return ret;
1091 }
1092
1093 /*
1094 * Start a kernel session by opening all necessary streams.
1095 */
1096 static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe)
1097 {
1098 int ret;
1099 struct ltt_kernel_channel *kchan;
1100
1101 /* Open kernel metadata */
1102 if (ksess->metadata == NULL && ksess->output_traces) {
1103 ret = kernel_open_metadata(ksess);
1104 if (ret < 0) {
1105 ret = LTTNG_ERR_KERN_META_FAIL;
1106 goto error;
1107 }
1108 }
1109
1110 /* Open kernel metadata stream */
1111 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
1112 ret = kernel_open_metadata_stream(ksess);
1113 if (ret < 0) {
1114 ERR("Kernel create metadata stream failed");
1115 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1116 goto error;
1117 }
1118 }
1119
1120 /* For each channel */
1121 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1122 if (kchan->stream_count == 0) {
1123 ret = kernel_open_channel_stream(kchan);
1124 if (ret < 0) {
1125 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1126 goto error;
1127 }
1128 /* Update the stream global counter */
1129 ksess->stream_count_global += ret;
1130 }
1131 }
1132
1133 /* Setup kernel consumer socket and send fds to it */
1134 ret = init_kernel_tracing(ksess);
1135 if (ret != 0) {
1136 ret = LTTNG_ERR_KERN_START_FAIL;
1137 goto error;
1138 }
1139
1140 /* This start the kernel tracing */
1141 ret = kernel_start_session(ksess);
1142 if (ret < 0) {
1143 ret = LTTNG_ERR_KERN_START_FAIL;
1144 goto error;
1145 }
1146
1147 /* Quiescent wait after starting trace */
1148 kernel_wait_quiescent(kernel_tracer_fd);
1149
1150 ksess->active = 1;
1151
1152 ret = LTTNG_OK;
1153
1154 error:
1155 return ret;
1156 }
1157
1158 /*
1159 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1160 */
1161 int cmd_disable_channel(struct ltt_session *session,
1162 enum lttng_domain_type domain, char *channel_name)
1163 {
1164 int ret;
1165 struct ltt_ust_session *usess;
1166
1167 usess = session->ust_session;
1168
1169 rcu_read_lock();
1170
1171 switch (domain) {
1172 case LTTNG_DOMAIN_KERNEL:
1173 {
1174 ret = channel_kernel_disable(session->kernel_session,
1175 channel_name);
1176 if (ret != LTTNG_OK) {
1177 goto error;
1178 }
1179
1180 kernel_wait_quiescent(kernel_tracer_fd);
1181 break;
1182 }
1183 case LTTNG_DOMAIN_UST:
1184 {
1185 struct ltt_ust_channel *uchan;
1186 struct lttng_ht *chan_ht;
1187
1188 chan_ht = usess->domain_global.channels;
1189
1190 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
1191 if (uchan == NULL) {
1192 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1193 goto error;
1194 }
1195
1196 ret = channel_ust_disable(usess, uchan);
1197 if (ret != LTTNG_OK) {
1198 goto error;
1199 }
1200 break;
1201 }
1202 default:
1203 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1204 goto error;
1205 }
1206
1207 ret = LTTNG_OK;
1208
1209 error:
1210 rcu_read_unlock();
1211 return ret;
1212 }
1213
1214 /*
1215 * Command LTTNG_TRACK_PID processed by the client thread.
1216 *
1217 * Called with session lock held.
1218 */
1219 int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
1220 int pid)
1221 {
1222 int ret;
1223
1224 rcu_read_lock();
1225
1226 switch (domain) {
1227 case LTTNG_DOMAIN_KERNEL:
1228 {
1229 struct ltt_kernel_session *ksess;
1230
1231 ksess = session->kernel_session;
1232
1233 ret = kernel_track_pid(ksess, pid);
1234 if (ret != LTTNG_OK) {
1235 goto error;
1236 }
1237
1238 kernel_wait_quiescent(kernel_tracer_fd);
1239 break;
1240 }
1241 case LTTNG_DOMAIN_UST:
1242 {
1243 struct ltt_ust_session *usess;
1244
1245 usess = session->ust_session;
1246
1247 ret = trace_ust_track_pid(usess, pid);
1248 if (ret != LTTNG_OK) {
1249 goto error;
1250 }
1251 break;
1252 }
1253 default:
1254 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1255 goto error;
1256 }
1257
1258 ret = LTTNG_OK;
1259
1260 error:
1261 rcu_read_unlock();
1262 return ret;
1263 }
1264
1265 /*
1266 * Command LTTNG_UNTRACK_PID processed by the client thread.
1267 *
1268 * Called with session lock held.
1269 */
1270 int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
1271 int pid)
1272 {
1273 int ret;
1274
1275 rcu_read_lock();
1276
1277 switch (domain) {
1278 case LTTNG_DOMAIN_KERNEL:
1279 {
1280 struct ltt_kernel_session *ksess;
1281
1282 ksess = session->kernel_session;
1283
1284 ret = kernel_untrack_pid(ksess, pid);
1285 if (ret != LTTNG_OK) {
1286 goto error;
1287 }
1288
1289 kernel_wait_quiescent(kernel_tracer_fd);
1290 break;
1291 }
1292 case LTTNG_DOMAIN_UST:
1293 {
1294 struct ltt_ust_session *usess;
1295
1296 usess = session->ust_session;
1297
1298 ret = trace_ust_untrack_pid(usess, pid);
1299 if (ret != LTTNG_OK) {
1300 goto error;
1301 }
1302 break;
1303 }
1304 default:
1305 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1306 goto error;
1307 }
1308
1309 ret = LTTNG_OK;
1310
1311 error:
1312 rcu_read_unlock();
1313 return ret;
1314 }
1315
1316 /*
1317 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1318 *
1319 * The wpipe arguments is used as a notifier for the kernel thread.
1320 */
1321 int cmd_enable_channel(struct ltt_session *session,
1322 struct lttng_domain *domain, struct lttng_channel *attr, int wpipe)
1323 {
1324 int ret;
1325 struct ltt_ust_session *usess = session->ust_session;
1326 struct lttng_ht *chan_ht;
1327 size_t len;
1328
1329 assert(session);
1330 assert(attr);
1331 assert(domain);
1332
1333 len = lttng_strnlen(attr->name, sizeof(attr->name));
1334
1335 /* Validate channel name */
1336 if (attr->name[0] == '.' ||
1337 memchr(attr->name, '/', len) != NULL) {
1338 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1339 goto end;
1340 }
1341
1342 DBG("Enabling channel %s for session %s", attr->name, session->name);
1343
1344 rcu_read_lock();
1345
1346 /*
1347 * Don't try to enable a channel if the session has been started at
1348 * some point in time before. The tracer does not allow it.
1349 */
1350 if (session->has_been_started) {
1351 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1352 goto error;
1353 }
1354
1355 /*
1356 * If the session is a live session, remove the switch timer, the
1357 * live timer does the same thing but sends also synchronisation
1358 * beacons for inactive streams.
1359 */
1360 if (session->live_timer > 0) {
1361 attr->attr.live_timer_interval = session->live_timer;
1362 attr->attr.switch_timer_interval = 0;
1363 }
1364
1365 /* Check for feature support */
1366 switch (domain->type) {
1367 case LTTNG_DOMAIN_KERNEL:
1368 {
1369 if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) {
1370 /* Sampling position of buffer is not supported */
1371 WARN("Kernel tracer does not support buffer monitoring. "
1372 "Setting the monitor interval timer to 0 "
1373 "(disabled) for channel '%s' of session '%s'",
1374 attr-> name, session->name);
1375 lttng_channel_set_monitor_timer_interval(attr, 0);
1376 }
1377 break;
1378 }
1379 case LTTNG_DOMAIN_UST:
1380 case LTTNG_DOMAIN_JUL:
1381 case LTTNG_DOMAIN_LOG4J:
1382 case LTTNG_DOMAIN_PYTHON:
1383 break;
1384 default:
1385 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1386 goto error;
1387 }
1388
1389 switch (domain->type) {
1390 case LTTNG_DOMAIN_KERNEL:
1391 {
1392 struct ltt_kernel_channel *kchan;
1393
1394 kchan = trace_kernel_get_channel_by_name(attr->name,
1395 session->kernel_session);
1396 if (kchan == NULL) {
1397 ret = channel_kernel_create(session->kernel_session, attr, wpipe);
1398 if (attr->name[0] != '\0') {
1399 session->kernel_session->has_non_default_channel = 1;
1400 }
1401 } else {
1402 ret = channel_kernel_enable(session->kernel_session, kchan);
1403 }
1404
1405 if (ret != LTTNG_OK) {
1406 goto error;
1407 }
1408
1409 kernel_wait_quiescent(kernel_tracer_fd);
1410 break;
1411 }
1412 case LTTNG_DOMAIN_UST:
1413 case LTTNG_DOMAIN_JUL:
1414 case LTTNG_DOMAIN_LOG4J:
1415 case LTTNG_DOMAIN_PYTHON:
1416 {
1417 struct ltt_ust_channel *uchan;
1418
1419 /*
1420 * FIXME
1421 *
1422 * Current agent implementation limitations force us to allow
1423 * only one channel at once in "agent" subdomains. Each
1424 * subdomain has a default channel name which must be strictly
1425 * adhered to.
1426 */
1427 if (domain->type == LTTNG_DOMAIN_JUL) {
1428 if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
1429 LTTNG_SYMBOL_NAME_LEN)) {
1430 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1431 goto error;
1432 }
1433 } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
1434 if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
1435 LTTNG_SYMBOL_NAME_LEN)) {
1436 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1437 goto error;
1438 }
1439 } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
1440 if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
1441 LTTNG_SYMBOL_NAME_LEN)) {
1442 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1443 goto error;
1444 }
1445 }
1446
1447 chan_ht = usess->domain_global.channels;
1448
1449 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
1450 if (uchan == NULL) {
1451 ret = channel_ust_create(usess, attr, domain->buf_type);
1452 if (attr->name[0] != '\0') {
1453 usess->has_non_default_channel = 1;
1454 }
1455 } else {
1456 ret = channel_ust_enable(usess, uchan);
1457 }
1458 break;
1459 }
1460 default:
1461 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1462 goto error;
1463 }
1464
1465 error:
1466 rcu_read_unlock();
1467 end:
1468 return ret;
1469 }
1470
1471 /*
1472 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1473 */
1474 int cmd_disable_event(struct ltt_session *session,
1475 enum lttng_domain_type domain, char *channel_name,
1476 struct lttng_event *event)
1477 {
1478 int ret;
1479 char *event_name;
1480
1481 DBG("Disable event command for event \'%s\'", event->name);
1482
1483 event_name = event->name;
1484
1485 /* Error out on unhandled search criteria */
1486 if (event->loglevel_type || event->loglevel != -1 || event->enabled
1487 || event->pid || event->filter || event->exclusion) {
1488 ret = LTTNG_ERR_UNK;
1489 goto error;
1490 }
1491
1492 rcu_read_lock();
1493
1494 switch (domain) {
1495 case LTTNG_DOMAIN_KERNEL:
1496 {
1497 struct ltt_kernel_channel *kchan;
1498 struct ltt_kernel_session *ksess;
1499
1500 ksess = session->kernel_session;
1501
1502 /*
1503 * If a non-default channel has been created in the
1504 * session, explicitely require that -c chan_name needs
1505 * to be provided.
1506 */
1507 if (ksess->has_non_default_channel && channel_name[0] == '\0') {
1508 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1509 goto error_unlock;
1510 }
1511
1512 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1513 if (kchan == NULL) {
1514 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
1515 goto error_unlock;
1516 }
1517
1518 switch (event->type) {
1519 case LTTNG_EVENT_ALL:
1520 case LTTNG_EVENT_TRACEPOINT:
1521 case LTTNG_EVENT_SYSCALL:
1522 case LTTNG_EVENT_PROBE:
1523 case LTTNG_EVENT_FUNCTION:
1524 case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
1525 if (event_name[0] == '\0') {
1526 ret = event_kernel_disable_event(kchan,
1527 NULL, event->type);
1528 } else {
1529 ret = event_kernel_disable_event(kchan,
1530 event_name, event->type);
1531 }
1532 if (ret != LTTNG_OK) {
1533 goto error_unlock;
1534 }
1535 break;
1536 default:
1537 ret = LTTNG_ERR_UNK;
1538 goto error_unlock;
1539 }
1540
1541 kernel_wait_quiescent(kernel_tracer_fd);
1542 break;
1543 }
1544 case LTTNG_DOMAIN_UST:
1545 {
1546 struct ltt_ust_channel *uchan;
1547 struct ltt_ust_session *usess;
1548
1549 usess = session->ust_session;
1550
1551 if (validate_ust_event_name(event_name)) {
1552 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1553 goto error_unlock;
1554 }
1555
1556 /*
1557 * If a non-default channel has been created in the
1558 * session, explicitly require that -c chan_name needs
1559 * to be provided.
1560 */
1561 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1562 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1563 goto error_unlock;
1564 }
1565
1566 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1567 channel_name);
1568 if (uchan == NULL) {
1569 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1570 goto error_unlock;
1571 }
1572
1573 switch (event->type) {
1574 case LTTNG_EVENT_ALL:
1575 /*
1576 * An empty event name means that everything
1577 * should be disabled.
1578 */
1579 if (event->name[0] == '\0') {
1580 ret = event_ust_disable_all_tracepoints(usess, uchan);
1581 } else {
1582 ret = event_ust_disable_tracepoint(usess, uchan,
1583 event_name);
1584 }
1585 if (ret != LTTNG_OK) {
1586 goto error_unlock;
1587 }
1588 break;
1589 default:
1590 ret = LTTNG_ERR_UNK;
1591 goto error_unlock;
1592 }
1593
1594 DBG3("Disable UST event %s in channel %s completed", event_name,
1595 channel_name);
1596 break;
1597 }
1598 case LTTNG_DOMAIN_LOG4J:
1599 case LTTNG_DOMAIN_JUL:
1600 case LTTNG_DOMAIN_PYTHON:
1601 {
1602 struct agent *agt;
1603 struct ltt_ust_session *usess = session->ust_session;
1604
1605 assert(usess);
1606
1607 switch (event->type) {
1608 case LTTNG_EVENT_ALL:
1609 break;
1610 default:
1611 ret = LTTNG_ERR_UNK;
1612 goto error_unlock;
1613 }
1614
1615 agt = trace_ust_find_agent(usess, domain);
1616 if (!agt) {
1617 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
1618 goto error_unlock;
1619 }
1620 /*
1621 * An empty event name means that everything
1622 * should be disabled.
1623 */
1624 if (event->name[0] == '\0') {
1625 ret = event_agent_disable_all(usess, agt);
1626 } else {
1627 ret = event_agent_disable(usess, agt, event_name);
1628 }
1629 if (ret != LTTNG_OK) {
1630 goto error_unlock;
1631 }
1632
1633 break;
1634 }
1635 default:
1636 ret = LTTNG_ERR_UND;
1637 goto error_unlock;
1638 }
1639
1640 ret = LTTNG_OK;
1641
1642 error_unlock:
1643 rcu_read_unlock();
1644 error:
1645 return ret;
1646 }
1647
1648 /*
1649 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1650 */
1651 int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
1652 char *channel_name, struct lttng_event_context *ctx, int kwpipe)
1653 {
1654 int ret, chan_kern_created = 0, chan_ust_created = 0;
1655 char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
1656
1657 /*
1658 * Don't try to add a context if the session has been started at
1659 * some point in time before. The tracer does not allow it and would
1660 * result in a corrupted trace.
1661 */
1662 if (session->has_been_started) {
1663 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1664 goto end;
1665 }
1666
1667 if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
1668 app_ctx_provider_name = ctx->u.app_ctx.provider_name;
1669 app_ctx_name = ctx->u.app_ctx.ctx_name;
1670 }
1671
1672 switch (domain) {
1673 case LTTNG_DOMAIN_KERNEL:
1674 assert(session->kernel_session);
1675
1676 if (session->kernel_session->channel_count == 0) {
1677 /* Create default channel */
1678 ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
1679 if (ret != LTTNG_OK) {
1680 goto error;
1681 }
1682 chan_kern_created = 1;
1683 }
1684 /* Add kernel context to kernel tracer */
1685 ret = context_kernel_add(session->kernel_session, ctx, channel_name);
1686 if (ret != LTTNG_OK) {
1687 goto error;
1688 }
1689 break;
1690 case LTTNG_DOMAIN_JUL:
1691 case LTTNG_DOMAIN_LOG4J:
1692 {
1693 /*
1694 * Validate channel name.
1695 * If no channel name is given and the domain is JUL or LOG4J,
1696 * set it to the appropriate domain-specific channel name. If
1697 * a name is provided but does not match the expexted channel
1698 * name, return an error.
1699 */
1700 if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
1701 strcmp(channel_name,
1702 DEFAULT_JUL_CHANNEL_NAME)) {
1703 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1704 goto error;
1705 } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
1706 strcmp(channel_name,
1707 DEFAULT_LOG4J_CHANNEL_NAME)) {
1708 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1709 goto error;
1710 }
1711 /* break is _not_ missing here. */
1712 }
1713 case LTTNG_DOMAIN_UST:
1714 {
1715 struct ltt_ust_session *usess = session->ust_session;
1716 unsigned int chan_count;
1717
1718 assert(usess);
1719
1720 chan_count = lttng_ht_get_count(usess->domain_global.channels);
1721 if (chan_count == 0) {
1722 struct lttng_channel *attr;
1723 /* Create default channel */
1724 attr = channel_new_default_attr(domain, usess->buffer_type);
1725 if (attr == NULL) {
1726 ret = LTTNG_ERR_FATAL;
1727 goto error;
1728 }
1729
1730 ret = channel_ust_create(usess, attr, usess->buffer_type);
1731 if (ret != LTTNG_OK) {
1732 free(attr);
1733 goto error;
1734 }
1735 channel_attr_destroy(attr);
1736 chan_ust_created = 1;
1737 }
1738
1739 ret = context_ust_add(usess, domain, ctx, channel_name);
1740 free(app_ctx_provider_name);
1741 free(app_ctx_name);
1742 app_ctx_name = NULL;
1743 app_ctx_provider_name = NULL;
1744 if (ret != LTTNG_OK) {
1745 goto error;
1746 }
1747 break;
1748 }
1749 default:
1750 ret = LTTNG_ERR_UND;
1751 goto error;
1752 }
1753
1754 ret = LTTNG_OK;
1755 goto end;
1756
1757 error:
1758 if (chan_kern_created) {
1759 struct ltt_kernel_channel *kchan =
1760 trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
1761 session->kernel_session);
1762 /* Created previously, this should NOT fail. */
1763 assert(kchan);
1764 kernel_destroy_channel(kchan);
1765 }
1766
1767 if (chan_ust_created) {
1768 struct ltt_ust_channel *uchan =
1769 trace_ust_find_channel_by_name(
1770 session->ust_session->domain_global.channels,
1771 DEFAULT_CHANNEL_NAME);
1772 /* Created previously, this should NOT fail. */
1773 assert(uchan);
1774 /* Remove from the channel list of the session. */
1775 trace_ust_delete_channel(session->ust_session->domain_global.channels,
1776 uchan);
1777 trace_ust_destroy_channel(uchan);
1778 }
1779 end:
1780 free(app_ctx_provider_name);
1781 free(app_ctx_name);
1782 return ret;
1783 }
1784
1785 static inline bool name_starts_with(const char *name, const char *prefix)
1786 {
1787 const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
1788
1789 return !strncmp(name, prefix, max_cmp_len);
1790 }
1791
1792 /* Perform userspace-specific event name validation */
1793 static int validate_ust_event_name(const char *name)
1794 {
1795 int ret = 0;
1796
1797 if (!name) {
1798 ret = -1;
1799 goto end;
1800 }
1801
1802 /*
1803 * Check name against all internal UST event component namespaces used
1804 * by the agents.
1805 */
1806 if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
1807 name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
1808 name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
1809 ret = -1;
1810 }
1811
1812 end:
1813 return ret;
1814 }
1815
1816 /*
1817 * Internal version of cmd_enable_event() with a supplemental
1818 * "internal_event" flag which is used to enable internal events which should
1819 * be hidden from clients. Such events are used in the agent implementation to
1820 * enable the events through which all "agent" events are funeled.
1821 */
1822 static int _cmd_enable_event(struct ltt_session *session,
1823 struct lttng_domain *domain,
1824 char *channel_name, struct lttng_event *event,
1825 char *filter_expression,
1826 struct lttng_filter_bytecode *filter,
1827 struct lttng_event_exclusion *exclusion,
1828 int wpipe, bool internal_event)
1829 {
1830 int ret = 0, channel_created = 0;
1831 struct lttng_channel *attr = NULL;
1832
1833 assert(session);
1834 assert(event);
1835 assert(channel_name);
1836
1837 /* If we have a filter, we must have its filter expression */
1838 assert(!(!!filter_expression ^ !!filter));
1839
1840 /* Normalize event name as a globbing pattern */
1841 strutils_normalize_star_glob_pattern(event->name);
1842
1843 /* Normalize exclusion names as globbing patterns */
1844 if (exclusion) {
1845 size_t i;
1846
1847 for (i = 0; i < exclusion->count; i++) {
1848 char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i);
1849
1850 strutils_normalize_star_glob_pattern(name);
1851 }
1852 }
1853
1854 DBG("Enable event command for event \'%s\'", event->name);
1855
1856 rcu_read_lock();
1857
1858 switch (domain->type) {
1859 case LTTNG_DOMAIN_KERNEL:
1860 {
1861 struct ltt_kernel_channel *kchan;
1862
1863 /*
1864 * If a non-default channel has been created in the
1865 * session, explicitely require that -c chan_name needs
1866 * to be provided.
1867 */
1868 if (session->kernel_session->has_non_default_channel
1869 && channel_name[0] == '\0') {
1870 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
1871 goto error;
1872 }
1873
1874 kchan = trace_kernel_get_channel_by_name(channel_name,
1875 session->kernel_session);
1876 if (kchan == NULL) {
1877 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
1878 LTTNG_BUFFER_GLOBAL);
1879 if (attr == NULL) {
1880 ret = LTTNG_ERR_FATAL;
1881 goto error;
1882 }
1883 if (lttng_strncpy(attr->name, channel_name,
1884 sizeof(attr->name))) {
1885 ret = LTTNG_ERR_INVALID;
1886 goto error;
1887 }
1888
1889 ret = cmd_enable_channel(session, domain, attr, wpipe);
1890 if (ret != LTTNG_OK) {
1891 goto error;
1892 }
1893 channel_created = 1;
1894 }
1895
1896 /* Get the newly created kernel channel pointer */
1897 kchan = trace_kernel_get_channel_by_name(channel_name,
1898 session->kernel_session);
1899 if (kchan == NULL) {
1900 /* This sould not happen... */
1901 ret = LTTNG_ERR_FATAL;
1902 goto error;
1903 }
1904
1905 switch (event->type) {
1906 case LTTNG_EVENT_ALL:
1907 {
1908 char *filter_expression_a = NULL;
1909 struct lttng_filter_bytecode *filter_a = NULL;
1910
1911 /*
1912 * We need to duplicate filter_expression and filter,
1913 * because ownership is passed to first enable
1914 * event.
1915 */
1916 if (filter_expression) {
1917 filter_expression_a = strdup(filter_expression);
1918 if (!filter_expression_a) {
1919 ret = LTTNG_ERR_FATAL;
1920 goto error;
1921 }
1922 }
1923 if (filter) {
1924 filter_a = zmalloc(sizeof(*filter_a) + filter->len);
1925 if (!filter_a) {
1926 free(filter_expression_a);
1927 ret = LTTNG_ERR_FATAL;
1928 goto error;
1929 }
1930 memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
1931 }
1932 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
1933 ret = event_kernel_enable_event(kchan, event,
1934 filter_expression, filter);
1935 /* We have passed ownership */
1936 filter_expression = NULL;
1937 filter = NULL;
1938 if (ret != LTTNG_OK) {
1939 if (channel_created) {
1940 /* Let's not leak a useless channel. */
1941 kernel_destroy_channel(kchan);
1942 }
1943 free(filter_expression_a);
1944 free(filter_a);
1945 goto error;
1946 }
1947 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
1948 ret = event_kernel_enable_event(kchan, event,
1949 filter_expression_a, filter_a);
1950 /* We have passed ownership */
1951 filter_expression_a = NULL;
1952 filter_a = NULL;
1953 if (ret != LTTNG_OK) {
1954 goto error;
1955 }
1956 break;
1957 }
1958 case LTTNG_EVENT_PROBE:
1959 case LTTNG_EVENT_FUNCTION:
1960 case LTTNG_EVENT_FUNCTION_ENTRY:
1961 case LTTNG_EVENT_TRACEPOINT:
1962 ret = event_kernel_enable_event(kchan, event,
1963 filter_expression, filter);
1964 /* We have passed ownership */
1965 filter_expression = NULL;
1966 filter = NULL;
1967 if (ret != LTTNG_OK) {
1968 if (channel_created) {
1969 /* Let's not leak a useless channel. */
1970 kernel_destroy_channel(kchan);
1971 }
1972 goto error;
1973 }
1974 break;
1975 case LTTNG_EVENT_SYSCALL:
1976 ret = event_kernel_enable_event(kchan, event,
1977 filter_expression, filter);
1978 /* We have passed ownership */
1979 filter_expression = NULL;
1980 filter = NULL;
1981 if (ret != LTTNG_OK) {
1982 goto error;
1983 }
1984 break;
1985 default:
1986 ret = LTTNG_ERR_UNK;
1987 goto error;
1988 }
1989
1990 kernel_wait_quiescent(kernel_tracer_fd);
1991 break;
1992 }
1993 case LTTNG_DOMAIN_UST:
1994 {
1995 struct ltt_ust_channel *uchan;
1996 struct ltt_ust_session *usess = session->ust_session;
1997
1998 assert(usess);
1999
2000 /*
2001 * If a non-default channel has been created in the
2002 * session, explicitely require that -c chan_name needs
2003 * to be provided.
2004 */
2005 if (usess->has_non_default_channel && channel_name[0] == '\0') {
2006 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2007 goto error;
2008 }
2009
2010 /* Get channel from global UST domain */
2011 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2012 channel_name);
2013 if (uchan == NULL) {
2014 /* Create default channel */
2015 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2016 usess->buffer_type);
2017 if (attr == NULL) {
2018 ret = LTTNG_ERR_FATAL;
2019 goto error;
2020 }
2021 if (lttng_strncpy(attr->name, channel_name,
2022 sizeof(attr->name))) {
2023 ret = LTTNG_ERR_INVALID;
2024 goto error;
2025 }
2026
2027 ret = cmd_enable_channel(session, domain, attr, wpipe);
2028 if (ret != LTTNG_OK) {
2029 goto error;
2030 }
2031
2032 /* Get the newly created channel reference back */
2033 uchan = trace_ust_find_channel_by_name(
2034 usess->domain_global.channels, channel_name);
2035 assert(uchan);
2036 }
2037
2038 if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
2039 /*
2040 * Don't allow users to add UST events to channels which
2041 * are assigned to a userspace subdomain (JUL, Log4J,
2042 * Python, etc.).
2043 */
2044 ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
2045 goto error;
2046 }
2047
2048 if (!internal_event) {
2049 /*
2050 * Ensure the event name is not reserved for internal
2051 * use.
2052 */
2053 ret = validate_ust_event_name(event->name);
2054 if (ret) {
2055 WARN("Userspace event name %s failed validation.",
2056 event->name ?
2057 event->name : "NULL");
2058 ret = LTTNG_ERR_INVALID_EVENT_NAME;
2059 goto error;
2060 }
2061 }
2062
2063 /* At this point, the session and channel exist on the tracer */
2064 ret = event_ust_enable_tracepoint(usess, uchan, event,
2065 filter_expression, filter, exclusion,
2066 internal_event);
2067 /* We have passed ownership */
2068 filter_expression = NULL;
2069 filter = NULL;
2070 exclusion = NULL;
2071 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2072 goto already_enabled;
2073 } else if (ret != LTTNG_OK) {
2074 goto error;
2075 }
2076 break;
2077 }
2078 case LTTNG_DOMAIN_LOG4J:
2079 case LTTNG_DOMAIN_JUL:
2080 case LTTNG_DOMAIN_PYTHON:
2081 {
2082 const char *default_event_name, *default_chan_name;
2083 struct agent *agt;
2084 struct lttng_event uevent;
2085 struct lttng_domain tmp_dom;
2086 struct ltt_ust_session *usess = session->ust_session;
2087
2088 assert(usess);
2089
2090 agt = trace_ust_find_agent(usess, domain->type);
2091 if (!agt) {
2092 agt = agent_create(domain->type);
2093 if (!agt) {
2094 ret = LTTNG_ERR_NOMEM;
2095 goto error;
2096 }
2097 agent_add(agt, usess->agents);
2098 }
2099
2100 /* Create the default tracepoint. */
2101 memset(&uevent, 0, sizeof(uevent));
2102 uevent.type = LTTNG_EVENT_TRACEPOINT;
2103 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
2104 default_event_name = event_get_default_agent_ust_name(
2105 domain->type);
2106 if (!default_event_name) {
2107 ret = LTTNG_ERR_FATAL;
2108 goto error;
2109 }
2110 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
2111 uevent.name[sizeof(uevent.name) - 1] = '\0';
2112
2113 /*
2114 * The domain type is changed because we are about to enable the
2115 * default channel and event for the JUL domain that are hardcoded.
2116 * This happens in the UST domain.
2117 */
2118 memcpy(&tmp_dom, domain, sizeof(tmp_dom));
2119 tmp_dom.type = LTTNG_DOMAIN_UST;
2120
2121 switch (domain->type) {
2122 case LTTNG_DOMAIN_LOG4J:
2123 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
2124 break;
2125 case LTTNG_DOMAIN_JUL:
2126 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
2127 break;
2128 case LTTNG_DOMAIN_PYTHON:
2129 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2130 break;
2131 default:
2132 /* The switch/case we are in makes this impossible */
2133 assert(0);
2134 }
2135
2136 {
2137 char *filter_expression_copy = NULL;
2138 struct lttng_filter_bytecode *filter_copy = NULL;
2139
2140 if (filter) {
2141 const size_t filter_size = sizeof(
2142 struct lttng_filter_bytecode)
2143 + filter->len;
2144
2145 filter_copy = zmalloc(filter_size);
2146 if (!filter_copy) {
2147 ret = LTTNG_ERR_NOMEM;
2148 goto error;
2149 }
2150 memcpy(filter_copy, filter, filter_size);
2151
2152 filter_expression_copy =
2153 strdup(filter_expression);
2154 if (!filter_expression) {
2155 ret = LTTNG_ERR_NOMEM;
2156 }
2157
2158 if (!filter_expression_copy || !filter_copy) {
2159 free(filter_expression_copy);
2160 free(filter_copy);
2161 goto error;
2162 }
2163 }
2164
2165 ret = cmd_enable_event_internal(session, &tmp_dom,
2166 (char *) default_chan_name,
2167 &uevent, filter_expression_copy,
2168 filter_copy, NULL, wpipe);
2169 }
2170
2171 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2172 goto already_enabled;
2173 } else if (ret != LTTNG_OK) {
2174 goto error;
2175 }
2176
2177 /* The wild card * means that everything should be enabled. */
2178 if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
2179 ret = event_agent_enable_all(usess, agt, event, filter,
2180 filter_expression);
2181 } else {
2182 ret = event_agent_enable(usess, agt, event, filter,
2183 filter_expression);
2184 }
2185 filter = NULL;
2186 filter_expression = NULL;
2187 if (ret != LTTNG_OK) {
2188 goto error;
2189 }
2190
2191 break;
2192 }
2193 default:
2194 ret = LTTNG_ERR_UND;
2195 goto error;
2196 }
2197
2198 ret = LTTNG_OK;
2199
2200 already_enabled:
2201 error:
2202 free(filter_expression);
2203 free(filter);
2204 free(exclusion);
2205 channel_attr_destroy(attr);
2206 rcu_read_unlock();
2207 return ret;
2208 }
2209
2210 /*
2211 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2212 * We own filter, exclusion, and filter_expression.
2213 */
2214 int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
2215 char *channel_name, struct lttng_event *event,
2216 char *filter_expression,
2217 struct lttng_filter_bytecode *filter,
2218 struct lttng_event_exclusion *exclusion,
2219 int wpipe)
2220 {
2221 return _cmd_enable_event(session, domain, channel_name, event,
2222 filter_expression, filter, exclusion, wpipe, false);
2223 }
2224
2225 /*
2226 * Enable an event which is internal to LTTng. An internal should
2227 * never be made visible to clients and are immune to checks such as
2228 * reserved names.
2229 */
2230 static int cmd_enable_event_internal(struct ltt_session *session,
2231 struct lttng_domain *domain,
2232 char *channel_name, struct lttng_event *event,
2233 char *filter_expression,
2234 struct lttng_filter_bytecode *filter,
2235 struct lttng_event_exclusion *exclusion,
2236 int wpipe)
2237 {
2238 return _cmd_enable_event(session, domain, channel_name, event,
2239 filter_expression, filter, exclusion, wpipe, true);
2240 }
2241
2242 /*
2243 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2244 */
2245 ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
2246 struct lttng_event **events)
2247 {
2248 int ret;
2249 ssize_t nb_events = 0;
2250
2251 switch (domain) {
2252 case LTTNG_DOMAIN_KERNEL:
2253 nb_events = kernel_list_events(kernel_tracer_fd, events);
2254 if (nb_events < 0) {
2255 ret = LTTNG_ERR_KERN_LIST_FAIL;
2256 goto error;
2257 }
2258 break;
2259 case LTTNG_DOMAIN_UST:
2260 nb_events = ust_app_list_events(events);
2261 if (nb_events < 0) {
2262 ret = LTTNG_ERR_UST_LIST_FAIL;
2263 goto error;
2264 }
2265 break;
2266 case LTTNG_DOMAIN_LOG4J:
2267 case LTTNG_DOMAIN_JUL:
2268 case LTTNG_DOMAIN_PYTHON:
2269 nb_events = agent_list_events(events, domain);
2270 if (nb_events < 0) {
2271 ret = LTTNG_ERR_UST_LIST_FAIL;
2272 goto error;
2273 }
2274 break;
2275 default:
2276 ret = LTTNG_ERR_UND;
2277 goto error;
2278 }
2279
2280 return nb_events;
2281
2282 error:
2283 /* Return negative value to differentiate return code */
2284 return -ret;
2285 }
2286
2287 /*
2288 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2289 */
2290 ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2291 struct lttng_event_field **fields)
2292 {
2293 int ret;
2294 ssize_t nb_fields = 0;
2295
2296 switch (domain) {
2297 case LTTNG_DOMAIN_UST:
2298 nb_fields = ust_app_list_event_fields(fields);
2299 if (nb_fields < 0) {
2300 ret = LTTNG_ERR_UST_LIST_FAIL;
2301 goto error;
2302 }
2303 break;
2304 case LTTNG_DOMAIN_KERNEL:
2305 default: /* fall-through */
2306 ret = LTTNG_ERR_UND;
2307 goto error;
2308 }
2309
2310 return nb_fields;
2311
2312 error:
2313 /* Return negative value to differentiate return code */
2314 return -ret;
2315 }
2316
2317 ssize_t cmd_list_syscalls(struct lttng_event **events)
2318 {
2319 return syscall_table_list(events);
2320 }
2321
2322 /*
2323 * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
2324 *
2325 * Called with session lock held.
2326 */
2327 ssize_t cmd_list_tracker_pids(struct ltt_session *session,
2328 enum lttng_domain_type domain, int32_t **pids)
2329 {
2330 int ret;
2331 ssize_t nr_pids = 0;
2332
2333 switch (domain) {
2334 case LTTNG_DOMAIN_KERNEL:
2335 {
2336 struct ltt_kernel_session *ksess;
2337
2338 ksess = session->kernel_session;
2339 nr_pids = kernel_list_tracker_pids(ksess, pids);
2340 if (nr_pids < 0) {
2341 ret = LTTNG_ERR_KERN_LIST_FAIL;
2342 goto error;
2343 }
2344 break;
2345 }
2346 case LTTNG_DOMAIN_UST:
2347 {
2348 struct ltt_ust_session *usess;
2349
2350 usess = session->ust_session;
2351 nr_pids = trace_ust_list_tracker_pids(usess, pids);
2352 if (nr_pids < 0) {
2353 ret = LTTNG_ERR_UST_LIST_FAIL;
2354 goto error;
2355 }
2356 break;
2357 }
2358 case LTTNG_DOMAIN_LOG4J:
2359 case LTTNG_DOMAIN_JUL:
2360 case LTTNG_DOMAIN_PYTHON:
2361 default:
2362 ret = LTTNG_ERR_UND;
2363 goto error;
2364 }
2365
2366 return nr_pids;
2367
2368 error:
2369 /* Return negative value to differentiate return code */
2370 return -ret;
2371 }
2372
2373 /*
2374 * Command LTTNG_START_TRACE processed by the client thread.
2375 *
2376 * Called with session mutex held.
2377 */
2378 int cmd_start_trace(struct ltt_session *session)
2379 {
2380 int ret;
2381 unsigned long nb_chan = 0;
2382 struct ltt_kernel_session *ksession;
2383 struct ltt_ust_session *usess;
2384
2385 assert(session);
2386
2387 /* Ease our life a bit ;) */
2388 ksession = session->kernel_session;
2389 usess = session->ust_session;
2390
2391 /* Is the session already started? */
2392 if (session->active) {
2393 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2394 goto error;
2395 }
2396
2397 /*
2398 * Starting a session without channel is useless since after that it's not
2399 * possible to enable channel thus inform the client.
2400 */
2401 if (usess && usess->domain_global.channels) {
2402 nb_chan += lttng_ht_get_count(usess->domain_global.channels);
2403 }
2404 if (ksession) {
2405 nb_chan += ksession->channel_count;
2406 }
2407 if (!nb_chan) {
2408 ret = LTTNG_ERR_NO_CHANNEL;
2409 goto error;
2410 }
2411
2412 /* Kernel tracing */
2413 if (ksession != NULL) {
2414 ret = start_kernel_session(ksession, kernel_tracer_fd);
2415 if (ret != LTTNG_OK) {
2416 goto error;
2417 }
2418 }
2419
2420 /* Flag session that trace should start automatically */
2421 if (usess) {
2422 /*
2423 * Even though the start trace might fail, flag this session active so
2424 * other application coming in are started by default.
2425 */
2426 usess->active = 1;
2427
2428 ret = ust_app_start_trace_all(usess);
2429 if (ret < 0) {
2430 ret = LTTNG_ERR_UST_START_FAIL;
2431 goto error;
2432 }
2433 }
2434
2435 /* Flag this after a successful start. */
2436 session->has_been_started = 1;
2437 session->active = 1;
2438
2439 ret = LTTNG_OK;
2440
2441 error:
2442 return ret;
2443 }
2444
2445 /*
2446 * Command LTTNG_STOP_TRACE processed by the client thread.
2447 */
2448 int cmd_stop_trace(struct ltt_session *session)
2449 {
2450 int ret;
2451 struct ltt_kernel_channel *kchan;
2452 struct ltt_kernel_session *ksession;
2453 struct ltt_ust_session *usess;
2454
2455 assert(session);
2456
2457 /* Short cut */
2458 ksession = session->kernel_session;
2459 usess = session->ust_session;
2460
2461 /* Session is not active. Skip everythong and inform the client. */
2462 if (!session->active) {
2463 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2464 goto error;
2465 }
2466
2467 /* Kernel tracer */
2468 if (ksession && ksession->active) {
2469 DBG("Stop kernel tracing");
2470
2471 ret = kernel_stop_session(ksession);
2472 if (ret < 0) {
2473 ret = LTTNG_ERR_KERN_STOP_FAIL;
2474 goto error;
2475 }
2476
2477 kernel_wait_quiescent(kernel_tracer_fd);
2478
2479 /* Flush metadata after stopping (if exists) */
2480 if (ksession->metadata_stream_fd >= 0) {
2481 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
2482 if (ret < 0) {
2483 ERR("Kernel metadata flush failed");
2484 }
2485 }
2486
2487 /* Flush all buffers after stopping */
2488 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2489 ret = kernel_flush_buffer(kchan);
2490 if (ret < 0) {
2491 ERR("Kernel flush buffer error");
2492 }
2493 }
2494
2495 ksession->active = 0;
2496 }
2497
2498 if (usess && usess->active) {
2499 /*
2500 * Even though the stop trace might fail, flag this session inactive so
2501 * other application coming in are not started by default.
2502 */
2503 usess->active = 0;
2504
2505 ret = ust_app_stop_trace_all(usess);
2506 if (ret < 0) {
2507 ret = LTTNG_ERR_UST_STOP_FAIL;
2508 goto error;
2509 }
2510 }
2511
2512 /* Flag inactive after a successful stop. */
2513 session->active = 0;
2514 ret = LTTNG_OK;
2515
2516 error:
2517 return ret;
2518 }
2519
2520 /*
2521 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2522 */
2523 int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2524 struct lttng_uri *uris)
2525 {
2526 int ret, i;
2527 struct ltt_kernel_session *ksess = session->kernel_session;
2528 struct ltt_ust_session *usess = session->ust_session;
2529
2530 assert(session);
2531 assert(uris);
2532 assert(nb_uri > 0);
2533
2534 /* Can't set consumer URI if the session is active. */
2535 if (session->active) {
2536 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2537 goto error;
2538 }
2539
2540 /* Set the "global" consumer URIs */
2541 for (i = 0; i < nb_uri; i++) {
2542 ret = add_uri_to_consumer(session->consumer,
2543 &uris[i], 0, session->name);
2544 if (ret != LTTNG_OK) {
2545 goto error;
2546 }
2547 }
2548
2549 /* Set UST session URIs */
2550 if (session->ust_session) {
2551 for (i = 0; i < nb_uri; i++) {
2552 ret = add_uri_to_consumer(
2553 session->ust_session->consumer,
2554 &uris[i], LTTNG_DOMAIN_UST,
2555 session->name);
2556 if (ret != LTTNG_OK) {
2557 goto error;
2558 }
2559 }
2560 }
2561
2562 /* Set kernel session URIs */
2563 if (session->kernel_session) {
2564 for (i = 0; i < nb_uri; i++) {
2565 ret = add_uri_to_consumer(
2566 session->kernel_session->consumer,
2567 &uris[i], LTTNG_DOMAIN_KERNEL,
2568 session->name);
2569 if (ret != LTTNG_OK) {
2570 goto error;
2571 }
2572 }
2573 }
2574
2575 /*
2576 * Make sure to set the session in output mode after we set URI since a
2577 * session can be created without URL (thus flagged in no output mode).
2578 */
2579 session->output_traces = 1;
2580 if (ksess) {
2581 ksess->output_traces = 1;
2582 }
2583
2584 if (usess) {
2585 usess->output_traces = 1;
2586 }
2587
2588 /* All good! */
2589 ret = LTTNG_OK;
2590
2591 error:
2592 return ret;
2593 }
2594
2595 /*
2596 * Command LTTNG_CREATE_SESSION processed by the client thread.
2597 */
2598 int cmd_create_session_uri(char *name, struct lttng_uri *uris,
2599 size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer)
2600 {
2601 int ret;
2602 struct ltt_session *session;
2603
2604 assert(name);
2605 assert(creds);
2606
2607 /*
2608 * Verify if the session already exist
2609 *
2610 * XXX: There is no need for the session lock list here since the caller
2611 * (process_client_msg) is holding it. We might want to change that so a
2612 * single command does not lock the entire session list.
2613 */
2614 session = session_find_by_name(name);
2615 if (session != NULL) {
2616 ret = LTTNG_ERR_EXIST_SESS;
2617 goto find_error;
2618 }
2619
2620 /* Create tracing session in the registry */
2621 ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds),
2622 LTTNG_SOCK_GET_GID_CRED(creds));
2623 if (ret != LTTNG_OK) {
2624 goto session_error;
2625 }
2626
2627 /*
2628 * Get the newly created session pointer back
2629 *
2630 * XXX: There is no need for the session lock list here since the caller
2631 * (process_client_msg) is holding it. We might want to change that so a
2632 * single command does not lock the entire session list.
2633 */
2634 session = session_find_by_name(name);
2635 assert(session);
2636
2637 session->live_timer = live_timer;
2638 /* Create default consumer output for the session not yet created. */
2639 session->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
2640 if (session->consumer == NULL) {
2641 ret = LTTNG_ERR_FATAL;
2642 goto consumer_error;
2643 }
2644
2645 if (uris) {
2646 ret = cmd_set_consumer_uri(session, nb_uri, uris);
2647 if (ret != LTTNG_OK) {
2648 goto consumer_error;
2649 }
2650 session->output_traces = 1;
2651 } else {
2652 session->output_traces = 0;
2653 DBG2("Session %s created with no output", session->name);
2654 }
2655
2656 session->consumer->enabled = 1;
2657
2658 return LTTNG_OK;
2659
2660 consumer_error:
2661 session_destroy(session);
2662 session_error:
2663 find_error:
2664 return ret;
2665 }
2666
2667 /*
2668 * Command LTTNG_CREATE_SESSION_SNAPSHOT processed by the client thread.
2669 */
2670 int cmd_create_session_snapshot(char *name, struct lttng_uri *uris,
2671 size_t nb_uri, lttng_sock_cred *creds)
2672 {
2673 int ret;
2674 struct ltt_session *session;
2675 struct snapshot_output *new_output = NULL;
2676
2677 assert(name);
2678 assert(creds);
2679
2680 /*
2681 * Create session in no output mode with URIs set to NULL. The uris we've
2682 * received are for a default snapshot output if one.
2683 */
2684 ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
2685 if (ret != LTTNG_OK) {
2686 goto error;
2687 }
2688
2689 /* Get the newly created session pointer back. This should NEVER fail. */
2690 session = session_find_by_name(name);
2691 assert(session);
2692
2693 /* Flag session for snapshot mode. */
2694 session->snapshot_mode = 1;
2695
2696 /* Skip snapshot output creation if no URI is given. */
2697 if (nb_uri == 0) {
2698 goto end;
2699 }
2700
2701 new_output = snapshot_output_alloc();
2702 if (!new_output) {
2703 ret = LTTNG_ERR_NOMEM;
2704 goto error_snapshot_alloc;
2705 }
2706
2707 ret = snapshot_output_init_with_uri(DEFAULT_SNAPSHOT_MAX_SIZE, NULL,
2708 uris, nb_uri, session->consumer, new_output, &session->snapshot);
2709 if (ret < 0) {
2710 if (ret == -ENOMEM) {
2711 ret = LTTNG_ERR_NOMEM;
2712 } else {
2713 ret = LTTNG_ERR_INVALID;
2714 }
2715 goto error_snapshot;
2716 }
2717
2718 rcu_read_lock();
2719 snapshot_add_output(&session->snapshot, new_output);
2720 rcu_read_unlock();
2721
2722 end:
2723 return LTTNG_OK;
2724
2725 error_snapshot:
2726 snapshot_output_destroy(new_output);
2727 error_snapshot_alloc:
2728 session_destroy(session);
2729 error:
2730 return ret;
2731 }
2732
2733 /*
2734 * Command LTTNG_DESTROY_SESSION processed by the client thread.
2735 *
2736 * Called with session lock held.
2737 */
2738 int cmd_destroy_session(struct ltt_session *session, int wpipe)
2739 {
2740 int ret;
2741 struct ltt_ust_session *usess;
2742 struct ltt_kernel_session *ksess;
2743
2744 /* Safety net */
2745 assert(session);
2746
2747 usess = session->ust_session;
2748 ksess = session->kernel_session;
2749
2750 /* Clean kernel session teardown */
2751 kernel_destroy_session(ksess);
2752
2753 /* UST session teardown */
2754 if (usess) {
2755 /* Close any relayd session */
2756 consumer_output_send_destroy_relayd(usess->consumer);
2757
2758 /* Destroy every UST application related to this session. */
2759 ret = ust_app_destroy_trace_all(usess);
2760 if (ret) {
2761 ERR("Error in ust_app_destroy_trace_all");
2762 }
2763
2764 /* Clean up the rest. */
2765 trace_ust_destroy_session(usess);
2766 }
2767
2768 /*
2769 * Must notify the kernel thread here to update it's poll set in order to
2770 * remove the channel(s)' fd just destroyed.
2771 */
2772 ret = notify_thread_pipe(wpipe);
2773 if (ret < 0) {
2774 PERROR("write kernel poll pipe");
2775 }
2776
2777 ret = session_destroy(session);
2778
2779 return ret;
2780 }
2781
2782 /*
2783 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
2784 */
2785 int cmd_register_consumer(struct ltt_session *session,
2786 enum lttng_domain_type domain, const char *sock_path,
2787 struct consumer_data *cdata)
2788 {
2789 int ret, sock;
2790 struct consumer_socket *socket = NULL;
2791
2792 assert(session);
2793 assert(cdata);
2794 assert(sock_path);
2795
2796 switch (domain) {
2797 case LTTNG_DOMAIN_KERNEL:
2798 {
2799 struct ltt_kernel_session *ksess = session->kernel_session;
2800
2801 assert(ksess);
2802
2803 /* Can't register a consumer if there is already one */
2804 if (ksess->consumer_fds_sent != 0) {
2805 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2806 goto error;
2807 }
2808
2809 sock = lttcomm_connect_unix_sock(sock_path);
2810 if (sock < 0) {
2811 ret = LTTNG_ERR_CONNECT_FAIL;
2812 goto error;
2813 }
2814 cdata->cmd_sock = sock;
2815
2816 socket = consumer_allocate_socket(&cdata->cmd_sock);
2817 if (socket == NULL) {
2818 ret = close(sock);
2819 if (ret < 0) {
2820 PERROR("close register consumer");
2821 }
2822 cdata->cmd_sock = -1;
2823 ret = LTTNG_ERR_FATAL;
2824 goto error;
2825 }
2826
2827 socket->lock = zmalloc(sizeof(pthread_mutex_t));
2828 if (socket->lock == NULL) {
2829 PERROR("zmalloc pthread mutex");
2830 ret = LTTNG_ERR_FATAL;
2831 goto error;
2832 }
2833 pthread_mutex_init(socket->lock, NULL);
2834 socket->registered = 1;
2835
2836 rcu_read_lock();
2837 consumer_add_socket(socket, ksess->consumer);
2838 rcu_read_unlock();
2839
2840 pthread_mutex_lock(&cdata->pid_mutex);
2841 cdata->pid = -1;
2842 pthread_mutex_unlock(&cdata->pid_mutex);
2843
2844 break;
2845 }
2846 default:
2847 /* TODO: Userspace tracing */
2848 ret = LTTNG_ERR_UND;
2849 goto error;
2850 }
2851
2852 return LTTNG_OK;
2853
2854 error:
2855 if (socket) {
2856 consumer_destroy_socket(socket);
2857 }
2858 return ret;
2859 }
2860
2861 /*
2862 * Command LTTNG_LIST_DOMAINS processed by the client thread.
2863 */
2864 ssize_t cmd_list_domains(struct ltt_session *session,
2865 struct lttng_domain **domains)
2866 {
2867 int ret, index = 0;
2868 ssize_t nb_dom = 0;
2869 struct agent *agt;
2870 struct lttng_ht_iter iter;
2871
2872 if (session->kernel_session != NULL) {
2873 DBG3("Listing domains found kernel domain");
2874 nb_dom++;
2875 }
2876
2877 if (session->ust_session != NULL) {
2878 DBG3("Listing domains found UST global domain");
2879 nb_dom++;
2880
2881 rcu_read_lock();
2882 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
2883 agt, node.node) {
2884 if (agt->being_used) {
2885 nb_dom++;
2886 }
2887 }
2888 rcu_read_unlock();
2889 }
2890
2891 if (!nb_dom) {
2892 goto end;
2893 }
2894
2895 *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
2896 if (*domains == NULL) {
2897 ret = LTTNG_ERR_FATAL;
2898 goto error;
2899 }
2900
2901 if (session->kernel_session != NULL) {
2902 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
2903
2904 /* Kernel session buffer type is always GLOBAL */
2905 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
2906
2907 index++;
2908 }
2909
2910 if (session->ust_session != NULL) {
2911 (*domains)[index].type = LTTNG_DOMAIN_UST;
2912 (*domains)[index].buf_type = session->ust_session->buffer_type;
2913 index++;
2914
2915 rcu_read_lock();
2916 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
2917 agt, node.node) {
2918 if (agt->being_used) {
2919 (*domains)[index].type = agt->domain;
2920 (*domains)[index].buf_type = session->ust_session->buffer_type;
2921 index++;
2922 }
2923 }
2924 rcu_read_unlock();
2925 }
2926 end:
2927 return nb_dom;
2928
2929 error:
2930 /* Return negative value to differentiate return code */
2931 return -ret;
2932 }
2933
2934
2935 /*
2936 * Command LTTNG_LIST_CHANNELS processed by the client thread.
2937 */
2938 ssize_t cmd_list_channels(enum lttng_domain_type domain,
2939 struct ltt_session *session, struct lttng_channel **channels)
2940 {
2941 ssize_t nb_chan = 0, payload_size = 0, ret;
2942
2943 switch (domain) {
2944 case LTTNG_DOMAIN_KERNEL:
2945 if (session->kernel_session != NULL) {
2946 nb_chan = session->kernel_session->channel_count;
2947 }
2948 DBG3("Number of kernel channels %zd", nb_chan);
2949 if (nb_chan <= 0) {
2950 ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
2951 goto end;
2952 }
2953 break;
2954 case LTTNG_DOMAIN_UST:
2955 if (session->ust_session != NULL) {
2956 rcu_read_lock();
2957 nb_chan = lttng_ht_get_count(
2958 session->ust_session->domain_global.channels);
2959 rcu_read_unlock();
2960 }
2961 DBG3("Number of UST global channels %zd", nb_chan);
2962 if (nb_chan < 0) {
2963 ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
2964 goto end;
2965 }
2966 break;
2967 default:
2968 ret = -LTTNG_ERR_UND;
2969 goto end;
2970 }
2971
2972 if (nb_chan > 0) {
2973 const size_t channel_size = sizeof(struct lttng_channel) +
2974 sizeof(struct lttng_channel_extended);
2975 struct lttng_channel_extended *channel_exts;
2976
2977 payload_size = nb_chan * channel_size;
2978 *channels = zmalloc(payload_size);
2979 if (*channels == NULL) {
2980 ret = -LTTNG_ERR_FATAL;
2981 goto end;
2982 }
2983
2984 channel_exts = ((void *) *channels) +
2985 (nb_chan * sizeof(struct lttng_channel));
2986 ret = list_lttng_channels(domain, session, *channels, channel_exts);
2987 if (ret != LTTNG_OK) {
2988 free(*channels);
2989 *channels = NULL;
2990 goto end;
2991 }
2992 } else {
2993 *channels = NULL;
2994 }
2995
2996 ret = payload_size;
2997 end:
2998 return ret;
2999 }
3000
3001 /*
3002 * Command LTTNG_LIST_EVENTS processed by the client thread.
3003 */
3004 ssize_t cmd_list_events(enum lttng_domain_type domain,
3005 struct ltt_session *session, char *channel_name,
3006 struct lttng_event **events, size_t *total_size)
3007 {
3008 int ret = 0;
3009 ssize_t nb_event = 0;
3010
3011 switch (domain) {
3012 case LTTNG_DOMAIN_KERNEL:
3013 if (session->kernel_session != NULL) {
3014 nb_event = list_lttng_kernel_events(channel_name,
3015 session->kernel_session, events,
3016 total_size);
3017 }
3018 break;
3019 case LTTNG_DOMAIN_UST:
3020 {
3021 if (session->ust_session != NULL) {
3022 nb_event = list_lttng_ust_global_events(channel_name,
3023 &session->ust_session->domain_global, events,
3024 total_size);
3025 }
3026 break;
3027 }
3028 case LTTNG_DOMAIN_LOG4J:
3029 case LTTNG_DOMAIN_JUL:
3030 case LTTNG_DOMAIN_PYTHON:
3031 if (session->ust_session) {
3032 struct lttng_ht_iter iter;
3033 struct agent *agt;
3034
3035 rcu_read_lock();
3036 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3037 &iter.iter, agt, node.node) {
3038 if (agt->domain == domain) {
3039 nb_event = list_lttng_agent_events(
3040 agt, events,
3041 total_size);
3042 break;
3043 }
3044 }
3045 rcu_read_unlock();
3046 }
3047 break;
3048 default:
3049 ret = LTTNG_ERR_UND;
3050 goto error;
3051 }
3052
3053 return nb_event;
3054
3055 error:
3056 /* Return negative value to differentiate return code */
3057 return -ret;
3058 }
3059
3060 /*
3061 * Using the session list, filled a lttng_session array to send back to the
3062 * client for session listing.
3063 *
3064 * The session list lock MUST be acquired before calling this function. Use
3065 * session_lock_list() and session_unlock_list().
3066 */
3067 void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid,
3068 gid_t gid)
3069 {
3070 int ret;
3071 unsigned int i = 0;
3072 struct ltt_session *session;
3073 struct ltt_session_list *list = session_get_list();
3074
3075 DBG("Getting all available session for UID %d GID %d",
3076 uid, gid);
3077 /*
3078 * Iterate over session list and append data after the control struct in
3079 * the buffer.
3080 */
3081 cds_list_for_each_entry(session, &list->head, list) {
3082 /*
3083 * Only list the sessions the user can control.
3084 */
3085 if (!session_access_ok(session, uid, gid)) {
3086 continue;
3087 }
3088
3089 struct ltt_kernel_session *ksess = session->kernel_session;
3090 struct ltt_ust_session *usess = session->ust_session;
3091
3092 if (session->consumer->type == CONSUMER_DST_NET ||
3093 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3094 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3095 ret = build_network_session_path(sessions[i].path,
3096 sizeof(sessions[i].path), session);
3097 } else {
3098 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
3099 session->consumer->dst.trace_path);
3100 }
3101 if (ret < 0) {
3102 PERROR("snprintf session path");
3103 continue;
3104 }
3105
3106 strncpy(sessions[i].name, session->name, NAME_MAX);
3107 sessions[i].name[NAME_MAX - 1] = '\0';
3108 sessions[i].enabled = session->active;
3109 sessions[i].snapshot_mode = session->snapshot_mode;
3110 sessions[i].live_timer_interval = session->live_timer;
3111 i++;
3112 }
3113 }
3114
3115 /*
3116 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
3117 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
3118 */
3119 int cmd_data_pending(struct ltt_session *session)
3120 {
3121 int ret;
3122 struct ltt_kernel_session *ksess = session->kernel_session;
3123 struct ltt_ust_session *usess = session->ust_session;
3124
3125 assert(session);
3126
3127 /* Session MUST be stopped to ask for data availability. */
3128 if (session->active) {
3129 ret = LTTNG_ERR_SESSION_STARTED;
3130 goto error;
3131 } else {
3132 /*
3133 * If stopped, just make sure we've started before else the above call
3134 * will always send that there is data pending.
3135 *
3136 * The consumer assumes that when the data pending command is received,
3137 * the trace has been started before or else no output data is written
3138 * by the streams which is a condition for data pending. So, this is
3139 * *VERY* important that we don't ask the consumer before a start
3140 * trace.
3141 */
3142 if (!session->has_been_started) {
3143 ret = 0;
3144 goto error;
3145 }
3146 }
3147
3148 if (ksess && ksess->consumer) {
3149 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
3150 if (ret == 1) {
3151 /* Data is still being extracted for the kernel. */
3152 goto error;
3153 }
3154 }
3155
3156 if (usess && usess->consumer) {
3157 ret = consumer_is_data_pending(usess->id, usess->consumer);
3158 if (ret == 1) {
3159 /* Data is still being extracted for the kernel. */
3160 goto error;
3161 }
3162 }
3163
3164 /* Data is ready to be read by a viewer */
3165 ret = 0;
3166
3167 error:
3168 return ret;
3169 }
3170
3171 /*
3172 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
3173 *
3174 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3175 */
3176 int cmd_snapshot_add_output(struct ltt_session *session,
3177 struct lttng_snapshot_output *output, uint32_t *id)
3178 {
3179 int ret;
3180 struct snapshot_output *new_output;
3181
3182 assert(session);
3183 assert(output);
3184
3185 DBG("Cmd snapshot add output for session %s", session->name);
3186
3187 /*
3188 * Can't create an output if the session is not set in no-output mode.
3189 */
3190 if (session->output_traces) {
3191 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3192 goto error;
3193 }
3194
3195 /* Only one output is allowed until we have the "tee" feature. */
3196 if (session->snapshot.nb_output == 1) {
3197 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
3198 goto error;
3199 }
3200
3201 new_output = snapshot_output_alloc();
3202 if (!new_output) {
3203 ret = LTTNG_ERR_NOMEM;
3204 goto error;
3205 }
3206
3207 ret = snapshot_output_init(output->max_size, output->name,
3208 output->ctrl_url, output->data_url, session->consumer, new_output,
3209 &session->snapshot);
3210 if (ret < 0) {
3211 if (ret == -ENOMEM) {
3212 ret = LTTNG_ERR_NOMEM;
3213 } else {
3214 ret = LTTNG_ERR_INVALID;
3215 }
3216 goto free_error;
3217 }
3218
3219 rcu_read_lock();
3220 snapshot_add_output(&session->snapshot, new_output);
3221 if (id) {
3222 *id = new_output->id;
3223 }
3224 rcu_read_unlock();
3225
3226 return LTTNG_OK;
3227
3228 free_error:
3229 snapshot_output_destroy(new_output);
3230 error:
3231 return ret;
3232 }
3233
3234 /*
3235 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
3236 *
3237 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3238 */
3239 int cmd_snapshot_del_output(struct ltt_session *session,
3240 struct lttng_snapshot_output *output)
3241 {
3242 int ret;
3243 struct snapshot_output *sout = NULL;
3244
3245 assert(session);
3246 assert(output);
3247
3248 rcu_read_lock();
3249
3250 /*
3251 * Permission denied to create an output if the session is not
3252 * set in no output mode.
3253 */
3254 if (session->output_traces) {
3255 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3256 goto error;
3257 }
3258
3259 if (output->id) {
3260 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
3261 session->name);
3262 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
3263 } else if (*output->name != '\0') {
3264 DBG("Cmd snapshot del output name %s for session %s", output->name,
3265 session->name);
3266 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
3267 }
3268 if (!sout) {
3269 ret = LTTNG_ERR_INVALID;
3270 goto error;
3271 }
3272
3273 snapshot_delete_output(&session->snapshot, sout);
3274 snapshot_output_destroy(sout);
3275 ret = LTTNG_OK;
3276
3277 error:
3278 rcu_read_unlock();
3279 return ret;
3280 }
3281
3282 /*
3283 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
3284 *
3285 * If no output is available, outputs is untouched and 0 is returned.
3286 *
3287 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
3288 */
3289 ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
3290 struct lttng_snapshot_output **outputs)
3291 {
3292 int ret, idx = 0;
3293 struct lttng_snapshot_output *list = NULL;
3294 struct lttng_ht_iter iter;
3295 struct snapshot_output *output;
3296
3297 assert(session);
3298 assert(outputs);
3299
3300 DBG("Cmd snapshot list outputs for session %s", session->name);
3301
3302 /*
3303 * Permission denied to create an output if the session is not
3304 * set in no output mode.
3305 */
3306 if (session->output_traces) {
3307 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3308 goto end;
3309 }
3310
3311 if (session->snapshot.nb_output == 0) {
3312 ret = 0;
3313 goto end;
3314 }
3315
3316 list = zmalloc(session->snapshot.nb_output * sizeof(*list));
3317 if (!list) {
3318 ret = -LTTNG_ERR_NOMEM;
3319 goto end;
3320 }
3321
3322 /* Copy list from session to the new list object. */
3323 rcu_read_lock();
3324 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
3325 output, node.node) {
3326 assert(output->consumer);
3327 list[idx].id = output->id;
3328 list[idx].max_size = output->max_size;
3329 if (lttng_strncpy(list[idx].name, output->name,
3330 sizeof(list[idx].name))) {
3331 ret = -LTTNG_ERR_INVALID;
3332 goto error;
3333 }
3334 if (output->consumer->type == CONSUMER_DST_LOCAL) {
3335 if (lttng_strncpy(list[idx].ctrl_url,
3336 output->consumer->dst.trace_path,
3337 sizeof(list[idx].ctrl_url))) {
3338 ret = -LTTNG_ERR_INVALID;
3339 goto error;
3340 }
3341 } else {
3342 /* Control URI. */
3343 ret = uri_to_str_url(&output->consumer->dst.net.control,
3344 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
3345 if (ret < 0) {
3346 ret = -LTTNG_ERR_NOMEM;
3347 goto error;
3348 }
3349
3350 /* Data URI. */
3351 ret = uri_to_str_url(&output->consumer->dst.net.data,
3352 list[idx].data_url, sizeof(list[idx].data_url));
3353 if (ret < 0) {
3354 ret = -LTTNG_ERR_NOMEM;
3355 goto error;
3356 }
3357 }
3358 idx++;
3359 }
3360
3361 *outputs = list;
3362 list = NULL;
3363 ret = session->snapshot.nb_output;
3364 error:
3365 rcu_read_unlock();
3366 free(list);
3367 end:
3368 return ret;
3369 }
3370
3371 /*
3372 * Check if we can regenerate the metadata for this session.
3373 * Only kernel, UST per-uid and non-live sessions are supported.
3374 *
3375 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
3376 */
3377 static
3378 int check_regenerate_metadata_support(struct ltt_session *session)
3379 {
3380 int ret;
3381
3382 assert(session);
3383
3384 if (session->live_timer != 0) {
3385 ret = LTTNG_ERR_LIVE_SESSION;
3386 goto end;
3387 }
3388 if (!session->active) {
3389 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3390 goto end;
3391 }
3392 if (session->ust_session) {
3393 switch (session->ust_session->buffer_type) {
3394 case LTTNG_BUFFER_PER_UID:
3395 break;
3396 case LTTNG_BUFFER_PER_PID:
3397 ret = LTTNG_ERR_PER_PID_SESSION;
3398 goto end;
3399 default:
3400 assert(0);
3401 ret = LTTNG_ERR_UNK;
3402 goto end;
3403 }
3404 }
3405 if (session->consumer->type == CONSUMER_DST_NET &&
3406 session->consumer->relay_minor_version < 8) {
3407 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
3408 goto end;
3409 }
3410 ret = 0;
3411
3412 end:
3413 return ret;
3414 }
3415
3416 static
3417 int clear_metadata_file(int fd)
3418 {
3419 int ret;
3420
3421 ret = lseek(fd, 0, SEEK_SET);
3422 if (ret < 0) {
3423 PERROR("lseek");
3424 goto end;
3425 }
3426
3427 ret = ftruncate(fd, 0);
3428 if (ret < 0) {
3429 PERROR("ftruncate");
3430 goto end;
3431 }
3432
3433 end:
3434 return ret;
3435 }
3436
3437 static
3438 int ust_regenerate_metadata(struct ltt_ust_session *usess)
3439 {
3440 int ret = 0;
3441 struct buffer_reg_uid *uid_reg = NULL;
3442 struct buffer_reg_session *session_reg = NULL;
3443
3444 rcu_read_lock();
3445 cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
3446 struct ust_registry_session *registry;
3447 struct ust_registry_channel *chan;
3448 struct lttng_ht_iter iter_chan;
3449
3450 session_reg = uid_reg->registry;
3451 registry = session_reg->reg.ust;
3452
3453 pthread_mutex_lock(&registry->lock);
3454 registry->metadata_len_sent = 0;
3455 memset(registry->metadata, 0, registry->metadata_alloc_len);
3456 registry->metadata_len = 0;
3457 registry->metadata_version++;
3458 if (registry->metadata_fd > 0) {
3459 /* Clear the metadata file's content. */
3460 ret = clear_metadata_file(registry->metadata_fd);
3461 if (ret) {
3462 pthread_mutex_unlock(&registry->lock);
3463 goto end;
3464 }
3465 }
3466
3467 ret = ust_metadata_session_statedump(registry, NULL,
3468 registry->major, registry->minor);
3469 if (ret) {
3470 pthread_mutex_unlock(&registry->lock);
3471 ERR("Failed to generate session metadata (err = %d)",
3472 ret);
3473 goto end;
3474 }
3475 cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
3476 chan, node.node) {
3477 struct ust_registry_event *event;
3478 struct lttng_ht_iter iter_event;
3479
3480 ret = ust_metadata_channel_statedump(registry, chan);
3481 if (ret) {
3482 pthread_mutex_unlock(&registry->lock);
3483 ERR("Failed to generate channel metadata "
3484 "(err = %d)", ret);
3485 goto end;
3486 }
3487 cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter,
3488 event, node.node) {
3489 ret = ust_metadata_event_statedump(registry,
3490 chan, event);
3491 if (ret) {
3492 pthread_mutex_unlock(&registry->lock);
3493 ERR("Failed to generate event metadata "
3494 "(err = %d)", ret);
3495 goto end;
3496 }
3497 }
3498 }
3499 pthread_mutex_unlock(&registry->lock);
3500 }
3501
3502 end:
3503 rcu_read_unlock();
3504 return ret;
3505 }
3506
3507 /*
3508 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
3509 *
3510 * Ask the consumer to truncate the existing metadata file(s) and
3511 * then regenerate the metadata. Live and per-pid sessions are not
3512 * supported and return an error.
3513 *
3514 * Return 0 on success or else a LTTNG_ERR code.
3515 */
3516 int cmd_regenerate_metadata(struct ltt_session *session)
3517 {
3518 int ret;
3519
3520 assert(session);
3521
3522 ret = check_regenerate_metadata_support(session);
3523 if (ret) {
3524 goto end;
3525 }
3526
3527 if (session->kernel_session) {
3528 ret = kernctl_session_regenerate_metadata(
3529 session->kernel_session->fd);
3530 if (ret < 0) {
3531 ERR("Failed to regenerate the kernel metadata");
3532 goto end;
3533 }
3534 }
3535
3536 if (session->ust_session) {
3537 ret = ust_regenerate_metadata(session->ust_session);
3538 if (ret < 0) {
3539 ERR("Failed to regenerate the UST metadata");
3540 goto end;
3541 }
3542 }
3543 DBG("Cmd metadata regenerate for session %s", session->name);
3544 ret = LTTNG_OK;
3545
3546 end:
3547 return ret;
3548 }
3549
3550 /*
3551 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
3552 *
3553 * Ask the tracer to regenerate a new statedump.
3554 *
3555 * Return 0 on success or else a LTTNG_ERR code.
3556 */
3557 int cmd_regenerate_statedump(struct ltt_session *session)
3558 {
3559 int ret;
3560
3561 assert(session);
3562
3563 if (!session->active) {
3564 ret = LTTNG_ERR_SESSION_NOT_STARTED;
3565 goto end;
3566 }
3567
3568 if (session->kernel_session) {
3569 ret = kernctl_session_regenerate_statedump(
3570 session->kernel_session->fd);
3571 /*
3572 * Currently, the statedump in kernel can only fail if out
3573 * of memory.
3574 */
3575 if (ret < 0) {
3576 if (ret == -ENOMEM) {
3577 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
3578 } else {
3579 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3580 }
3581 ERR("Failed to regenerate the kernel statedump");
3582 goto end;
3583 }
3584 }
3585
3586 if (session->ust_session) {
3587 ret = ust_app_regenerate_statedump_all(session->ust_session);
3588 /*
3589 * Currently, the statedump in UST always returns 0.
3590 */
3591 if (ret < 0) {
3592 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
3593 ERR("Failed to regenerate the UST statedump");
3594 goto end;
3595 }
3596 }
3597 DBG("Cmd regenerate statedump for session %s", session->name);
3598 ret = LTTNG_OK;
3599
3600 end:
3601 return ret;
3602 }
3603
3604 int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock,
3605 struct notification_thread_handle *notification_thread)
3606 {
3607 int ret;
3608 size_t trigger_len;
3609 ssize_t sock_recv_len;
3610 struct lttng_trigger *trigger = NULL;
3611 struct lttng_buffer_view view;
3612 struct lttng_dynamic_buffer trigger_buffer;
3613
3614 lttng_dynamic_buffer_init(&trigger_buffer);
3615 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3616 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3617 if (ret) {
3618 ret = LTTNG_ERR_NOMEM;
3619 goto end;
3620 }
3621
3622 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3623 trigger_len);
3624 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3625 ERR("Failed to receive \"register trigger\" command payload");
3626 /* TODO: should this be a new error enum ? */
3627 ret = LTTNG_ERR_INVALID_TRIGGER;
3628 goto end;
3629 }
3630
3631 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3632 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3633 trigger_len) {
3634 ERR("Invalid trigger payload received in \"register trigger\" command");
3635 ret = LTTNG_ERR_INVALID_TRIGGER;
3636 goto end;
3637 }
3638
3639 ret = notification_thread_command_register_trigger(notification_thread,
3640 trigger);
3641 /* Ownership of trigger was transferred. */
3642 trigger = NULL;
3643 end:
3644 lttng_trigger_destroy(trigger);
3645 lttng_dynamic_buffer_reset(&trigger_buffer);
3646 return ret;
3647 }
3648
3649 int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock,
3650 struct notification_thread_handle *notification_thread)
3651 {
3652 int ret;
3653 size_t trigger_len;
3654 ssize_t sock_recv_len;
3655 struct lttng_trigger *trigger = NULL;
3656 struct lttng_buffer_view view;
3657 struct lttng_dynamic_buffer trigger_buffer;
3658
3659 lttng_dynamic_buffer_init(&trigger_buffer);
3660 trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length;
3661 ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len);
3662 if (ret) {
3663 ret = LTTNG_ERR_NOMEM;
3664 goto end;
3665 }
3666
3667 sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data,
3668 trigger_len);
3669 if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
3670 ERR("Failed to receive \"unregister trigger\" command payload");
3671 /* TODO: should this be a new error enum ? */
3672 ret = LTTNG_ERR_INVALID_TRIGGER;
3673 goto end;
3674 }
3675
3676 view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1);
3677 if (lttng_trigger_create_from_buffer(&view, &trigger) !=
3678 trigger_len) {
3679 ERR("Invalid trigger payload received in \"unregister trigger\" command");
3680 ret = LTTNG_ERR_INVALID_TRIGGER;
3681 goto end;
3682 }
3683
3684 ret = notification_thread_command_unregister_trigger(notification_thread,
3685 trigger);
3686 end:
3687 lttng_trigger_destroy(trigger);
3688 lttng_dynamic_buffer_reset(&trigger_buffer);
3689 return ret;
3690 }
3691
3692 /*
3693 * Send relayd sockets from snapshot output to consumer. Ignore request if the
3694 * snapshot output is *not* set with a remote destination.
3695 *
3696 * Return 0 on success or a LTTNG_ERR code.
3697 */
3698 static int set_relayd_for_snapshot(struct consumer_output *consumer,
3699 struct snapshot_output *snap_output, struct ltt_session *session)
3700 {
3701 int ret = LTTNG_OK;
3702 struct lttng_ht_iter iter;
3703 struct consumer_socket *socket;
3704
3705 assert(consumer);
3706 assert(snap_output);
3707 assert(session);
3708
3709 DBG2("Set relayd object from snapshot output");
3710
3711 /* Ignore if snapshot consumer output is not network. */
3712 if (snap_output->consumer->type != CONSUMER_DST_NET) {
3713 goto error;
3714 }
3715
3716 /*
3717 * For each consumer socket, create and send the relayd object of the
3718 * snapshot output.
3719 */
3720 rcu_read_lock();
3721 cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter,
3722 socket, node.node) {
3723 pthread_mutex_lock(socket->lock);
3724 ret = send_consumer_relayd_sockets(0, session->id,
3725 snap_output->consumer, socket,
3726 session->name, session->hostname,
3727 session->live_timer);
3728 pthread_mutex_unlock(socket->lock);
3729 if (ret != LTTNG_OK) {
3730 rcu_read_unlock();
3731 goto error;
3732 }
3733 }
3734 rcu_read_unlock();
3735
3736 error:
3737 return ret;
3738 }
3739
3740 /*
3741 * Record a kernel snapshot.
3742 *
3743 * Return LTTNG_OK on success or a LTTNG_ERR code.
3744 */
3745 static int record_kernel_snapshot(struct ltt_kernel_session *ksess,
3746 struct snapshot_output *output, struct ltt_session *session,
3747 int wait, uint64_t nb_packets_per_stream)
3748 {
3749 int ret;
3750
3751 assert(ksess);
3752 assert(output);
3753 assert(session);
3754
3755
3756 /*
3757 * Copy kernel session sockets so we can communicate with the right
3758 * consumer for the snapshot record command.
3759 */
3760 ret = consumer_copy_sockets(output->consumer, ksess->consumer);
3761 if (ret < 0) {
3762 ret = LTTNG_ERR_NOMEM;
3763 goto error;
3764 }
3765
3766 ret = set_relayd_for_snapshot(ksess->consumer, output, session);
3767 if (ret != LTTNG_OK) {
3768 goto error_snapshot;
3769 }
3770
3771 ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream);
3772 if (ret != LTTNG_OK) {
3773 goto error_snapshot;
3774 }
3775
3776 ret = LTTNG_OK;
3777 goto end;
3778
3779 error_snapshot:
3780 /* Clean up copied sockets so this output can use some other later on. */
3781 consumer_destroy_output_sockets(output->consumer);
3782 error:
3783 end:
3784 return ret;
3785 }
3786
3787 /*
3788 * Record a UST snapshot.
3789 *
3790 * Return 0 on success or a LTTNG_ERR error code.
3791 */
3792 static int record_ust_snapshot(struct ltt_ust_session *usess,
3793 struct snapshot_output *output, struct ltt_session *session,
3794 int wait, uint64_t nb_packets_per_stream)
3795 {
3796 int ret;
3797
3798 assert(usess);
3799 assert(output);
3800 assert(session);
3801
3802 /*
3803 * Copy UST session sockets so we can communicate with the right
3804 * consumer for the snapshot record command.
3805 */
3806 ret = consumer_copy_sockets(output->consumer, usess->consumer);
3807 if (ret < 0) {
3808 ret = LTTNG_ERR_NOMEM;
3809 goto error;
3810 }
3811
3812 ret = set_relayd_for_snapshot(usess->consumer, output, session);
3813 if (ret != LTTNG_OK) {
3814 goto error_snapshot;
3815 }
3816
3817 ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream);
3818 if (ret < 0) {
3819 switch (-ret) {
3820 case EINVAL:
3821 ret = LTTNG_ERR_INVALID;
3822 break;
3823 default:
3824 ret = LTTNG_ERR_SNAPSHOT_FAIL;
3825 break;
3826 }
3827 goto error_snapshot;
3828 }
3829
3830 ret = LTTNG_OK;
3831
3832 error_snapshot:
3833 /* Clean up copied sockets so this output can use some other later on. */
3834 consumer_destroy_output_sockets(output->consumer);
3835 error:
3836 return ret;
3837 }
3838
3839 static
3840 uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session,
3841 uint64_t cur_nr_packets)
3842 {
3843 uint64_t tot_size = 0;
3844
3845 if (session->kernel_session) {
3846 struct ltt_kernel_channel *chan;
3847 struct ltt_kernel_session *ksess = session->kernel_session;
3848
3849 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
3850 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
3851 /*
3852 * Don't take channel into account if we
3853 * already grab all its packets.
3854 */
3855 continue;
3856 }
3857 tot_size += chan->channel->attr.subbuf_size
3858 * chan->stream_count;
3859 }
3860 }
3861
3862 if (session->ust_session) {
3863 struct ltt_ust_session *usess = session->ust_session;
3864
3865 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
3866 cur_nr_packets);
3867 }
3868
3869 return tot_size;
3870 }
3871
3872 /*
3873 * Calculate the number of packets we can grab from each stream that
3874 * fits within the overall snapshot max size.
3875 *
3876 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
3877 * the number of packets per stream.
3878 *
3879 * TODO: this approach is not perfect: we consider the worse case
3880 * (packet filling the sub-buffers) as an upper bound, but we could do
3881 * better if we do this calculation while we actually grab the packet
3882 * content: we would know how much padding we don't actually store into
3883 * the file.
3884 *
3885 * This algorithm is currently bounded by the number of packets per
3886 * stream.
3887 *
3888 * Since we call this algorithm before actually grabbing the data, it's
3889 * an approximation: for instance, applications could appear/disappear
3890 * in between this call and actually grabbing data.
3891 */
3892 static
3893 int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t max_size)
3894 {
3895 int64_t size_left;
3896 uint64_t cur_nb_packets = 0;
3897
3898 if (!max_size) {
3899 return 0; /* Infinite */
3900 }
3901
3902 size_left = max_size;
3903 for (;;) {
3904 uint64_t one_more_packet_tot_size;
3905
3906 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(session,
3907 cur_nb_packets);
3908 if (!one_more_packet_tot_size) {
3909 /* We are already grabbing all packets. */
3910 break;
3911 }
3912 size_left -= one_more_packet_tot_size;
3913 if (size_left < 0) {
3914 break;
3915 }
3916 cur_nb_packets++;
3917 }
3918 if (!cur_nb_packets) {
3919 /* Not enough room to grab one packet of each stream, error. */
3920 return -1;
3921 }
3922 return cur_nb_packets;
3923 }
3924
3925 /*
3926 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
3927 *
3928 * The wait parameter is ignored so this call always wait for the snapshot to
3929 * complete before returning.
3930 *
3931 * Return LTTNG_OK on success or else a LTTNG_ERR code.
3932 */
3933 int cmd_snapshot_record(struct ltt_session *session,
3934 struct lttng_snapshot_output *output, int wait)
3935 {
3936 int ret = LTTNG_OK;
3937 unsigned int use_tmp_output = 0;
3938 struct snapshot_output tmp_output;
3939 unsigned int snapshot_success = 0;
3940 char datetime[16];
3941
3942 assert(session);
3943 assert(output);
3944
3945 DBG("Cmd snapshot record for session %s", session->name);
3946
3947 /* Get the datetime for the snapshot output directory. */
3948 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
3949 sizeof(datetime));
3950 if (!ret) {
3951 ret = LTTNG_ERR_INVALID;
3952 goto error;
3953 }
3954
3955 /*
3956 * Permission denied to create an output if the session is not
3957 * set in no output mode.
3958 */
3959 if (session->output_traces) {
3960 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3961 goto error;
3962 }
3963
3964 /* The session needs to be started at least once. */
3965 if (!session->has_been_started) {
3966 ret = LTTNG_ERR_START_SESSION_ONCE;
3967 goto error;
3968 }
3969
3970 /* Use temporary output for the session. */
3971 if (*output->ctrl_url != '\0') {
3972 ret = snapshot_output_init(output->max_size, output->name,
3973 output->ctrl_url, output->data_url, session->consumer,
3974 &tmp_output, NULL);
3975 if (ret < 0) {
3976 if (ret == -ENOMEM) {
3977 ret = LTTNG_ERR_NOMEM;
3978 } else {
3979 ret = LTTNG_ERR_INVALID;
3980 }
3981 goto error;
3982 }
3983 /* Use the global session count for the temporary snapshot. */
3984 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
3985
3986 /* Use the global datetime */
3987 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
3988 use_tmp_output = 1;
3989 }
3990
3991 if (use_tmp_output) {
3992 int64_t nb_packets_per_stream;
3993
3994 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
3995 tmp_output.max_size);
3996 if (nb_packets_per_stream < 0) {
3997 ret = LTTNG_ERR_MAX_SIZE_INVALID;
3998 goto error;
3999 }
4000
4001 if (session->kernel_session) {
4002 ret = record_kernel_snapshot(session->kernel_session,
4003 &tmp_output, session,
4004 wait, nb_packets_per_stream);
4005 if (ret != LTTNG_OK) {
4006 goto error;
4007 }
4008 }
4009
4010 if (session->ust_session) {
4011 ret = record_ust_snapshot(session->ust_session,
4012 &tmp_output, session,
4013 wait, nb_packets_per_stream);
4014 if (ret != LTTNG_OK) {
4015 goto error;
4016 }
4017 }
4018
4019 snapshot_success = 1;
4020 } else {
4021 struct snapshot_output *sout;
4022 struct lttng_ht_iter iter;
4023
4024 rcu_read_lock();
4025 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
4026 &iter.iter, sout, node.node) {
4027 int64_t nb_packets_per_stream;
4028
4029 /*
4030 * Make a local copy of the output and assign the possible
4031 * temporary value given by the caller.
4032 */
4033 memset(&tmp_output, 0, sizeof(tmp_output));
4034 memcpy(&tmp_output, sout, sizeof(tmp_output));
4035
4036 if (output->max_size != (uint64_t) -1ULL) {
4037 tmp_output.max_size = output->max_size;
4038 }
4039
4040 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
4041 tmp_output.max_size);
4042 if (nb_packets_per_stream < 0) {
4043 ret = LTTNG_ERR_MAX_SIZE_INVALID;
4044 rcu_read_unlock();
4045 goto error;
4046 }
4047
4048 /* Use temporary name. */
4049 if (*output->name != '\0') {
4050 if (lttng_strncpy(tmp_output.name, output->name,
4051 sizeof(tmp_output.name))) {
4052 ret = LTTNG_ERR_INVALID;
4053 rcu_read_unlock();
4054 goto error;
4055 }
4056 }
4057
4058 tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
4059 memcpy(tmp_output.datetime, datetime, sizeof(datetime));
4060
4061 if (session->kernel_session) {
4062 ret = record_kernel_snapshot(session->kernel_session,
4063 &tmp_output, session,
4064 wait, nb_packets_per_stream);
4065 if (ret != LTTNG_OK) {
4066 rcu_read_unlock();
4067 goto error;
4068 }
4069 }
4070
4071 if (session->ust_session) {
4072 ret = record_ust_snapshot(session->ust_session,
4073 &tmp_output, session,
4074 wait, nb_packets_per_stream);
4075 if (ret != LTTNG_OK) {
4076 rcu_read_unlock();
4077 goto error;
4078 }
4079 }
4080 snapshot_success = 1;
4081 }
4082 rcu_read_unlock();
4083 }
4084
4085 if (snapshot_success) {
4086 session->snapshot.nb_snapshot++;
4087 } else {
4088 ret = LTTNG_ERR_SNAPSHOT_FAIL;
4089 }
4090
4091 error:
4092 return ret;
4093 }
4094
4095 /*
4096 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
4097 */
4098 int cmd_set_session_shm_path(struct ltt_session *session,
4099 const char *shm_path)
4100 {
4101 /* Safety net */
4102 assert(session);
4103
4104 /*
4105 * Can only set shm path before session is started.
4106 */
4107 if (session->has_been_started) {
4108 return LTTNG_ERR_SESSION_STARTED;
4109 }
4110
4111 strncpy(session->shm_path, shm_path,
4112 sizeof(session->shm_path));
4113 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
4114
4115 return 0;
4116 }
4117
4118 /*
4119 * Init command subsystem.
4120 */
4121 void cmd_init(void)
4122 {
4123 /*
4124 * Set network sequence index to 1 for streams to match a relayd
4125 * socket on the consumer side.
4126 */
4127 pthread_mutex_lock(&relayd_net_seq_idx_lock);
4128 relayd_net_seq_idx = 1;
4129 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
4130
4131 DBG("Command subsystem initialized");
4132 }
LTTng 2.0 tools and control repository
This page took 0.176506 seconds and 4 git commands to generate.