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