Use free running metadata channel key between sessiond and kernel consumer
[lttng-tools.git] / src / bin / lttng-sessiond / cmd.c
CommitLineData
2f77fc4b
DG
1/*
2 * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
bdf64013 3 * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
2f77fc4b
DG
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
6c1c0768 19#define _LGPL_SOURCE
2f77fc4b 20#include <assert.h>
6dc3064a 21#include <inttypes.h>
2f77fc4b
DG
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>
10a50311 29#include <common/utils.h>
f5436bfc 30#include <common/compat/string.h>
93ec662e 31#include <common/kernel-ctl/kernel-ctl.h>
b0880ae5
JG
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>
6e21424e 37#include <lttng/channel.h>
b0880ae5 38#include <lttng/channel-internal.h>
9f449915 39#include <common/string-utils/string-utils.h>
2f77fc4b
DG
40
41#include "channel.h"
42#include "consumer.h"
43#include "event.h"
8782cc74 44#include "health-sessiond.h"
2f77fc4b
DG
45#include "kernel.h"
46#include "kernel-consumer.h"
47#include "lttng-sessiond.h"
48#include "utils.h"
834978fd 49#include "syscall.h"
7c1d2758 50#include "agent.h"
93ec662e 51#include "buffer-registry.h"
b0880ae5
JG
52#include "notification-thread.h"
53#include "notification-thread-commands.h"
2f77fc4b
DG
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
d88aee68
DG
60 * to send to. It must be accessed with the relayd_net_seq_idx_lock
61 * held.
2f77fc4b 62 */
d88aee68
DG
63static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
64static uint64_t relayd_net_seq_idx;
2f77fc4b 65
7076b56e
JG
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
2f77fc4b
DG
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
9aa9f900
DG
131 /*
132 * Do we have a UST url set. If yes, this means we have both kernel and UST
133 * to print.
134 */
9d035200 135 if (*tmp_uurl != '\0') {
2f77fc4b
DG
136 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
137 tmp_urls, kdata_port, tmp_uurl, udata_port);
138 } else {
9aa9f900 139 int dport;
bef08707 140 if (kuri || (!kuri && !uuri)) {
9aa9f900
DG
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);
2f77fc4b
DG
147 }
148
149error:
150 return ret;
151}
152
fb83fe64
JD
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
e1f3997a 170 ret = consumer_get_discarded_events(session->id, kchan->key,
fb83fe64
JD
171 session->kernel_session->consumer,
172 discarded_events);
173 if (ret < 0) {
174 goto end;
175 }
176
e1f3997a 177 ret = consumer_get_lost_packets(session->id, kchan->key,
fb83fe64
JD
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
a91c5803
JG
199 if (!discarded_events || !lost_packets) {
200 ret = -1;
201 goto end;
202 }
203
fb83fe64 204 usess = session->ust_session;
a905c624
JG
205 assert(discarded_events);
206 assert(lost_packets);
fb83fe64
JD
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");
967bc289 235 assert(0);
fb83fe64
JD
236 ret = -1;
237 goto end;
238 }
239
240end:
241 return ret;
242}
243
2f77fc4b
DG
244/*
245 * Fill lttng_channel array of all channels.
246 */
d449df4a 247static ssize_t list_lttng_channels(enum lttng_domain_type domain,
fb83fe64 248 struct ltt_session *session, struct lttng_channel *channels,
cf0bcb51 249 struct lttng_channel_extended *chan_exts)
2f77fc4b 250{
d449df4a 251 int i = 0, ret = 0;
2f77fc4b
DG
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) {
fb83fe64 262 uint64_t discarded_events, lost_packets;
cf0bcb51
JG
263 struct lttng_channel_extended *extended;
264
265 extended = (struct lttng_channel_extended *)
266 kchan->channel->attr.extended.ptr;
fb83fe64
JD
267
268 ret = get_kernel_runtime_stats(session, kchan,
269 &discarded_events, &lost_packets);
270 if (ret < 0) {
271 goto end;
272 }
2f77fc4b
DG
273 /* Copy lttng_channel struct to array */
274 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
275 channels[i].enabled = kchan->enabled;
fb83fe64
JD
276 chan_exts[i].discarded_events =
277 discarded_events;
278 chan_exts[i].lost_packets = lost_packets;
cf0bcb51
JG
279 chan_exts[i].monitor_timer_interval =
280 extended->monitor_timer_interval;
491d1539 281 chan_exts[i].blocking_timeout = 0;
2f77fc4b
DG
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
e7fe706f 291 rcu_read_lock();
2f77fc4b
DG
292 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
293 &iter.iter, uchan, node.node) {
a91c5803 294 uint64_t discarded_events = 0, lost_packets = 0;
fb83fe64 295
8ee609c8
MD
296 if (lttng_strncpy(channels[i].name, uchan->name,
297 LTTNG_SYMBOL_NAME_LEN)) {
298 break;
299 }
2f77fc4b
DG
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;
2f785fe7
DG
308 channels[i].attr.tracefile_size = uchan->tracefile_size;
309 channels[i].attr.tracefile_count = uchan->tracefile_count;
5e4435a4
JG
310
311 /*
312 * Map enum lttng_ust_output to enum lttng_event_output.
313 */
2f77fc4b
DG
314 switch (uchan->attr.output) {
315 case LTTNG_UST_MMAP:
2f77fc4b
DG
316 channels[i].attr.output = LTTNG_EVENT_MMAP;
317 break;
5e4435a4
JG
318 default:
319 /*
320 * LTTNG_UST_MMAP is the only supported UST
321 * output mode.
322 */
323 assert(0);
324 break;
2f77fc4b 325 }
fb83fe64 326
d449df4a
MD
327 chan_exts[i].monitor_timer_interval =
328 uchan->monitor_timer_interval;
491d1539
MD
329 chan_exts[i].blocking_timeout =
330 uchan->attr.u.s.blocking_timeout;
d449df4a 331
fb83fe64
JD
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;
2f77fc4b
DG
339 i++;
340 }
e7fe706f 341 rcu_read_unlock();
2f77fc4b
DG
342 break;
343 }
344 default:
345 break;
346 }
fb83fe64
JD
347
348end:
d449df4a
MD
349 if (ret < 0) {
350 return -LTTNG_ERR_FATAL;
351 } else {
352 return LTTNG_OK;
353 }
2f77fc4b
DG
354}
355
b4e3ceb9 356static void increment_extended_len(const char *filter_expression,
795d57ce 357 struct lttng_event_exclusion *exclusion, size_t *extended_len)
b4e3ceb9
PP
358{
359 *extended_len += sizeof(struct lttcomm_event_extended_header);
360
361 if (filter_expression) {
362 *extended_len += strlen(filter_expression) + 1;
363 }
795d57ce
PP
364
365 if (exclusion) {
366 *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN;
367 }
b4e3ceb9
PP
368}
369
370static void append_extended_info(const char *filter_expression,
795d57ce 371 struct lttng_event_exclusion *exclusion, void **extended_at)
b4e3ceb9
PP
372{
373 struct lttcomm_event_extended_header extended_header;
374 size_t filter_len = 0;
795d57ce 375 size_t nb_exclusions = 0;
b4e3ceb9
PP
376
377 if (filter_expression) {
378 filter_len = strlen(filter_expression) + 1;
379 }
380
795d57ce
PP
381 if (exclusion) {
382 nb_exclusions = exclusion->count;
383 }
384
385 /* Set header fields */
b4e3ceb9 386 extended_header.filter_len = filter_len;
795d57ce
PP
387 extended_header.nb_exclusions = nb_exclusions;
388
389 /* Copy header */
b4e3ceb9
PP
390 memcpy(*extended_at, &extended_header, sizeof(extended_header));
391 *extended_at += sizeof(extended_header);
795d57ce
PP
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 }
b4e3ceb9
PP
406}
407
3c6a091f 408/*
022d91ba 409 * Create a list of agent domain events.
3c6a091f
DG
410 *
411 * Return number of events in list on success or else a negative value.
412 */
022d91ba 413static int list_lttng_agent_events(struct agent *agt,
b4e3ceb9 414 struct lttng_event **events, size_t *total_size)
3c6a091f
DG
415{
416 int i = 0, ret = 0;
417 unsigned int nb_event = 0;
022d91ba 418 struct agent_event *event;
3c6a091f
DG
419 struct lttng_event *tmp_events;
420 struct lttng_ht_iter iter;
b4e3ceb9
PP
421 size_t extended_len = 0;
422 void *extended_at;
3c6a091f 423
022d91ba 424 assert(agt);
3c6a091f
DG
425 assert(events);
426
022d91ba 427 DBG3("Listing agent events");
3c6a091f 428
e5bbf678 429 rcu_read_lock();
022d91ba 430 nb_event = lttng_ht_get_count(agt->events);
e5bbf678 431 rcu_read_unlock();
3c6a091f
DG
432 if (nb_event == 0) {
433 ret = nb_event;
b4e3ceb9 434 *total_size = 0;
3c6a091f
DG
435 goto error;
436 }
437
b4e3ceb9
PP
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) {
795d57ce
PP
447 increment_extended_len(event->filter_expression, NULL,
448 &extended_len);
b4e3ceb9
PP
449 }
450 rcu_read_unlock();
451
452 *total_size = nb_event * sizeof(*tmp_events) + extended_len;
453 tmp_events = zmalloc(*total_size);
3c6a091f 454 if (!tmp_events) {
022d91ba 455 PERROR("zmalloc agent events session");
3c6a091f
DG
456 ret = -LTTNG_ERR_FATAL;
457 goto error;
458 }
459
b4e3ceb9
PP
460 extended_at = ((uint8_t *) tmp_events) +
461 nb_event * sizeof(struct lttng_event);
462
3c6a091f 463 rcu_read_lock();
022d91ba 464 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
3c6a091f
DG
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;
2106efa0 468 tmp_events[i].loglevel = event->loglevel_value;
ff94328f 469 tmp_events[i].loglevel_type = event->loglevel_type;
3c6a091f 470 i++;
b4e3ceb9
PP
471
472 /* Append extended info */
795d57ce
PP
473 append_extended_info(event->filter_expression, NULL,
474 &extended_at);
3c6a091f
DG
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
2f77fc4b
DG
486/*
487 * Create a list of ust global domain events.
488 */
489static int list_lttng_ust_global_events(char *channel_name,
b4e3ceb9
PP
490 struct ltt_ust_domain_global *ust_global,
491 struct lttng_event **events, size_t *total_size)
2f77fc4b
DG
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;
b4e3ceb9
PP
500 size_t extended_len = 0;
501 void *extended_at;
2f77fc4b
DG
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) {
f73fabfd 510 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
d31d3e8c 511 goto end;
2f77fc4b
DG
512 }
513
514 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
515
3c442be3 516 nb_event = lttng_ht_get_count(uchan->events);
2f77fc4b
DG
517 if (nb_event == 0) {
518 ret = nb_event;
b4e3ceb9 519 *total_size = 0;
d31d3e8c 520 goto end;
2f77fc4b
DG
521 }
522
523 DBG3("Listing UST global %d events", nb_event);
524
b4e3ceb9
PP
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,
795d57ce 533 uevent->exclusion, &extended_len);
b4e3ceb9 534 }
d31d3e8c
PP
535 if (nb_event == 0) {
536 /* All events are internal, skip. */
537 ret = 0;
538 *total_size = 0;
539 goto end;
540 }
b4e3ceb9
PP
541
542 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
543 tmp = zmalloc(*total_size);
2f77fc4b 544 if (tmp == NULL) {
b12c38df
JG
545 ret = -LTTNG_ERR_FATAL;
546 goto end;
2f77fc4b
DG
547 }
548
b4e3ceb9
PP
549 extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event);
550
2f77fc4b 551 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
3c442be3
JG
552 if (uevent->internal) {
553 /* This event should remain hidden from clients */
3c442be3
JG
554 continue;
555 }
2f77fc4b
DG
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 }
4634f12e
JI
587 if (uevent->exclusion) {
588 tmp[i].exclusion = 1;
589 }
2f77fc4b 590 i++;
b4e3ceb9
PP
591
592 /* Append extended info */
795d57ce
PP
593 append_extended_info(uevent->filter_expression,
594 uevent->exclusion, &extended_at);
2f77fc4b
DG
595 }
596
597 ret = nb_event;
598 *events = tmp;
d31d3e8c 599end:
2f77fc4b
DG
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,
b4e3ceb9
PP
608 struct ltt_kernel_session *kernel_session,
609 struct lttng_event **events, size_t *total_size)
2f77fc4b
DG
610{
611 int i = 0, ret;
612 unsigned int nb_event;
613 struct ltt_kernel_event *event;
614 struct ltt_kernel_channel *kchan;
b4e3ceb9
PP
615 size_t extended_len = 0;
616 void *extended_at;
2f77fc4b
DG
617
618 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
619 if (kchan == NULL) {
f73fabfd 620 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
2f77fc4b
DG
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) {
b4e3ceb9 629 *total_size = 0;
834978fd 630 *events = NULL;
db906c12 631 goto end;
2f77fc4b
DG
632 }
633
b4e3ceb9
PP
634 /* Compute required extended infos size */
635 cds_list_for_each_entry(event, &kchan->events_list.head, list) {
795d57ce
PP
636 increment_extended_len(event->filter_expression, NULL,
637 &extended_len);
b4e3ceb9
PP
638 }
639
640 *total_size = nb_event * sizeof(struct lttng_event) + extended_len;
641 *events = zmalloc(*total_size);
2f77fc4b 642 if (*events == NULL) {
f73fabfd 643 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
644 goto error;
645 }
646
ab4aa612 647 extended_at = ((void *) *events) +
b4e3ceb9
PP
648 nb_event * sizeof(struct lttng_event);
649
2f77fc4b
DG
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;
00f992f2
JG
655 (*events)[i].filter =
656 (unsigned char) !!event->filter_expression;
2f77fc4b
DG
657
658 switch (event->event->instrumentation) {
659 case LTTNG_KERNEL_TRACEPOINT:
660 (*events)[i].type = LTTNG_EVENT_TRACEPOINT;
661 break;
2f77fc4b 662 case LTTNG_KERNEL_KRETPROBE:
1896972b
DG
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:
2f77fc4b
DG
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++;
b4e3ceb9
PP
688
689 /* Append extended info */
795d57ce
PP
690 append_extended_info(event->filter_expression, NULL,
691 &extended_at);
2f77fc4b
DG
692 }
693
db906c12 694end:
2f77fc4b
DG
695 return nb_event;
696
697error:
f73fabfd
DG
698 /* Negate the error code to differentiate the size from an error */
699 return -ret;
2f77fc4b
DG
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,
56a37563
JG
707 struct lttng_uri *uri, enum lttng_domain_type domain,
708 const char *session_name)
2f77fc4b 709{
f73fabfd 710 int ret = LTTNG_OK;
2f77fc4b
DG
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.");
f73fabfd 717 ret = LTTNG_ERR_NO_CONSUMER;
2f77fc4b
DG
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
df75acac
DG
741 if (consumer->type == CONSUMER_DST_NET) {
742 if ((uri->stype == LTTNG_STREAM_CONTROL &&
785d2d0d
DG
743 consumer->dst.net.control_isset) ||
744 (uri->stype == LTTNG_STREAM_DATA &&
745 consumer->dst.net.data_isset)) {
df75acac
DG
746 ret = LTTNG_ERR_URL_EXIST;
747 goto error;
748 }
749 } else {
750 memset(&consumer->dst.net, 0, sizeof(consumer->dst.net));
785d2d0d
DG
751 }
752
df75acac
DG
753 consumer->type = CONSUMER_DST_NET;
754
2f77fc4b
DG
755 /* Set URI into consumer output object */
756 ret = consumer_set_network_uri(consumer, uri);
757 if (ret < 0) {
a74934ba 758 ret = -ret;
2f77fc4b
DG
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 */
f86c9f4e 765 ret = LTTNG_OK;
2f77fc4b
DG
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) {
f73fabfd 772 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
773 goto error;
774 }
775 }
776
777 if (uri->stype == LTTNG_STREAM_CONTROL) {
778 /* On a new subdir, reappend the default trace dir. */
c30ce0b3
CB
779 strncat(consumer->subdir, default_trace_dir,
780 sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
2f77fc4b
DG
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);
366a9222
JD
787 memset(consumer->dst.session_root_path, 0,
788 sizeof(consumer->dst.session_root_path));
9ac05d92
MD
789 /* Explicit length checks for strcpy and strcat. */
790 if (strlen(uri->dst.path) + strlen(default_trace_dir)
366a9222 791 >= sizeof(consumer->dst.session_root_path)) {
9ac05d92
MD
792 ret = LTTNG_ERR_FATAL;
793 goto error;
794 }
366a9222 795 strcpy(consumer->dst.session_root_path, uri->dst.path);
2f77fc4b 796 /* Append default trace dir */
366a9222 797 strcat(consumer->dst.session_root_path, default_trace_dir);
2f77fc4b
DG
798 /* Flag consumer as local. */
799 consumer->type = CONSUMER_DST_LOCAL;
800 break;
801 }
802
a74934ba
DG
803 ret = LTTNG_OK;
804
2f77fc4b
DG
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
e7fe706f
DG
820 rcu_read_lock();
821
2f77fc4b
DG
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) {
2f77fc4b 825 pthread_mutex_lock(socket->lock);
f50f23d9 826 ret = kernel_consumer_send_session(socket, session);
2f77fc4b
DG
827 pthread_mutex_unlock(socket->lock);
828 if (ret < 0) {
f73fabfd 829 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
830 goto error;
831 }
832 }
833 }
834
835error:
e7fe706f 836 rcu_read_unlock();
2f77fc4b
DG
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 */
6151a90f 846static int create_connect_relayd(struct lttng_uri *uri,
b31610f2
JD
847 struct lttcomm_relayd_sock **relayd_sock,
848 struct consumer_output *consumer)
2f77fc4b
DG
849{
850 int ret;
6151a90f 851 struct lttcomm_relayd_sock *rsock;
2f77fc4b 852
6151a90f
JD
853 rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
854 RELAYD_VERSION_COMM_MINOR);
855 if (!rsock) {
f73fabfd 856 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
857 goto error;
858 }
859
ffe60014
DG
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();
6151a90f 866 ret = relayd_connect(rsock);
ffe60014 867 health_poll_exit();
2f77fc4b
DG
868 if (ret < 0) {
869 ERR("Unable to reach lttng-relayd");
f73fabfd 870 ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
2f77fc4b
DG
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 */
6151a90f 879 ret = relayd_version_check(rsock);
67d5aa28
JD
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;
2f77fc4b
DG
885 goto close_sock;
886 }
b31610f2
JD
887 consumer->relay_major_version = rsock->major;
888 consumer->relay_minor_version = rsock->minor;
2f77fc4b
DG
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);
f73fabfd 894 ret = LTTNG_ERR_INVALID;
2f77fc4b
DG
895 goto close_sock;
896 }
897
6151a90f 898 *relayd_sock = rsock;
2f77fc4b 899
f73fabfd 900 return LTTNG_OK;
2f77fc4b
DG
901
902close_sock:
6151a90f
JD
903 /* The returned value is not useful since we are on an error path. */
904 (void) relayd_close(rsock);
2f77fc4b 905free_sock:
6151a90f 906 free(rsock);
2f77fc4b
DG
907error:
908 return ret;
909}
910
911/*
912 * Connect to the relayd using URI and send the socket to the right consumer.
43fade62
JG
913 *
914 * The consumer socket lock must be held by the caller.
2f77fc4b 915 */
56a37563
JG
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,
d3e2ba59
JD
919 struct consumer_socket *consumer_sock,
920 char *session_name, char *hostname, int session_live_timer)
2f77fc4b
DG
921{
922 int ret;
6151a90f 923 struct lttcomm_relayd_sock *rsock = NULL;
2f77fc4b 924
ffe60014 925 /* Connect to relayd and make version check if uri is the control. */
b31610f2 926 ret = create_connect_relayd(relayd_uri, &rsock, consumer);
ffe60014 927 if (ret != LTTNG_OK) {
9e218353 928 goto relayd_comm_error;
ffe60014 929 }
6151a90f 930 assert(rsock);
ffe60014 931
2f77fc4b 932 /* Set the network sequence index if not set. */
d88aee68
DG
933 if (consumer->net_seq_index == (uint64_t) -1ULL) {
934 pthread_mutex_lock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
935 /*
936 * Increment net_seq_idx because we are about to transfer the
937 * new relayd socket to the consumer.
d88aee68 938 * Assign unique key so the consumer can match streams.
2f77fc4b 939 */
d88aee68
DG
940 consumer->net_seq_index = ++relayd_net_seq_idx;
941 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
942 }
943
2f77fc4b 944 /* Send relayd socket to consumer. */
6151a90f 945 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
d3e2ba59
JD
946 relayd_uri->stype, session_id,
947 session_name, hostname, session_live_timer);
2f77fc4b 948 if (ret < 0) {
f73fabfd 949 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2f77fc4b
DG
950 goto close_sock;
951 }
952
c890b720
DG
953 /* Flag that the corresponding socket was sent. */
954 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
ffe60014 955 consumer_sock->control_sock_sent = 1;
c890b720 956 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
ffe60014 957 consumer_sock->data_sock_sent = 1;
c890b720
DG
958 }
959
f73fabfd 960 ret = LTTNG_OK;
2f77fc4b
DG
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:
ffe60014
DG
968 if (ret != LTTNG_OK) {
969 /*
d9078d0c
DG
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.
ffe60014 973 */
d9078d0c 974 consumer->enabled = 0;
ffe60014 975 }
9e218353
JR
976 (void) relayd_close(rsock);
977 free(rsock);
978
979relayd_comm_error:
2f77fc4b
DG
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.
43fade62
JG
987 *
988 * The consumer socket lock must be held by the caller.
2f77fc4b 989 */
56a37563
JG
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)
2f77fc4b 994{
dda67f6c 995 int ret = LTTNG_OK;
2f77fc4b 996
2f77fc4b 997 assert(consumer);
6dc3064a 998 assert(sock);
2f77fc4b 999
2f77fc4b 1000 /* Sending control relayd socket. */
ffe60014 1001 if (!sock->control_sock_sent) {
6dc3064a 1002 ret = send_consumer_relayd_socket(domain, session_id,
d3e2ba59
JD
1003 &consumer->dst.net.control, consumer, sock,
1004 session_name, hostname, session_live_timer);
c890b720
DG
1005 if (ret != LTTNG_OK) {
1006 goto error;
1007 }
2f77fc4b
DG
1008 }
1009
1010 /* Sending data relayd socket. */
ffe60014 1011 if (!sock->data_sock_sent) {
6dc3064a 1012 ret = send_consumer_relayd_socket(domain, session_id,
d3e2ba59
JD
1013 &consumer->dst.net.data, consumer, sock,
1014 session_name, hostname, session_live_timer);
c890b720
DG
1015 if (ret != LTTNG_OK) {
1016 goto error;
1017 }
2f77fc4b
DG
1018 }
1019
2f77fc4b
DG
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 */
ffe60014 1029int cmd_setup_relayd(struct ltt_session *session)
2f77fc4b 1030{
f73fabfd 1031 int ret = LTTNG_OK;
2f77fc4b
DG
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
785d2d0d 1042 DBG("Setting relayd for session %s", session->name);
2f77fc4b 1043
e7fe706f
DG
1044 rcu_read_lock();
1045
2f77fc4b
DG
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) {
2f77fc4b 1051 pthread_mutex_lock(socket->lock);
6dc3064a 1052 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
d3e2ba59
JD
1053 usess->consumer, socket,
1054 session->name, session->hostname,
1055 session->live_timer);
2f77fc4b 1056 pthread_mutex_unlock(socket->lock);
f73fabfd 1057 if (ret != LTTNG_OK) {
2f77fc4b
DG
1058 goto error;
1059 }
6dc3064a
DG
1060 /* Session is now ready for network streaming. */
1061 session->net_handle = 1;
2f77fc4b 1062 }
b31610f2
JD
1063 session->consumer->relay_major_version =
1064 usess->consumer->relay_major_version;
1065 session->consumer->relay_minor_version =
1066 usess->consumer->relay_minor_version;
2f77fc4b
DG
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) {
2f77fc4b 1073 pthread_mutex_lock(socket->lock);
6dc3064a 1074 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
d3e2ba59
JD
1075 ksess->consumer, socket,
1076 session->name, session->hostname,
1077 session->live_timer);
2f77fc4b 1078 pthread_mutex_unlock(socket->lock);
f73fabfd 1079 if (ret != LTTNG_OK) {
2f77fc4b
DG
1080 goto error;
1081 }
6dc3064a
DG
1082 /* Session is now ready for network streaming. */
1083 session->net_handle = 1;
2f77fc4b 1084 }
b31610f2
JD
1085 session->consumer->relay_major_version =
1086 ksess->consumer->relay_major_version;
1087 session->consumer->relay_minor_version =
1088 ksess->consumer->relay_minor_version;
2f77fc4b
DG
1089 }
1090
1091error:
e7fe706f 1092 rcu_read_unlock();
2f77fc4b
DG
1093 return ret;
1094}
1095
9b6c7ec5
DG
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 */
07b86b52 1105 if (ksess->metadata == NULL && ksess->output_traces) {
9b6c7ec5
DG
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 */
07b86b52 1114 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
9b6c7ec5
DG
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);
e43c41c5 1138 if (ret != 0) {
9b6c7ec5
DG
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 */
784303b0 1151 kernel_wait_quiescent(kernel_tracer_fd);
9b6c7ec5 1152
14fb1ebe 1153 ksess->active = 1;
9b6c7ec5
DG
1154
1155 ret = LTTNG_OK;
1156
1157error:
1158 return ret;
1159}
1160
2f77fc4b
DG
1161/*
1162 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1163 */
56a37563
JG
1164int cmd_disable_channel(struct ltt_session *session,
1165 enum lttng_domain_type domain, char *channel_name)
2f77fc4b
DG
1166{
1167 int ret;
1168 struct ltt_ust_session *usess;
1169
1170 usess = session->ust_session;
1171
2223c96f
DG
1172 rcu_read_lock();
1173
2f77fc4b
DG
1174 switch (domain) {
1175 case LTTNG_DOMAIN_KERNEL:
1176 {
1177 ret = channel_kernel_disable(session->kernel_session,
1178 channel_name);
f73fabfd 1179 if (ret != LTTNG_OK) {
2f77fc4b
DG
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) {
f73fabfd 1195 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
2f77fc4b
DG
1196 goto error;
1197 }
1198
7972aab2 1199 ret = channel_ust_disable(usess, uchan);
f73fabfd 1200 if (ret != LTTNG_OK) {
2f77fc4b
DG
1201 goto error;
1202 }
1203 break;
1204 }
2f77fc4b 1205 default:
f73fabfd 1206 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1207 goto error;
1208 }
1209
f73fabfd 1210 ret = LTTNG_OK;
2f77fc4b
DG
1211
1212error:
2223c96f 1213 rcu_read_unlock();
2f77fc4b
DG
1214 return ret;
1215}
1216
ccf10263
MD
1217/*
1218 * Command LTTNG_TRACK_PID processed by the client thread.
a9ad0c8f
MD
1219 *
1220 * Called with session lock held.
ccf10263 1221 */
56a37563
JG
1222int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
1223 int pid)
ccf10263
MD
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 }
ccf10263 1244 case LTTNG_DOMAIN_UST:
a9ad0c8f
MD
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 }
ccf10263
MD
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.
a9ad0c8f
MD
1270 *
1271 * Called with session lock held.
ccf10263 1272 */
56a37563
JG
1273int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
1274 int pid)
ccf10263
MD
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 }
ccf10263 1295 case LTTNG_DOMAIN_UST:
a9ad0c8f
MD
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 }
ccf10263
MD
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
2f77fc4b
DG
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,
7972aab2 1325 struct lttng_domain *domain, struct lttng_channel *attr, int wpipe)
2f77fc4b
DG
1326{
1327 int ret;
1328 struct ltt_ust_session *usess = session->ust_session;
1329 struct lttng_ht *chan_ht;
1f345e94 1330 size_t len;
2f77fc4b
DG
1331
1332 assert(session);
1333 assert(attr);
7972aab2 1334 assert(domain);
2f77fc4b 1335
f5436bfc 1336 len = lttng_strnlen(attr->name, sizeof(attr->name));
1f345e94
PP
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
2f77fc4b
DG
1345 DBG("Enabling channel %s for session %s", attr->name, session->name);
1346
03b4fdcf
DG
1347 rcu_read_lock();
1348
ecc48a90
JD
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 */
8382cf6f 1353 if (session->has_been_started) {
ecc48a90
JD
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
6e21424e
JR
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
7972aab2 1392 switch (domain->type) {
2f77fc4b
DG
1393 case LTTNG_DOMAIN_KERNEL:
1394 {
1395 struct ltt_kernel_channel *kchan;
1396
2f77fc4b
DG
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);
85076754
MD
1401 if (attr->name[0] != '\0') {
1402 session->kernel_session->has_non_default_channel = 1;
1403 }
2f77fc4b
DG
1404 } else {
1405 ret = channel_kernel_enable(session->kernel_session, kchan);
1406 }
1407
f73fabfd 1408 if (ret != LTTNG_OK) {
2f77fc4b
DG
1409 goto error;
1410 }
1411
784303b0 1412 kernel_wait_quiescent(kernel_tracer_fd);
2f77fc4b
DG
1413 break;
1414 }
1415 case LTTNG_DOMAIN_UST:
9232818f
JG
1416 case LTTNG_DOMAIN_JUL:
1417 case LTTNG_DOMAIN_LOG4J:
1418 case LTTNG_DOMAIN_PYTHON:
2f77fc4b
DG
1419 {
1420 struct ltt_ust_channel *uchan;
1421
9232818f
JG
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
2f77fc4b
DG
1450 chan_ht = usess->domain_global.channels;
1451
1452 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
1453 if (uchan == NULL) {
7972aab2 1454 ret = channel_ust_create(usess, attr, domain->buf_type);
85076754
MD
1455 if (attr->name[0] != '\0') {
1456 usess->has_non_default_channel = 1;
1457 }
2f77fc4b 1458 } else {
7972aab2 1459 ret = channel_ust_enable(usess, uchan);
2f77fc4b
DG
1460 }
1461 break;
1462 }
2f77fc4b 1463 default:
f73fabfd 1464 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1465 goto error;
1466 }
1467
1468error:
2223c96f 1469 rcu_read_unlock();
1f345e94 1470end:
2f77fc4b
DG
1471 return ret;
1472}
1473
2f77fc4b
DG
1474/*
1475 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1476 */
56a37563
JG
1477int cmd_disable_event(struct ltt_session *session,
1478 enum lttng_domain_type domain, char *channel_name,
6e911cad 1479 struct lttng_event *event)
2f77fc4b
DG
1480{
1481 int ret;
6e911cad
MD
1482 char *event_name;
1483
18a720cd
MD
1484 DBG("Disable event command for event \'%s\'", event->name);
1485
6e911cad
MD
1486 event_name = event->name;
1487
9b7431cf
JG
1488 /* Error out on unhandled search criteria */
1489 if (event->loglevel_type || event->loglevel != -1 || event->enabled
6e911cad 1490 || event->pid || event->filter || event->exclusion) {
7076b56e
JG
1491 ret = LTTNG_ERR_UNK;
1492 goto error;
6e911cad 1493 }
2f77fc4b 1494
2223c96f
DG
1495 rcu_read_lock();
1496
2f77fc4b
DG
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
85076754
MD
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;
7076b56e 1512 goto error_unlock;
85076754
MD
1513 }
1514
2f77fc4b
DG
1515 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1516 if (kchan == NULL) {
f73fabfd 1517 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
7076b56e 1518 goto error_unlock;
2f77fc4b
DG
1519 }
1520
6e911cad
MD
1521 switch (event->type) {
1522 case LTTNG_EVENT_ALL:
9550ee81 1523 case LTTNG_EVENT_TRACEPOINT:
d0ae4ea8 1524 case LTTNG_EVENT_SYSCALL:
9550ee81
JR
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);
29c62722 1531 } else {
d0ae4ea8 1532 ret = event_kernel_disable_event(kchan,
9550ee81 1533 event_name, event->type);
29c62722 1534 }
6e911cad 1535 if (ret != LTTNG_OK) {
7076b56e 1536 goto error_unlock;
6e911cad
MD
1537 }
1538 break;
6e911cad
MD
1539 default:
1540 ret = LTTNG_ERR_UNK;
7076b56e 1541 goto error_unlock;
2f77fc4b
DG
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
7076b56e
JG
1554 if (validate_ust_event_name(event_name)) {
1555 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1556 goto error_unlock;
1557 }
1558
85076754
MD
1559 /*
1560 * If a non-default channel has been created in the
9550ee81 1561 * session, explicitly require that -c chan_name needs
85076754
MD
1562 * to be provided.
1563 */
1564 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1565 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
7076b56e 1566 goto error_unlock;
85076754
MD
1567 }
1568
2f77fc4b
DG
1569 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1570 channel_name);
1571 if (uchan == NULL) {
f73fabfd 1572 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
7076b56e 1573 goto error_unlock;
2f77fc4b
DG
1574 }
1575
6e911cad
MD
1576 switch (event->type) {
1577 case LTTNG_EVENT_ALL:
b3639870
JR
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);
77d536b2
JR
1584 } else {
1585 ret = event_ust_disable_tracepoint(usess, uchan,
1586 event_name);
1587 }
6e911cad 1588 if (ret != LTTNG_OK) {
7076b56e 1589 goto error_unlock;
6e911cad
MD
1590 }
1591 break;
1592 default:
1593 ret = LTTNG_ERR_UNK;
7076b56e 1594 goto error_unlock;
2f77fc4b
DG
1595 }
1596
1597 DBG3("Disable UST event %s in channel %s completed", event_name,
1598 channel_name);
1599 break;
1600 }
5cdb6027 1601 case LTTNG_DOMAIN_LOG4J:
f20baf8e 1602 case LTTNG_DOMAIN_JUL:
0e115563 1603 case LTTNG_DOMAIN_PYTHON:
f20baf8e 1604 {
fefd409b 1605 struct agent *agt;
f20baf8e
DG
1606 struct ltt_ust_session *usess = session->ust_session;
1607
1608 assert(usess);
1609
6e911cad
MD
1610 switch (event->type) {
1611 case LTTNG_EVENT_ALL:
1612 break;
1613 default:
1614 ret = LTTNG_ERR_UNK;
7076b56e 1615 goto error_unlock;
6e911cad
MD
1616 }
1617
5cdb6027 1618 agt = trace_ust_find_agent(usess, domain);
fefd409b
DG
1619 if (!agt) {
1620 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
7076b56e 1621 goto error_unlock;
fefd409b 1622 }
b3639870
JR
1623 /*
1624 * An empty event name means that everything
1625 * should be disabled.
1626 */
1627 if (event->name[0] == '\0') {
18a720cd
MD
1628 ret = event_agent_disable_all(usess, agt);
1629 } else {
1630 ret = event_agent_disable(usess, agt, event_name);
1631 }
f20baf8e 1632 if (ret != LTTNG_OK) {
7076b56e 1633 goto error_unlock;
f20baf8e
DG
1634 }
1635
1636 break;
1637 }
2f77fc4b 1638 default:
f73fabfd 1639 ret = LTTNG_ERR_UND;
7076b56e 1640 goto error_unlock;
2f77fc4b
DG
1641 }
1642
f73fabfd 1643 ret = LTTNG_OK;
2f77fc4b 1644
7076b56e 1645error_unlock:
2223c96f 1646 rcu_read_unlock();
7076b56e 1647error:
2f77fc4b
DG
1648 return ret;
1649}
1650
2f77fc4b
DG
1651/*
1652 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1653 */
56a37563 1654int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
601d5acf 1655 char *channel_name, struct lttng_event_context *ctx, int kwpipe)
2f77fc4b 1656{
d5979e4a 1657 int ret, chan_kern_created = 0, chan_ust_created = 0;
bdf64013
JG
1658 char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
1659
9a699f7b
JR
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
bdf64013
JG
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 }
2f77fc4b
DG
1674
1675 switch (domain) {
1676 case LTTNG_DOMAIN_KERNEL:
979e618e
DG
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 }
d5979e4a 1685 chan_kern_created = 1;
979e618e 1686 }
2f77fc4b 1687 /* Add kernel context to kernel tracer */
601d5acf 1688 ret = context_kernel_add(session->kernel_session, ctx, channel_name);
f73fabfd 1689 if (ret != LTTNG_OK) {
2f77fc4b
DG
1690 goto error;
1691 }
1692 break;
bdf64013
JG
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 }
a93b3916 1714 /* break is _not_ missing here. */
bdf64013 1715 }
2f77fc4b
DG
1716 case LTTNG_DOMAIN_UST:
1717 {
1718 struct ltt_ust_session *usess = session->ust_session;
85076754
MD
1719 unsigned int chan_count;
1720
2f77fc4b
DG
1721 assert(usess);
1722
85076754 1723 chan_count = lttng_ht_get_count(usess->domain_global.channels);
979e618e
DG
1724 if (chan_count == 0) {
1725 struct lttng_channel *attr;
1726 /* Create default channel */
0a9c6494 1727 attr = channel_new_default_attr(domain, usess->buffer_type);
979e618e
DG
1728 if (attr == NULL) {
1729 ret = LTTNG_ERR_FATAL;
1730 goto error;
1731 }
1732
7972aab2 1733 ret = channel_ust_create(usess, attr, usess->buffer_type);
979e618e
DG
1734 if (ret != LTTNG_OK) {
1735 free(attr);
1736 goto error;
1737 }
cf0bcb51 1738 channel_attr_destroy(attr);
d5979e4a 1739 chan_ust_created = 1;
979e618e
DG
1740 }
1741
601d5acf 1742 ret = context_ust_add(usess, domain, ctx, channel_name);
bdf64013
JG
1743 free(app_ctx_provider_name);
1744 free(app_ctx_name);
1745 app_ctx_name = NULL;
1746 app_ctx_provider_name = NULL;
f73fabfd 1747 if (ret != LTTNG_OK) {
2f77fc4b
DG
1748 goto error;
1749 }
1750 break;
1751 }
2f77fc4b 1752 default:
f73fabfd 1753 ret = LTTNG_ERR_UND;
2f77fc4b
DG
1754 goto error;
1755 }
1756
bdf64013
JG
1757 ret = LTTNG_OK;
1758 goto end;
2f77fc4b
DG
1759
1760error:
d5979e4a
DG
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 }
bdf64013
JG
1782end:
1783 free(app_ctx_provider_name);
1784 free(app_ctx_name);
2f77fc4b
DG
1785 return ret;
1786}
1787
dac8e046
JG
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}
88f06f15 1818
2f77fc4b 1819/*
88f06f15
JG
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.
2f77fc4b 1824 */
88f06f15
JG
1825static int _cmd_enable_event(struct ltt_session *session,
1826 struct lttng_domain *domain,
025faf73 1827 char *channel_name, struct lttng_event *event,
6b453b5e 1828 char *filter_expression,
db8f1377
JI
1829 struct lttng_filter_bytecode *filter,
1830 struct lttng_event_exclusion *exclusion,
88f06f15 1831 int wpipe, bool internal_event)
2f77fc4b 1832{
9f449915 1833 int ret = 0, channel_created = 0;
cfedea03 1834 struct lttng_channel *attr = NULL;
2f77fc4b
DG
1835
1836 assert(session);
1837 assert(event);
1838 assert(channel_name);
1839
2a385866
JG
1840 /* If we have a filter, we must have its filter expression */
1841 assert(!(!!filter_expression ^ !!filter));
1842
9f449915
PP
1843 /* Normalize event name as a globbing pattern */
1844 strutils_normalize_star_glob_pattern(event->name);
18a720cd 1845
9f449915
PP
1846 /* Normalize exclusion names as globbing patterns */
1847 if (exclusion) {
1848 size_t i;
f5ac4bd7 1849
9f449915
PP
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 }
930a2e99
JG
1855 }
1856
9f449915
PP
1857 DBG("Enable event command for event \'%s\'", event->name);
1858
1859 rcu_read_lock();
1860
7972aab2 1861 switch (domain->type) {
2f77fc4b
DG
1862 case LTTNG_DOMAIN_KERNEL:
1863 {
1864 struct ltt_kernel_channel *kchan;
1865
85076754
MD
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
2f77fc4b
DG
1877 kchan = trace_kernel_get_channel_by_name(channel_name,
1878 session->kernel_session);
1879 if (kchan == NULL) {
0a9c6494
DG
1880 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
1881 LTTNG_BUFFER_GLOBAL);
2f77fc4b 1882 if (attr == NULL) {
f73fabfd 1883 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
1884 goto error;
1885 }
04c17253
MD
1886 if (lttng_strncpy(attr->name, channel_name,
1887 sizeof(attr->name))) {
1888 ret = LTTNG_ERR_INVALID;
04c17253
MD
1889 goto error;
1890 }
2f77fc4b
DG
1891
1892 ret = cmd_enable_channel(session, domain, attr, wpipe);
f73fabfd 1893 if (ret != LTTNG_OK) {
2f77fc4b
DG
1894 goto error;
1895 }
e5f5db7f 1896 channel_created = 1;
2f77fc4b
DG
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... */
f73fabfd 1904 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
1905 goto error;
1906 }
1907
6e911cad
MD
1908 switch (event->type) {
1909 case LTTNG_EVENT_ALL:
29c62722 1910 {
00a62084
MD
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 }
29c62722 1935 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
00a62084
MD
1936 ret = event_kernel_enable_event(kchan, event,
1937 filter_expression, filter);
a969e101
MD
1938 /* We have passed ownership */
1939 filter_expression = NULL;
1940 filter = NULL;
29c62722
MD
1941 if (ret != LTTNG_OK) {
1942 if (channel_created) {
1943 /* Let's not leak a useless channel. */
1944 kernel_destroy_channel(kchan);
1945 }
00a62084
MD
1946 free(filter_expression_a);
1947 free(filter_a);
29c62722
MD
1948 goto error;
1949 }
1950 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
00a62084
MD
1951 ret = event_kernel_enable_event(kchan, event,
1952 filter_expression_a, filter_a);
60d21fa2
AB
1953 /* We have passed ownership */
1954 filter_expression_a = NULL;
1955 filter_a = NULL;
29c62722
MD
1956 if (ret != LTTNG_OK) {
1957 goto error;
1958 }
1959 break;
1960 }
6e6ef3d7
DG
1961 case LTTNG_EVENT_PROBE:
1962 case LTTNG_EVENT_FUNCTION:
1963 case LTTNG_EVENT_FUNCTION_ENTRY:
6e911cad 1964 case LTTNG_EVENT_TRACEPOINT:
00a62084
MD
1965 ret = event_kernel_enable_event(kchan, event,
1966 filter_expression, filter);
a969e101
MD
1967 /* We have passed ownership */
1968 filter_expression = NULL;
1969 filter = NULL;
6e911cad
MD
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;
e5f5db7f 1976 }
6e911cad
MD
1977 break;
1978 case LTTNG_EVENT_SYSCALL:
00a62084
MD
1979 ret = event_kernel_enable_event(kchan, event,
1980 filter_expression, filter);
a969e101
MD
1981 /* We have passed ownership */
1982 filter_expression = NULL;
1983 filter = NULL;
e2b957af
MD
1984 if (ret != LTTNG_OK) {
1985 goto error;
1986 }
6e911cad
MD
1987 break;
1988 default:
1989 ret = LTTNG_ERR_UNK;
2f77fc4b
DG
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
85076754
MD
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
2f77fc4b
DG
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 */
0a9c6494
DG
2018 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2019 usess->buffer_type);
2f77fc4b 2020 if (attr == NULL) {
f73fabfd 2021 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2022 goto error;
2023 }
04c17253
MD
2024 if (lttng_strncpy(attr->name, channel_name,
2025 sizeof(attr->name))) {
2026 ret = LTTNG_ERR_INVALID;
04c17253
MD
2027 goto error;
2028 }
2f77fc4b
DG
2029
2030 ret = cmd_enable_channel(session, domain, attr, wpipe);
f73fabfd 2031 if (ret != LTTNG_OK) {
2f77fc4b
DG
2032 goto error;
2033 }
2f77fc4b
DG
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
141feb8c
JG
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
dac8e046
JG
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
2f77fc4b 2066 /* At this point, the session and channel exist on the tracer */
6b453b5e 2067 ret = event_ust_enable_tracepoint(usess, uchan, event,
88f06f15
JG
2068 filter_expression, filter, exclusion,
2069 internal_event);
49d21f93
MD
2070 /* We have passed ownership */
2071 filter_expression = NULL;
2072 filter = NULL;
2073 exclusion = NULL;
94382e15
JG
2074 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2075 goto already_enabled;
2076 } else if (ret != LTTNG_OK) {
2f77fc4b
DG
2077 goto error;
2078 }
2079 break;
2080 }
5cdb6027 2081 case LTTNG_DOMAIN_LOG4J:
f20baf8e 2082 case LTTNG_DOMAIN_JUL:
0e115563 2083 case LTTNG_DOMAIN_PYTHON:
f20baf8e 2084 {
da6c3a50 2085 const char *default_event_name, *default_chan_name;
fefd409b 2086 struct agent *agt;
f20baf8e
DG
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
5cdb6027 2093 agt = trace_ust_find_agent(usess, domain->type);
fefd409b 2094 if (!agt) {
5cdb6027 2095 agt = agent_create(domain->type);
fefd409b 2096 if (!agt) {
e5b3c48c 2097 ret = LTTNG_ERR_NOMEM;
fefd409b
DG
2098 goto error;
2099 }
2100 agent_add(agt, usess->agents);
2101 }
2102
022d91ba 2103 /* Create the default tracepoint. */
996de3c7 2104 memset(&uevent, 0, sizeof(uevent));
f20baf8e
DG
2105 uevent.type = LTTNG_EVENT_TRACEPOINT;
2106 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
51755dc8
JG
2107 default_event_name = event_get_default_agent_ust_name(
2108 domain->type);
da6c3a50 2109 if (!default_event_name) {
e5b3c48c 2110 ret = LTTNG_ERR_FATAL;
da6c3a50 2111 goto error;
f43f95a9 2112 }
da6c3a50 2113 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
f20baf8e
DG
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
0e115563
DG
2124 switch (domain->type) {
2125 case LTTNG_DOMAIN_LOG4J:
da6c3a50 2126 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
0e115563
DG
2127 break;
2128 case LTTNG_DOMAIN_JUL:
da6c3a50 2129 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
0e115563
DG
2130 break;
2131 case LTTNG_DOMAIN_PYTHON:
2132 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2133 break;
2134 default:
e98a44b0 2135 /* The switch/case we are in makes this impossible */
0e115563 2136 assert(0);
da6c3a50
DG
2137 }
2138
971da06a 2139 {
8404118c 2140 char *filter_expression_copy = NULL;
51755dc8 2141 struct lttng_filter_bytecode *filter_copy = NULL;
971da06a
JG
2142
2143 if (filter) {
51755dc8
JG
2144 const size_t filter_size = sizeof(
2145 struct lttng_filter_bytecode)
2146 + filter->len;
2147
2148 filter_copy = zmalloc(filter_size);
971da06a 2149 if (!filter_copy) {
018096a4 2150 ret = LTTNG_ERR_NOMEM;
b742e3e2 2151 goto error;
971da06a 2152 }
51755dc8 2153 memcpy(filter_copy, filter, filter_size);
971da06a 2154
8404118c
JG
2155 filter_expression_copy =
2156 strdup(filter_expression);
2157 if (!filter_expression) {
2158 ret = LTTNG_ERR_NOMEM;
51755dc8
JG
2159 }
2160
2161 if (!filter_expression_copy || !filter_copy) {
2162 free(filter_expression_copy);
2163 free(filter_copy);
2164 goto error;
8404118c 2165 }
971da06a
JG
2166 }
2167
88f06f15 2168 ret = cmd_enable_event_internal(session, &tmp_dom,
971da06a 2169 (char *) default_chan_name,
8404118c
JG
2170 &uevent, filter_expression_copy,
2171 filter_copy, NULL, wpipe);
971da06a
JG
2172 }
2173
94382e15
JG
2174 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2175 goto already_enabled;
2176 } else if (ret != LTTNG_OK) {
f20baf8e
DG
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) {
8404118c
JG
2182 ret = event_agent_enable_all(usess, agt, event, filter,
2183 filter_expression);
f20baf8e 2184 } else {
8404118c
JG
2185 ret = event_agent_enable(usess, agt, event, filter,
2186 filter_expression);
f20baf8e 2187 }
51755dc8
JG
2188 filter = NULL;
2189 filter_expression = NULL;
f20baf8e
DG
2190 if (ret != LTTNG_OK) {
2191 goto error;
2192 }
2193
2194 break;
2195 }
2f77fc4b 2196 default:
f73fabfd 2197 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2198 goto error;
2199 }
2200
f73fabfd 2201 ret = LTTNG_OK;
2f77fc4b 2202
94382e15 2203already_enabled:
2f77fc4b 2204error:
49d21f93
MD
2205 free(filter_expression);
2206 free(filter);
2207 free(exclusion);
cf0bcb51 2208 channel_attr_destroy(attr);
2223c96f 2209 rcu_read_unlock();
2f77fc4b
DG
2210 return ret;
2211}
2212
88f06f15
JG
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
2f77fc4b
DG
2245/*
2246 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2247 */
56a37563
JG
2248ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
2249 struct lttng_event **events)
2f77fc4b
DG
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) {
f73fabfd 2258 ret = LTTNG_ERR_KERN_LIST_FAIL;
2f77fc4b
DG
2259 goto error;
2260 }
2261 break;
2262 case LTTNG_DOMAIN_UST:
2263 nb_events = ust_app_list_events(events);
2264 if (nb_events < 0) {
f73fabfd 2265 ret = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2266 goto error;
2267 }
2268 break;
5cdb6027 2269 case LTTNG_DOMAIN_LOG4J:
3c6a091f 2270 case LTTNG_DOMAIN_JUL:
0e115563 2271 case LTTNG_DOMAIN_PYTHON:
f60140a1 2272 nb_events = agent_list_events(events, domain);
3c6a091f
DG
2273 if (nb_events < 0) {
2274 ret = LTTNG_ERR_UST_LIST_FAIL;
2275 goto error;
2276 }
2277 break;
2f77fc4b 2278 default:
f73fabfd 2279 ret = LTTNG_ERR_UND;
2f77fc4b
DG
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 */
56a37563 2293ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2f77fc4b
DG
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) {
f73fabfd 2303 ret = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2304 goto error;
2305 }
2306 break;
2307 case LTTNG_DOMAIN_KERNEL:
2308 default: /* fall-through */
f73fabfd 2309 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2310 goto error;
2311 }
2312
2313 return nb_fields;
2314
2315error:
2316 /* Return negative value to differentiate return code */
2317 return -ret;
2318}
2319
834978fd
DG
2320ssize_t cmd_list_syscalls(struct lttng_event **events)
2321{
2322 return syscall_table_list(events);
2323}
2324
a5dfbb9d
MD
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,
56a37563 2331 enum lttng_domain_type domain, int32_t **pids)
a5dfbb9d
MD
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
2f77fc4b
DG
2376/*
2377 * Command LTTNG_START_TRACE processed by the client thread.
a9ad0c8f
MD
2378 *
2379 * Called with session mutex held.
2f77fc4b
DG
2380 */
2381int cmd_start_trace(struct ltt_session *session)
2382{
2383 int ret;
cde3e505 2384 unsigned long nb_chan = 0;
2f77fc4b
DG
2385 struct ltt_kernel_session *ksession;
2386 struct ltt_ust_session *usess;
2f77fc4b
DG
2387
2388 assert(session);
2389
2390 /* Ease our life a bit ;) */
2391 ksession = session->kernel_session;
2392 usess = session->ust_session;
2393
8382cf6f
DG
2394 /* Is the session already started? */
2395 if (session->active) {
f73fabfd 2396 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2f77fc4b
DG
2397 goto error;
2398 }
2399
cde3e505
DG
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
2f77fc4b
DG
2415 /* Kernel tracing */
2416 if (ksession != NULL) {
9b6c7ec5
DG
2417 ret = start_kernel_session(ksession, kernel_tracer_fd);
2418 if (ret != LTTNG_OK) {
2f77fc4b
DG
2419 goto error;
2420 }
2f77fc4b
DG
2421 }
2422
2423 /* Flag session that trace should start automatically */
2424 if (usess) {
14fb1ebe
DG
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;
2f77fc4b
DG
2430
2431 ret = ust_app_start_trace_all(usess);
2432 if (ret < 0) {
f73fabfd 2433 ret = LTTNG_ERR_UST_START_FAIL;
2f77fc4b
DG
2434 goto error;
2435 }
2436 }
2437
8382cf6f
DG
2438 /* Flag this after a successful start. */
2439 session->has_been_started = 1;
2440 session->active = 1;
9b6c7ec5 2441
f73fabfd 2442 ret = LTTNG_OK;
2f77fc4b
DG
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
8382cf6f
DG
2464 /* Session is not active. Skip everythong and inform the client. */
2465 if (!session->active) {
f73fabfd 2466 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2f77fc4b
DG
2467 goto error;
2468 }
2469
2f77fc4b 2470 /* Kernel tracer */
14fb1ebe 2471 if (ksession && ksession->active) {
2f77fc4b
DG
2472 DBG("Stop kernel tracing");
2473
566d8970
MD
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) */
2f77fc4b
DG
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
566d8970 2490 /* Flush all buffers after stopping */
2f77fc4b
DG
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
14fb1ebe 2498 ksession->active = 0;
2f77fc4b
DG
2499 }
2500
14fb1ebe
DG
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;
2f77fc4b
DG
2507
2508 ret = ust_app_stop_trace_all(usess);
2509 if (ret < 0) {
f73fabfd 2510 ret = LTTNG_ERR_UST_STOP_FAIL;
2f77fc4b
DG
2511 goto error;
2512 }
2513 }
2514
8382cf6f
DG
2515 /* Flag inactive after a successful stop. */
2516 session->active = 0;
f73fabfd 2517 ret = LTTNG_OK;
2f77fc4b
DG
2518
2519error:
2520 return ret;
2521}
2522
2523/*
2524 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2525 */
bda32d56
JG
2526int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2527 struct lttng_uri *uris)
2f77fc4b
DG
2528{
2529 int ret, i;
2530 struct ltt_kernel_session *ksess = session->kernel_session;
2531 struct ltt_ust_session *usess = session->ust_session;
2f77fc4b
DG
2532
2533 assert(session);
2534 assert(uris);
2535 assert(nb_uri > 0);
2536
8382cf6f
DG
2537 /* Can't set consumer URI if the session is active. */
2538 if (session->active) {
f73fabfd 2539 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2f77fc4b
DG
2540 goto error;
2541 }
2542
bda32d56 2543 /* Set the "global" consumer URIs */
2f77fc4b 2544 for (i = 0; i < nb_uri; i++) {
bda32d56
JG
2545 ret = add_uri_to_consumer(session->consumer,
2546 &uris[i], 0, session->name);
a74934ba 2547 if (ret != LTTNG_OK) {
2f77fc4b
DG
2548 goto error;
2549 }
2f77fc4b
DG
2550 }
2551
bda32d56
JG
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
7ab70fe0
DG
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;
bda32d56
JG
2585 }
2586
2587 if (usess) {
7ab70fe0
DG
2588 usess->output_traces = 1;
2589 }
2590
2f77fc4b 2591 /* All good! */
f73fabfd 2592 ret = LTTNG_OK;
2f77fc4b
DG
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,
ecc48a90 2602 size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer)
2f77fc4b
DG
2603{
2604 int ret;
2f77fc4b
DG
2605 struct ltt_session *session;
2606
2607 assert(name);
2bba9e53 2608 assert(creds);
785d2d0d 2609
2f77fc4b
DG
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) {
f73fabfd 2619 ret = LTTNG_ERR_EXIST_SESS;
2f77fc4b
DG
2620 goto find_error;
2621 }
2622
2623 /* Create tracing session in the registry */
dec56f6c 2624 ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds),
2f77fc4b 2625 LTTNG_SOCK_GET_GID_CRED(creds));
f73fabfd 2626 if (ret != LTTNG_OK) {
2f77fc4b
DG
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
ecc48a90 2640 session->live_timer = live_timer;
2f77fc4b
DG
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) {
f73fabfd 2644 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2645 goto consumer_error;
2646 }
2647
2bba9e53 2648 if (uris) {
bda32d56 2649 ret = cmd_set_consumer_uri(session, nb_uri, uris);
2bba9e53
DG
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);
2f77fc4b
DG
2657 }
2658
2659 session->consumer->enabled = 1;
2660
f73fabfd 2661 return LTTNG_OK;
2f77fc4b
DG
2662
2663consumer_error:
2664 session_destroy(session);
2665session_error:
2666find_error:
2667 return ret;
2668}
2669
27babd3a
DG
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 */
ae58b817 2687 ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
27babd3a
DG
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
2f77fc4b
DG
2736/*
2737 * Command LTTNG_DESTROY_SESSION processed by the client thread.
a9ad0c8f
MD
2738 *
2739 * Called with session lock held.
2f77fc4b
DG
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
2f77fc4b
DG
2785/*
2786 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
2787 */
56a37563
JG
2788int cmd_register_consumer(struct ltt_session *session,
2789 enum lttng_domain_type domain, const char *sock_path,
2790 struct consumer_data *cdata)
2f77fc4b
DG
2791{
2792 int ret, sock;
dd81b457 2793 struct consumer_socket *socket = NULL;
2f77fc4b
DG
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) {
f73fabfd 2808 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
2809 goto error;
2810 }
2811
2812 sock = lttcomm_connect_unix_sock(sock_path);
2813 if (sock < 0) {
f73fabfd 2814 ret = LTTNG_ERR_CONNECT_FAIL;
2f77fc4b
DG
2815 goto error;
2816 }
4ce514c4 2817 cdata->cmd_sock = sock;
2f77fc4b 2818
4ce514c4 2819 socket = consumer_allocate_socket(&cdata->cmd_sock);
2f77fc4b 2820 if (socket == NULL) {
f66c074c
DG
2821 ret = close(sock);
2822 if (ret < 0) {
2823 PERROR("close register consumer");
2824 }
4ce514c4 2825 cdata->cmd_sock = -1;
f73fabfd 2826 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2827 goto error;
2828 }
2829
2830 socket->lock = zmalloc(sizeof(pthread_mutex_t));
2831 if (socket->lock == NULL) {
2832 PERROR("zmalloc pthread mutex");
f73fabfd 2833 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
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 */
f73fabfd 2851 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2852 goto error;
2853 }
2854
dd81b457 2855 return LTTNG_OK;
2f77fc4b
DG
2856
2857error:
dd81b457
DG
2858 if (socket) {
2859 consumer_destroy_socket(socket);
2860 }
2f77fc4b
DG
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;
fefd409b
DG
2872 struct agent *agt;
2873 struct lttng_ht_iter iter;
2f77fc4b
DG
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++;
3c6a091f 2883
e0a74f01 2884 rcu_read_lock();
fefd409b
DG
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 }
3c6a091f 2890 }
e0a74f01 2891 rcu_read_unlock();
2f77fc4b
DG
2892 }
2893
fa64dfb4
JG
2894 if (!nb_dom) {
2895 goto end;
2896 }
2897
2f77fc4b
DG
2898 *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
2899 if (*domains == NULL) {
f73fabfd 2900 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2901 goto error;
2902 }
2903
2904 if (session->kernel_session != NULL) {
2905 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
b5edb9e8
PP
2906
2907 /* Kernel session buffer type is always GLOBAL */
2908 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
2909
2f77fc4b
DG
2910 index++;
2911 }
2912
2913 if (session->ust_session != NULL) {
2914 (*domains)[index].type = LTTNG_DOMAIN_UST;
88c5f0d8 2915 (*domains)[index].buf_type = session->ust_session->buffer_type;
2f77fc4b 2916 index++;
3c6a091f 2917
e0a74f01 2918 rcu_read_lock();
fefd409b
DG
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 }
3c6a091f 2926 }
e0a74f01 2927 rcu_read_unlock();
2f77fc4b 2928 }
fa64dfb4 2929end:
2f77fc4b
DG
2930 return nb_dom;
2931
2932error:
f73fabfd
DG
2933 /* Return negative value to differentiate return code */
2934 return -ret;
2f77fc4b
DG
2935}
2936
2937
2938/*
2939 * Command LTTNG_LIST_CHANNELS processed by the client thread.
2940 */
56a37563
JG
2941ssize_t cmd_list_channels(enum lttng_domain_type domain,
2942 struct ltt_session *session, struct lttng_channel **channels)
2f77fc4b 2943{
53e367f9 2944 ssize_t nb_chan = 0, payload_size = 0, ret;
2f77fc4b
DG
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);
c7d620a2 2952 if (nb_chan <= 0) {
53e367f9
JG
2953 ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND;
2954 goto end;
c7d620a2 2955 }
2f77fc4b
DG
2956 break;
2957 case LTTNG_DOMAIN_UST:
2958 if (session->ust_session != NULL) {
7ffc31a2 2959 rcu_read_lock();
2f77fc4b 2960 nb_chan = lttng_ht_get_count(
7ffc31a2
JG
2961 session->ust_session->domain_global.channels);
2962 rcu_read_unlock();
2f77fc4b
DG
2963 }
2964 DBG3("Number of UST global channels %zd", nb_chan);
ade7ce52 2965 if (nb_chan < 0) {
53e367f9
JG
2966 ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND;
2967 goto end;
c7d620a2 2968 }
2f77fc4b
DG
2969 break;
2970 default:
53e367f9
JG
2971 ret = -LTTNG_ERR_UND;
2972 goto end;
2f77fc4b
DG
2973 }
2974
2975 if (nb_chan > 0) {
53e367f9 2976 const size_t channel_size = sizeof(struct lttng_channel) +
cf0bcb51
JG
2977 sizeof(struct lttng_channel_extended);
2978 struct lttng_channel_extended *channel_exts;
53e367f9
JG
2979
2980 payload_size = nb_chan * channel_size;
2981 *channels = zmalloc(payload_size);
2f77fc4b 2982 if (*channels == NULL) {
53e367f9
JG
2983 ret = -LTTNG_ERR_FATAL;
2984 goto end;
2f77fc4b
DG
2985 }
2986
53e367f9
JG
2987 channel_exts = ((void *) *channels) +
2988 (nb_chan * sizeof(struct lttng_channel));
d449df4a
MD
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 }
53e367f9
JG
2995 } else {
2996 *channels = NULL;
2f77fc4b
DG
2997 }
2998
53e367f9
JG
2999 ret = payload_size;
3000end:
3001 return ret;
2f77fc4b
DG
3002}
3003
3004/*
3005 * Command LTTNG_LIST_EVENTS processed by the client thread.
3006 */
56a37563
JG
3007ssize_t cmd_list_events(enum lttng_domain_type domain,
3008 struct ltt_session *session, char *channel_name,
b4e3ceb9 3009 struct lttng_event **events, size_t *total_size)
2f77fc4b
DG
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,
b4e3ceb9
PP
3018 session->kernel_session, events,
3019 total_size);
2f77fc4b
DG
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,
b4e3ceb9
PP
3026 &session->ust_session->domain_global, events,
3027 total_size);
2f77fc4b
DG
3028 }
3029 break;
3030 }
5cdb6027 3031 case LTTNG_DOMAIN_LOG4J:
3c6a091f 3032 case LTTNG_DOMAIN_JUL:
0e115563 3033 case LTTNG_DOMAIN_PYTHON:
3c6a091f 3034 if (session->ust_session) {
fefd409b
DG
3035 struct lttng_ht_iter iter;
3036 struct agent *agt;
3037
b11feea5 3038 rcu_read_lock();
fefd409b
DG
3039 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3040 &iter.iter, agt, node.node) {
1dfd9906
JG
3041 if (agt->domain == domain) {
3042 nb_event = list_lttng_agent_events(
b4e3ceb9
PP
3043 agt, events,
3044 total_size);
1dfd9906
JG
3045 break;
3046 }
fefd409b 3047 }
b11feea5 3048 rcu_read_unlock();
3c6a091f
DG
3049 }
3050 break;
2f77fc4b 3051 default:
f73fabfd 3052 ret = LTTNG_ERR_UND;
2f77fc4b
DG
3053 goto error;
3054 }
3055
f73fabfd 3056 return nb_event;
2f77fc4b
DG
3057
3058error:
f73fabfd
DG
3059 /* Return negative value to differentiate return code */
3060 return -ret;
2f77fc4b
DG
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,
dec56f6c 3099 sizeof(sessions[i].path), session);
2f77fc4b 3100 } else {
dec56f6c 3101 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
366a9222 3102 session->consumer->dst.session_root_path);
2f77fc4b
DG
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';
8382cf6f 3111 sessions[i].enabled = session->active;
2cbf8fed 3112 sessions[i].snapshot_mode = session->snapshot_mode;
8960e9cd 3113 sessions[i].live_timer_interval = session->live_timer;
2f77fc4b
DG
3114 i++;
3115 }
3116}
3117
806e2684 3118/*
6d805429 3119 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
d3f14b8a 3120 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
806e2684 3121 */
6d805429 3122int cmd_data_pending(struct ltt_session *session)
806e2684
DG
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. */
8382cf6f 3131 if (session->active) {
806e2684
DG
3132 ret = LTTNG_ERR_SESSION_STARTED;
3133 goto error;
3a89d11a
DG
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 */
8382cf6f 3145 if (!session->has_been_started) {
3a89d11a
DG
3146 ret = 0;
3147 goto error;
3148 }
806e2684
DG
3149 }
3150
3151 if (ksess && ksess->consumer) {
6d805429
DG
3152 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
3153 if (ret == 1) {
806e2684
DG
3154 /* Data is still being extracted for the kernel. */
3155 goto error;
3156 }
3157 }
3158
3159 if (usess && usess->consumer) {
6d805429
DG
3160 ret = consumer_is_data_pending(usess->id, usess->consumer);
3161 if (ret == 1) {
806e2684
DG
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 */
6d805429 3168 ret = 0;
806e2684
DG
3169
3170error:
3171 return ret;
3172}
3173
6dc3064a
DG
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 /*
903ef685 3191 * Can't create an output if the session is not set in no-output mode.
6dc3064a
DG
3192 */
3193 if (session->output_traces) {
903ef685 3194 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
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
6dc3064a
DG
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;
eb240553 3246 struct snapshot_output *sout = NULL;
6dc3064a
DG
3247
3248 assert(session);
3249 assert(output);
3250
6dc3064a
DG
3251 rcu_read_lock();
3252
3253 /*
d3f14b8a
MD
3254 * Permission denied to create an output if the session is not
3255 * set in no output mode.
6dc3064a
DG
3256 */
3257 if (session->output_traces) {
903ef685 3258 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
3259 goto error;
3260 }
3261
eb240553
DG
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 }
6dc3064a
DG
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;
b223ca94 3296 struct lttng_snapshot_output *list = NULL;
6dc3064a
DG
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 /*
d3f14b8a
MD
3306 * Permission denied to create an output if the session is not
3307 * set in no output mode.
6dc3064a
DG
3308 */
3309 if (session->output_traces) {
903ef685
JG
3310 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
3311 goto end;
6dc3064a
DG
3312 }
3313
3314 if (session->snapshot.nb_output == 0) {
3315 ret = 0;
903ef685 3316 goto end;
6dc3064a
DG
3317 }
3318
3319 list = zmalloc(session->snapshot.nb_output * sizeof(*list));
3320 if (!list) {
b223ca94 3321 ret = -LTTNG_ERR_NOMEM;
903ef685 3322 goto end;
6dc3064a
DG
3323 }
3324
3325 /* Copy list from session to the new list object. */
b223ca94 3326 rcu_read_lock();
6dc3064a
DG
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;
6ce22875
MD
3332 if (lttng_strncpy(list[idx].name, output->name,
3333 sizeof(list[idx].name))) {
3334 ret = -LTTNG_ERR_INVALID;
903ef685 3335 goto error;
6ce22875 3336 }
6dc3064a 3337 if (output->consumer->type == CONSUMER_DST_LOCAL) {
6ce22875 3338 if (lttng_strncpy(list[idx].ctrl_url,
366a9222 3339 output->consumer->dst.session_root_path,
6ce22875
MD
3340 sizeof(list[idx].ctrl_url))) {
3341 ret = -LTTNG_ERR_INVALID;