Clean-up: sessiond command: fix include style
[lttng-tools.git] / src / bin / lttng-sessiond / cmd.c
CommitLineData
2f77fc4b 1/*
ab5be9fa
MJ
2 * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
2f77fc4b 4 *
ab5be9fa 5 * SPDX-License-Identifier: GPL-2.0-only
2f77fc4b 6 *
2f77fc4b
DG
7 */
8
6c1c0768 9#define _LGPL_SOURCE
2f77fc4b 10#include <assert.h>
6dc3064a 11#include <inttypes.h>
2f77fc4b
DG
12#include <urcu/list.h>
13#include <urcu/uatomic.h>
a503e1ef 14#include <sys/stat.h>
d2956687 15#include <stdio.h>
2f77fc4b
DG
16
17#include <common/defaults.h>
18#include <common/common.h>
19#include <common/sessiond-comm/sessiond-comm.h>
20#include <common/relayd/relayd.h>
10a50311 21#include <common/utils.h>
f5436bfc 22#include <common/compat/string.h>
93ec662e 23#include <common/kernel-ctl/kernel-ctl.h>
b0880ae5
JG
24#include <common/dynamic-buffer.h>
25#include <common/buffer-view.h>
9e620ea7
JG
26#include <common/payload.h>
27#include <common/payload-view.h>
82b69413 28#include <common/trace-chunk.h>
3e3665b8 29#include <lttng/location-internal.h>
b0880ae5
JG
30#include <lttng/trigger/trigger-internal.h>
31#include <lttng/condition/condition.h>
32#include <lttng/action/action.h>
6e21424e 33#include <lttng/channel.h>
b0880ae5 34#include <lttng/channel-internal.h>
5c408ad8 35#include <lttng/rotate-internal.h>
17dd1232 36#include <lttng/location-internal.h>
b178f53e 37#include <lttng/session-internal.h>
3c02e545 38#include <lttng/userspace-probe-internal.h>
b178f53e 39#include <lttng/session-descriptor-internal.h>
47aa1ca6
JG
40#include <lttng/lttng-error.h>
41#include <lttng/tracker.h>
9f449915 42#include <common/string-utils/string-utils.h>
2f77fc4b
DG
43
44#include "channel.h"
45#include "consumer.h"
46#include "event.h"
8782cc74 47#include "health-sessiond.h"
2f77fc4b
DG
48#include "kernel.h"
49#include "kernel-consumer.h"
50#include "lttng-sessiond.h"
51#include "utils.h"
0dbc2034 52#include "lttng-syscall.h"
7c1d2758 53#include "agent.h"
93ec662e 54#include "buffer-registry.h"
b0880ae5
JG
55#include "notification-thread.h"
56#include "notification-thread-commands.h"
5c408ad8
JD
57#include "rotate.h"
58#include "rotation-thread.h"
8e319828 59#include "timer.h"
f28f9e44 60#include "agent-thread.h"
47aa1ca6 61#include "tracker.h"
2f77fc4b
DG
62
63#include "cmd.h"
64
a503e1ef
JG
65/* Sleep for 100ms between each check for the shm path's deletion. */
66#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
67
3e3665b8
JG
68struct cmd_destroy_session_reply_context {
69 int reply_sock_fd;
70 bool implicit_rotation_on_destroy;
3285a971
JG
71 /*
72 * Indicates whether or not an error occurred while launching the
73 * destruction of a session.
74 */
75 enum lttng_error_code destruction_status;
3e3665b8
JG
76};
77
a503e1ef
JG
78static enum lttng_error_code wait_on_path(void *path);
79
80/*
81 * Command completion handler that is used by the destroy command
82 * when a session that has a non-default shm_path is being destroyed.
83 *
84 * See comment in cmd_destroy_session() for the rationale.
85 */
86static struct destroy_completion_handler {
87 struct cmd_completion_handler handler;
88 char shm_path[member_sizeof(struct ltt_session, shm_path)];
89} destroy_completion_handler = {
90 .handler = {
91 .run = wait_on_path,
92 .data = destroy_completion_handler.shm_path
93 },
94 .shm_path = { 0 },
95};
96
97static struct cmd_completion_handler *current_completion_handler;
98
2f77fc4b
DG
99/*
100 * Used to keep a unique index for each relayd socket created where this value
101 * is associated with streams on the consumer so it can match the right relayd
d88aee68
DG
102 * to send to. It must be accessed with the relayd_net_seq_idx_lock
103 * held.
2f77fc4b 104 */
d88aee68
DG
105static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
106static uint64_t relayd_net_seq_idx;
2f77fc4b 107
7076b56e
JG
108static int validate_ust_event_name(const char *);
109static int cmd_enable_event_internal(struct ltt_session *session,
df4f5a87 110 const struct lttng_domain *domain,
7076b56e
JG
111 char *channel_name, struct lttng_event *event,
112 char *filter_expression,
113 struct lttng_filter_bytecode *filter,
114 struct lttng_event_exclusion *exclusion,
115 int wpipe);
116
2f77fc4b
DG
117/*
118 * Create a session path used by list_lttng_sessions for the case that the
119 * session consumer is on the network.
120 */
121static int build_network_session_path(char *dst, size_t size,
122 struct ltt_session *session)
123{
124 int ret, kdata_port, udata_port;
125 struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
126 char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
127
128 assert(session);
129 assert(dst);
130
131 memset(tmp_urls, 0, sizeof(tmp_urls));
132 memset(tmp_uurl, 0, sizeof(tmp_uurl));
133
134 kdata_port = udata_port = DEFAULT_NETWORK_DATA_PORT;
135
136 if (session->kernel_session && session->kernel_session->consumer) {
137 kuri = &session->kernel_session->consumer->dst.net.control;
138 kdata_port = session->kernel_session->consumer->dst.net.data.port;
139 }
140
141 if (session->ust_session && session->ust_session->consumer) {
142 uuri = &session->ust_session->consumer->dst.net.control;
143 udata_port = session->ust_session->consumer->dst.net.data.port;
144 }
145
146 if (uuri == NULL && kuri == NULL) {
147 uri = &session->consumer->dst.net.control;
148 kdata_port = session->consumer->dst.net.data.port;
149 } else if (kuri && uuri) {
150 ret = uri_compare(kuri, uuri);
151 if (ret) {
152 /* Not Equal */
153 uri = kuri;
154 /* Build uuri URL string */
155 ret = uri_to_str_url(uuri, tmp_uurl, sizeof(tmp_uurl));
156 if (ret < 0) {
157 goto error;
158 }
159 } else {
160 uri = kuri;
161 }
162 } else if (kuri && uuri == NULL) {
163 uri = kuri;
164 } else if (uuri && kuri == NULL) {
165 uri = uuri;
166 }
167
168 ret = uri_to_str_url(uri, tmp_urls, sizeof(tmp_urls));
169 if (ret < 0) {
170 goto error;
171 }
172
9aa9f900
DG
173 /*
174 * Do we have a UST url set. If yes, this means we have both kernel and UST
175 * to print.
176 */
9d035200 177 if (*tmp_uurl != '\0') {
2f77fc4b
DG
178 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
179 tmp_urls, kdata_port, tmp_uurl, udata_port);
180 } else {
9aa9f900 181 int dport;
bef08707 182 if (kuri || (!kuri && !uuri)) {
9aa9f900
DG
183 dport = kdata_port;
184 } else {
185 /* No kernel URI, use the UST port. */
186 dport = udata_port;
187 }
188 ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, dport);
2f77fc4b
DG
189 }
190
191error:
192 return ret;
193}
194
fb83fe64
JD
195/*
196 * Get run-time attributes if the session has been started (discarded events,
197 * lost packets).
198 */
199static int get_kernel_runtime_stats(struct ltt_session *session,
200 struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
201 uint64_t *lost_packets)
202{
203 int ret;
204
205 if (!session->has_been_started) {
206 ret = 0;
207 *discarded_events = 0;
208 *lost_packets = 0;
209 goto end;
210 }
211
e1f3997a 212 ret = consumer_get_discarded_events(session->id, kchan->key,
fb83fe64
JD
213 session->kernel_session->consumer,
214 discarded_events);
215 if (ret < 0) {
216 goto end;
217 }
218
e1f3997a 219 ret = consumer_get_lost_packets(session->id, kchan->key,
fb83fe64
JD
220 session->kernel_session->consumer,
221 lost_packets);
222 if (ret < 0) {
223 goto end;
224 }
225
226end:
227 return ret;
228}
229
230/*
231 * Get run-time attributes if the session has been started (discarded events,
232 * lost packets).
233 */
234static int get_ust_runtime_stats(struct ltt_session *session,
235 struct ltt_ust_channel *uchan, uint64_t *discarded_events,
236 uint64_t *lost_packets)
237{
238 int ret;
239 struct ltt_ust_session *usess;
240
a91c5803
JG
241 if (!discarded_events || !lost_packets) {
242 ret = -1;
243 goto end;
244 }
245
fb83fe64 246 usess = session->ust_session;
a905c624
JG
247 assert(discarded_events);
248 assert(lost_packets);
fb83fe64
JD
249
250 if (!usess || !session->has_been_started) {
251 *discarded_events = 0;
252 *lost_packets = 0;
253 ret = 0;
254 goto end;
255 }
256
257 if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
258 ret = ust_app_uid_get_channel_runtime_stats(usess->id,
259 &usess->buffer_reg_uid_list,
260 usess->consumer, uchan->id,
261 uchan->attr.overwrite,
262 discarded_events,
263 lost_packets);
264 } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
265 ret = ust_app_pid_get_channel_runtime_stats(usess,
266 uchan, usess->consumer,
267 uchan->attr.overwrite,
268 discarded_events,
269 lost_packets);
270 if (ret < 0) {
271 goto end;
272 }
273 *discarded_events += uchan->per_pid_closed_app_discarded;
274 *lost_packets += uchan->per_pid_closed_app_lost;
275 } else {
276 ERR("Unsupported buffer type");
967bc289 277 assert(0);
fb83fe64
JD
278 ret = -1;
279 goto end;
280 }
281
282end:
283 return ret;
284}
285
2f77fc4b
DG
286/*
287 * Fill lttng_channel array of all channels.
288 */
d449df4a 289static ssize_t list_lttng_channels(enum lttng_domain_type domain,
fb83fe64 290 struct ltt_session *session, struct lttng_channel *channels,
cf0bcb51 291 struct lttng_channel_extended *chan_exts)
2f77fc4b 292{
d449df4a 293 int i = 0, ret = 0;
2f77fc4b
DG
294 struct ltt_kernel_channel *kchan;
295
296 DBG("Listing channels for session %s", session->name);
297
298 switch (domain) {
299 case LTTNG_DOMAIN_KERNEL:
300 /* Kernel channels */
301 if (session->kernel_session != NULL) {
302 cds_list_for_each_entry(kchan,
303 &session->kernel_session->channel_list.head, list) {
fb83fe64 304 uint64_t discarded_events, lost_packets;
cf0bcb51
JG
305 struct lttng_channel_extended *extended;
306
307 extended = (struct lttng_channel_extended *)
308 kchan->channel->attr.extended.ptr;
fb83fe64
JD
309
310 ret = get_kernel_runtime_stats(session, kchan,
311 &discarded_events, &lost_packets);
312 if (ret < 0) {
313 goto end;
314 }
2f77fc4b
DG
315 /* Copy lttng_channel struct to array */
316 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
317 channels[i].enabled = kchan->enabled;
fb83fe64
JD
318 chan_exts[i].discarded_events =
319 discarded_events;
320 chan_exts[i].lost_packets = lost_packets;
cf0bcb51
JG
321 chan_exts[i].monitor_timer_interval =
322 extended->monitor_timer_interval;
491d1539 323 chan_exts[i].blocking_timeout = 0;
2f77fc4b
DG
324 i++;
325 }
326 }
327 break;
328 case LTTNG_DOMAIN_UST:
329 {
330 struct lttng_ht_iter iter;
331 struct ltt_ust_channel *uchan;
332
e7fe706f 333 rcu_read_lock();
2f77fc4b
DG
334 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
335 &iter.iter, uchan, node.node) {
a91c5803 336 uint64_t discarded_events = 0, lost_packets = 0;
fb83fe64 337
8ee609c8
MD
338 if (lttng_strncpy(channels[i].name, uchan->name,
339 LTTNG_SYMBOL_NAME_LEN)) {
340 break;
341 }
2f77fc4b
DG
342 channels[i].attr.overwrite = uchan->attr.overwrite;
343 channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
344 channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
345 channels[i].attr.switch_timer_interval =
346 uchan->attr.switch_timer_interval;
347 channels[i].attr.read_timer_interval =
348 uchan->attr.read_timer_interval;
349 channels[i].enabled = uchan->enabled;
2f785fe7
DG
350 channels[i].attr.tracefile_size = uchan->tracefile_size;
351 channels[i].attr.tracefile_count = uchan->tracefile_count;
5e4435a4
JG
352
353 /*
354 * Map enum lttng_ust_output to enum lttng_event_output.
355 */
2f77fc4b
DG
356 switch (uchan->attr.output) {
357 case LTTNG_UST_MMAP:
2f77fc4b
DG
358 channels[i].attr.output = LTTNG_EVENT_MMAP;
359 break;
5e4435a4
JG
360 default:
361 /*
362 * LTTNG_UST_MMAP is the only supported UST
363 * output mode.
364 */
365 assert(0);
366 break;
2f77fc4b 367 }
fb83fe64 368
d449df4a
MD
369 chan_exts[i].monitor_timer_interval =
370 uchan->monitor_timer_interval;
491d1539
MD
371 chan_exts[i].blocking_timeout =
372 uchan->attr.u.s.blocking_timeout;
d449df4a 373
fb83fe64
JD
374 ret = get_ust_runtime_stats(session, uchan,
375 &discarded_events, &lost_packets);
376 if (ret < 0) {
377 break;
378 }
379 chan_exts[i].discarded_events = discarded_events;
380 chan_exts[i].lost_packets = lost_packets;
2f77fc4b
DG
381 i++;
382 }
e7fe706f 383 rcu_read_unlock();
2f77fc4b
DG
384 break;
385 }
386 default:
387 break;
388 }
fb83fe64
JD
389
390end:
d449df4a
MD
391 if (ret < 0) {
392 return -LTTNG_ERR_FATAL;
393 } else {
394 return LTTNG_OK;
395 }
2f77fc4b
DG
396}
397
3c02e545
FD
398static int append_extended_info(const char *filter_expression,
399 struct lttng_event_exclusion *exclusion,
400 struct lttng_userspace_probe_location *probe_location,
e368fb43 401 struct lttng_payload *payload)
b4e3ceb9 402{
3c02e545 403 int ret = 0;
b4e3ceb9 404 size_t filter_len = 0;
795d57ce 405 size_t nb_exclusions = 0;
3c02e545 406 size_t userspace_probe_location_len = 0;
e368fb43
JG
407 struct lttcomm_event_extended_header extended_header = {};
408 struct lttcomm_event_extended_header *p_extended_header;
409 const size_t original_payload_size = payload->buffer.size;
410
411 ret = lttng_dynamic_buffer_append(&payload->buffer, &extended_header,
412 sizeof(extended_header));
413 if (ret) {
414 goto end;
415 }
b4e3ceb9
PP
416
417 if (filter_expression) {
418 filter_len = strlen(filter_expression) + 1;
e368fb43
JG
419 ret = lttng_dynamic_buffer_append(&payload->buffer,
420 filter_expression, filter_len);
421 if (ret) {
422 goto end;
423 }
b4e3ceb9
PP
424 }
425
795d57ce 426 if (exclusion) {
e368fb43
JG
427 const size_t len = exclusion->count * LTTNG_SYMBOL_NAME_LEN;
428
795d57ce 429 nb_exclusions = exclusion->count;
e368fb43
JG
430
431 ret = lttng_dynamic_buffer_append(
432 &payload->buffer, &exclusion->names, len);
433 if (ret) {
434 goto end;
435 }
795d57ce
PP
436 }
437
3c02e545 438 if (probe_location) {
e368fb43
JG
439 const size_t size_before_probe = payload->buffer.size;
440
3c02e545 441 ret = lttng_userspace_probe_location_serialize(probe_location,
e368fb43 442 payload);
3c02e545
FD
443 if (ret < 0) {
444 ret = -1;
445 goto end;
446 }
795d57ce 447
e368fb43
JG
448 userspace_probe_location_len =
449 payload->buffer.size - size_before_probe;
795d57ce
PP
450 }
451
e368fb43
JG
452 /* Set header fields */
453 p_extended_header = (struct lttcomm_event_extended_header *)
454 (payload->buffer.data + original_payload_size);
795d57ce 455
e368fb43
JG
456 p_extended_header->filter_len = filter_len;
457 p_extended_header->nb_exclusions = nb_exclusions;
458 p_extended_header->userspace_probe_location_len =
459 userspace_probe_location_len;
3c02e545 460
3c02e545
FD
461 ret = 0;
462end:
463 return ret;
b4e3ceb9
PP
464}
465
3c6a091f 466/*
022d91ba 467 * Create a list of agent domain events.
3c6a091f
DG
468 *
469 * Return number of events in list on success or else a negative value.
470 */
022d91ba 471static int list_lttng_agent_events(struct agent *agt,
e368fb43 472 struct lttng_payload *payload)
3c6a091f 473{
e368fb43
JG
474 int nb_events = 0, ret = 0;
475 const struct agent_event *agent_event;
3c6a091f
DG
476 struct lttng_ht_iter iter;
477
022d91ba 478 assert(agt);
3c6a091f 479
022d91ba 480 DBG3("Listing agent events");
3c6a091f 481
e5bbf678 482 rcu_read_lock();
e368fb43
JG
483 cds_lfht_for_each_entry (
484 agt->events->ht, &iter.iter, agent_event, node.node) {
485 struct lttng_event event = {
486 .enabled = agent_event->enabled,
487 .loglevel = agent_event->loglevel_value,
488 .loglevel_type = agent_event->loglevel_type,
489 };
490
491 strncpy(event.name, agent_event->name, sizeof(event.name));
492 event.name[sizeof(event.name) - 1] = '\0';
493
494 ret = lttng_dynamic_buffer_append(
495 &payload->buffer, &event, sizeof(event));
3c02e545 496 if (ret) {
e368fb43
JG
497 ERR("Failed to append event to payload");
498 ret = -LTTNG_ERR_NOMEM;
499 goto end;
3c02e545 500 }
b4e3ceb9 501
e368fb43 502 nb_events++;
3c6a091f
DG
503 }
504
e368fb43
JG
505 cds_lfht_for_each_entry (
506 agt->events->ht, &iter.iter, agent_event, node.node) {
507 /* Append extended info. */
508 ret = append_extended_info(agent_event->filter_expression, NULL,
509 NULL, payload);
3c02e545 510 if (ret) {
e368fb43
JG
511 ERR("Failed to append extended event info to payload");
512 ret = -LTTNG_ERR_NOMEM;
513 goto end;
3c02e545 514 }
3c6a091f 515 }
3c6a091f 516
e368fb43 517 ret = nb_events;
47e52862 518end:
3c02e545 519 rcu_read_unlock();
3c6a091f
DG
520 return ret;
521}
522
2f77fc4b
DG
523/*
524 * Create a list of ust global domain events.
525 */
526static int list_lttng_ust_global_events(char *channel_name,
b4e3ceb9 527 struct ltt_ust_domain_global *ust_global,
e368fb43 528 struct lttng_payload *payload)
2f77fc4b 529{
e368fb43
JG
530 int ret = 0;
531 unsigned int nb_events = 0;
2f77fc4b 532 struct lttng_ht_iter iter;
e368fb43
JG
533 const struct lttng_ht_node_str *node;
534 const struct ltt_ust_channel *uchan;
535 const struct ltt_ust_event *uevent;
2f77fc4b
DG
536
537 DBG("Listing UST global events for channel %s", channel_name);
538
539 rcu_read_lock();
540
e368fb43 541 lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter);
2f77fc4b
DG
542 node = lttng_ht_iter_get_node_str(&iter);
543 if (node == NULL) {
f73fabfd 544 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
d31d3e8c 545 goto end;
2f77fc4b
DG
546 }
547
548 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
549
e368fb43 550 DBG3("Listing UST global events");
2f77fc4b 551
b4e3ceb9 552 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
e368fb43
JG
553 struct lttng_event event = {};
554
b4e3ceb9 555 if (uevent->internal) {
b4e3ceb9
PP
556 continue;
557 }
558
e368fb43
JG
559 strncpy(event.name, uevent->attr.name, sizeof(event.name));
560 event.name[sizeof(event.name) - 1] = '\0';
2f77fc4b 561
e368fb43 562 event.enabled = uevent->enabled;
2f77fc4b
DG
563
564 switch (uevent->attr.instrumentation) {
565 case LTTNG_UST_TRACEPOINT:
e368fb43 566 event.type = LTTNG_EVENT_TRACEPOINT;
2f77fc4b
DG
567 break;
568 case LTTNG_UST_PROBE:
e368fb43 569 event.type = LTTNG_EVENT_PROBE;
2f77fc4b
DG
570 break;
571 case LTTNG_UST_FUNCTION:
e368fb43 572 event.type = LTTNG_EVENT_FUNCTION;
2f77fc4b
DG
573 break;
574 }
575
e368fb43 576 event.loglevel = uevent->attr.loglevel;
2f77fc4b
DG
577 switch (uevent->attr.loglevel_type) {
578 case LTTNG_UST_LOGLEVEL_ALL:
e368fb43 579 event.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
2f77fc4b
DG
580 break;
581 case LTTNG_UST_LOGLEVEL_RANGE:
e368fb43 582 event.loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
2f77fc4b
DG
583 break;
584 case LTTNG_UST_LOGLEVEL_SINGLE:
e368fb43 585 event.loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
2f77fc4b
DG
586 break;
587 }
e368fb43 588
2f77fc4b 589 if (uevent->filter) {
e368fb43 590 event.filter = 1;
2f77fc4b 591 }
e368fb43 592
4634f12e 593 if (uevent->exclusion) {
e368fb43
JG
594 event.exclusion = 1;
595 }
596
597 ret = lttng_dynamic_buffer_append(&payload->buffer, &event, sizeof(event));
598 if (ret) {
599 ERR("Failed to append event to payload");
600 ret = -LTTNG_ERR_NOMEM;
601 goto end;
4634f12e 602 }
b4e3ceb9 603
e368fb43
JG
604 nb_events++;
605 }
606
607 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
608 /* Append extended info. */
3c02e545 609 ret = append_extended_info(uevent->filter_expression,
e368fb43 610 uevent->exclusion, NULL, payload);
3c02e545 611 if (ret) {
e368fb43 612 ERR("Failed to append extended event info to payload");
3c02e545
FD
613 ret = -LTTNG_ERR_FATAL;
614 goto end;
615 }
2f77fc4b
DG
616 }
617
e368fb43 618 ret = nb_events;
d31d3e8c 619end:
2f77fc4b
DG
620 rcu_read_unlock();
621 return ret;
622}
623
624/*
625 * Fill lttng_event array of all kernel events in the channel.
626 */
627static int list_lttng_kernel_events(char *channel_name,
b4e3ceb9 628 struct ltt_kernel_session *kernel_session,
e368fb43 629 struct lttng_payload *payload)
2f77fc4b 630{
e368fb43 631 int ret;
2f77fc4b 632 unsigned int nb_event;
e368fb43
JG
633 const struct ltt_kernel_event *kevent;
634 const struct ltt_kernel_channel *kchan;
2f77fc4b
DG
635
636 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
637 if (kchan == NULL) {
f73fabfd 638 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
2f77fc4b
DG
639 goto error;
640 }
641
642 nb_event = kchan->event_count;
643
644 DBG("Listing events for channel %s", kchan->channel->name);
645
e368fb43
JG
646 /* Kernel channels */
647 cds_list_for_each_entry(kevent, &kchan->events_list.head , list) {
648 struct lttng_event event = {};
2f77fc4b 649
e368fb43
JG
650 strncpy(event.name, kevent->event->name, sizeof(event.name));
651 event.name[sizeof(event.name) - 1] = '\0';
652 event.enabled = kevent->enabled;
653 event.filter = (unsigned char) !!kevent->filter_expression;
b4e3ceb9 654
e368fb43 655 switch (kevent->event->instrumentation) {
2f77fc4b 656 case LTTNG_KERNEL_TRACEPOINT:
e368fb43 657 event.type = LTTNG_EVENT_TRACEPOINT;
2f77fc4b 658 break;
2f77fc4b 659 case LTTNG_KERNEL_KRETPROBE:
e368fb43
JG
660 event.type = LTTNG_EVENT_FUNCTION;
661 memcpy(&event.attr.probe, &kevent->event->u.kprobe,
1896972b
DG
662 sizeof(struct lttng_kernel_kprobe));
663 break;
664 case LTTNG_KERNEL_KPROBE:
e368fb43
JG
665 event.type = LTTNG_EVENT_PROBE;
666 memcpy(&event.attr.probe, &kevent->event->u.kprobe,
2f77fc4b
DG
667 sizeof(struct lttng_kernel_kprobe));
668 break;
b955b4d4 669 case LTTNG_KERNEL_UPROBE:
e368fb43 670 event.type = LTTNG_EVENT_USERSPACE_PROBE;
b955b4d4 671 break;
2f77fc4b 672 case LTTNG_KERNEL_FUNCTION:
e368fb43
JG
673 event.type = LTTNG_EVENT_FUNCTION;
674 memcpy(&event.attr.ftrace, &kevent->event->u.ftrace,
2f77fc4b
DG
675 sizeof(struct lttng_kernel_function));
676 break;
677 case LTTNG_KERNEL_NOOP:
e368fb43 678 event.type = LTTNG_EVENT_NOOP;
2f77fc4b
DG
679 break;
680 case LTTNG_KERNEL_SYSCALL:
e368fb43 681 event.type = LTTNG_EVENT_SYSCALL;
2f77fc4b
DG
682 break;
683 case LTTNG_KERNEL_ALL:
1ab8c2ad
FD
684 /* fall-through. */
685 default:
2f77fc4b
DG
686 assert(0);
687 break;
688 }
b4e3ceb9 689
e368fb43
JG
690 ret = lttng_dynamic_buffer_append(
691 &payload->buffer, &event, sizeof(event));
692 if (ret) {
693 ERR("Failed to append event to payload");
694 ret = -LTTNG_ERR_NOMEM;
695 goto end;
696 }
697 }
698
699 cds_list_for_each_entry(kevent, &kchan->events_list.head , list) {
700 /* Append extended info. */
701 ret = append_extended_info(kevent->filter_expression, NULL,
702 kevent->userspace_probe_location, payload);
3c02e545
FD
703 if (ret) {
704 DBG("Error appending extended info message");
705 ret = -LTTNG_ERR_FATAL;
706 goto error;
707 }
2f77fc4b
DG
708 }
709
db906c12 710end:
2f77fc4b 711 return nb_event;
2f77fc4b 712error:
6314496f 713 return ret;
2f77fc4b
DG
714}
715
716/*
717 * Add URI so the consumer output object. Set the correct path depending on the
718 * domain adding the default trace directory.
719 */
b178f53e
JG
720static enum lttng_error_code add_uri_to_consumer(
721 const struct ltt_session *session,
722 struct consumer_output *consumer,
723 struct lttng_uri *uri, enum lttng_domain_type domain)
2f77fc4b 724{
b178f53e
JG
725 int ret;
726 enum lttng_error_code ret_code = LTTNG_OK;
2f77fc4b
DG
727
728 assert(uri);
729
730 if (consumer == NULL) {
731 DBG("No consumer detected. Don't add URI. Stopping.");
b178f53e 732 ret_code = LTTNG_ERR_NO_CONSUMER;
2f77fc4b
DG
733 goto error;
734 }
735
736 switch (domain) {
737 case LTTNG_DOMAIN_KERNEL:
b178f53e
JG
738 ret = lttng_strncpy(consumer->domain_subdir,
739 DEFAULT_KERNEL_TRACE_DIR,
740 sizeof(consumer->domain_subdir));
2f77fc4b
DG
741 break;
742 case LTTNG_DOMAIN_UST:
b178f53e
JG
743 ret = lttng_strncpy(consumer->domain_subdir,
744 DEFAULT_UST_TRACE_DIR,
745 sizeof(consumer->domain_subdir));
2f77fc4b
DG
746 break;
747 default:
748 /*
b178f53e
JG
749 * This case is possible is we try to add the URI to the global
750 * tracing session consumer object which in this case there is
751 * no subdir.
2f77fc4b 752 */
b178f53e
JG
753 memset(consumer->domain_subdir, 0,
754 sizeof(consumer->domain_subdir));
755 ret = 0;
756 }
757 if (ret) {
758 ERR("Failed to initialize consumer output domain subdirectory");
759 ret_code = LTTNG_ERR_FATAL;
760 goto error;
2f77fc4b
DG
761 }
762
763 switch (uri->dtype) {
764 case LTTNG_DST_IPV4:
765 case LTTNG_DST_IPV6:
766 DBG2("Setting network URI to consumer");
767
df75acac
DG
768 if (consumer->type == CONSUMER_DST_NET) {
769 if ((uri->stype == LTTNG_STREAM_CONTROL &&
785d2d0d
DG
770 consumer->dst.net.control_isset) ||
771 (uri->stype == LTTNG_STREAM_DATA &&
772 consumer->dst.net.data_isset)) {
b178f53e 773 ret_code = LTTNG_ERR_URL_EXIST;
df75acac
DG
774 goto error;
775 }
776 } else {
b178f53e 777 memset(&consumer->dst, 0, sizeof(consumer->dst));
785d2d0d
DG
778 }
779
2f77fc4b 780 /* Set URI into consumer output object */
b178f53e 781 ret = consumer_set_network_uri(session, consumer, uri);
2f77fc4b 782 if (ret < 0) {
b178f53e 783 ret_code = -ret;
2f77fc4b
DG
784 goto error;
785 } else if (ret == 1) {
786 /*
787 * URI was the same in the consumer so we do not append the subdir
788 * again so to not duplicate output dir.
789 */
b178f53e 790 ret_code = LTTNG_OK;
2f77fc4b
DG
791 goto error;
792 }
2f77fc4b
DG
793 break;
794 case LTTNG_DST_PATH:
b178f53e
JG
795 if (*uri->dst.path != '/' || strstr(uri->dst.path, "../")) {
796 ret_code = LTTNG_ERR_INVALID;
9ac05d92
MD
797 goto error;
798 }
b178f53e
JG
799 DBG2("Setting trace directory path from URI to %s",
800 uri->dst.path);
801 memset(&consumer->dst, 0, sizeof(consumer->dst));
802
803 ret = lttng_strncpy(consumer->dst.session_root_path,
804 uri->dst.path,
805 sizeof(consumer->dst.session_root_path));
4df41cad
JG
806 if (ret) {
807 ret_code = LTTNG_ERR_FATAL;
808 goto error;
809 }
2f77fc4b
DG
810 consumer->type = CONSUMER_DST_LOCAL;
811 break;
812 }
813
b178f53e 814 ret_code = LTTNG_OK;
2f77fc4b 815error:
b178f53e 816 return ret_code;
2f77fc4b
DG
817}
818
819/*
820 * Init tracing by creating trace directory and sending fds kernel consumer.
821 */
822static int init_kernel_tracing(struct ltt_kernel_session *session)
823{
824 int ret = 0;
825 struct lttng_ht_iter iter;
826 struct consumer_socket *socket;
827
828 assert(session);
829
e7fe706f
DG
830 rcu_read_lock();
831
2f77fc4b
DG
832 if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
833 cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
834 socket, node.node) {
2f77fc4b 835 pthread_mutex_lock(socket->lock);
f50f23d9 836 ret = kernel_consumer_send_session(socket, session);
2f77fc4b
DG
837 pthread_mutex_unlock(socket->lock);
838 if (ret < 0) {
f73fabfd 839 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
840 goto error;
841 }
842 }
843 }
844
845error:
e7fe706f 846 rcu_read_unlock();
2f77fc4b
DG
847 return ret;
848}
849
850/*
851 * Create a socket to the relayd using the URI.
852 *
853 * On success, the relayd_sock pointer is set to the created socket.
9a654598 854 * Else, it remains untouched and an LTTng error code is returned.
2f77fc4b 855 */
9a654598 856static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
b31610f2
JD
857 struct lttcomm_relayd_sock **relayd_sock,
858 struct consumer_output *consumer)
2f77fc4b
DG
859{
860 int ret;
9a654598 861 enum lttng_error_code status = LTTNG_OK;
6151a90f 862 struct lttcomm_relayd_sock *rsock;
2f77fc4b 863
6151a90f
JD
864 rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
865 RELAYD_VERSION_COMM_MINOR);
866 if (!rsock) {
9a654598 867 status = LTTNG_ERR_FATAL;
2f77fc4b
DG
868 goto error;
869 }
870
ffe60014
DG
871 /*
872 * Connect to relayd so we can proceed with a session creation. This call
873 * can possibly block for an arbitrary amount of time to set the health
874 * state to be in poll execution.
875 */
876 health_poll_entry();
6151a90f 877 ret = relayd_connect(rsock);
ffe60014 878 health_poll_exit();
2f77fc4b
DG
879 if (ret < 0) {
880 ERR("Unable to reach lttng-relayd");
9a654598 881 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
2f77fc4b
DG
882 goto free_sock;
883 }
884
885 /* Create socket for control stream. */
886 if (uri->stype == LTTNG_STREAM_CONTROL) {
eacb7b6f
MD
887 uint64_t result_flags;
888
2f77fc4b
DG
889 DBG3("Creating relayd stream socket from URI");
890
891 /* Check relayd version */
6151a90f 892 ret = relayd_version_check(rsock);
67d5aa28 893 if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) {
9a654598 894 status = LTTNG_ERR_RELAYD_VERSION_FAIL;
67d5aa28
JD
895 goto close_sock;
896 } else if (ret < 0) {
897 ERR("Unable to reach lttng-relayd");
9a654598 898 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
2f77fc4b
DG
899 goto close_sock;
900 }
b31610f2
JD
901 consumer->relay_major_version = rsock->major;
902 consumer->relay_minor_version = rsock->minor;
eacb7b6f
MD
903 ret = relayd_get_configuration(rsock, 0,
904 &result_flags);
905 if (ret < 0) {
906 ERR("Unable to get relayd configuration");
907 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
908 goto close_sock;
909 }
910 if (result_flags & LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED) {
911 consumer->relay_allows_clear = true;
912 }
2f77fc4b
DG
913 } else if (uri->stype == LTTNG_STREAM_DATA) {
914 DBG3("Creating relayd data socket from URI");
915 } else {
916 /* Command is not valid */
917 ERR("Relayd invalid stream type: %d", uri->stype);
9a654598 918 status = LTTNG_ERR_INVALID;
2f77fc4b
DG
919 goto close_sock;
920 }
921
6151a90f 922 *relayd_sock = rsock;
2f77fc4b 923
9a654598 924 return status;
2f77fc4b
DG
925
926close_sock:
6151a90f
JD
927 /* The returned value is not useful since we are on an error path. */
928 (void) relayd_close(rsock);
2f77fc4b 929free_sock:
6151a90f 930 free(rsock);
2f77fc4b 931error:
9a654598 932 return status;
2f77fc4b
DG
933}
934
935/*
936 * Connect to the relayd using URI and send the socket to the right consumer.
43fade62
JG
937 *
938 * The consumer socket lock must be held by the caller.
9a654598
JG
939 *
940 * Returns LTTNG_OK on success or an LTTng error code on failure.
2f77fc4b 941 */
9a654598
JG
942static enum lttng_error_code send_consumer_relayd_socket(
943 unsigned int session_id,
3044f922 944 struct lttng_uri *relayd_uri,
56a37563 945 struct consumer_output *consumer,
d3e2ba59 946 struct consumer_socket *consumer_sock,
fb9a95c4 947 const char *session_name, const char *hostname,
6fa5fe7c 948 const char *base_path, int session_live_timer,
0e270a1e 949 const uint64_t *current_chunk_id,
46ef2188
MD
950 time_t session_creation_time,
951 bool session_name_contains_creation_time)
2f77fc4b
DG
952{
953 int ret;
6151a90f 954 struct lttcomm_relayd_sock *rsock = NULL;
9a654598 955 enum lttng_error_code status;
2f77fc4b 956
ffe60014 957 /* Connect to relayd and make version check if uri is the control. */
9a654598
JG
958 status = create_connect_relayd(relayd_uri, &rsock, consumer);
959 if (status != LTTNG_OK) {
9e218353 960 goto relayd_comm_error;
ffe60014 961 }
6151a90f 962 assert(rsock);
ffe60014 963
2f77fc4b 964 /* Set the network sequence index if not set. */
d88aee68
DG
965 if (consumer->net_seq_index == (uint64_t) -1ULL) {
966 pthread_mutex_lock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
967 /*
968 * Increment net_seq_idx because we are about to transfer the
969 * new relayd socket to the consumer.
d88aee68 970 * Assign unique key so the consumer can match streams.
2f77fc4b 971 */
d88aee68
DG
972 consumer->net_seq_index = ++relayd_net_seq_idx;
973 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
974 }
975
2f77fc4b 976 /* Send relayd socket to consumer. */
6151a90f 977 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
d3e2ba59 978 relayd_uri->stype, session_id,
6fa5fe7c
MD
979 session_name, hostname, base_path,
980 session_live_timer, current_chunk_id,
46ef2188 981 session_creation_time, session_name_contains_creation_time);
2f77fc4b 982 if (ret < 0) {
9a654598 983 status = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2f77fc4b
DG
984 goto close_sock;
985 }
986
c890b720
DG
987 /* Flag that the corresponding socket was sent. */
988 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
ffe60014 989 consumer_sock->control_sock_sent = 1;
c890b720 990 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
ffe60014 991 consumer_sock->data_sock_sent = 1;
c890b720
DG
992 }
993
2f77fc4b
DG
994 /*
995 * Close socket which was dup on the consumer side. The session daemon does
996 * NOT keep track of the relayd socket(s) once transfer to the consumer.
997 */
998
999close_sock:
9a654598 1000 if (status != LTTNG_OK) {
ffe60014 1001 /*
d9078d0c
DG
1002 * The consumer output for this session should not be used anymore
1003 * since the relayd connection failed thus making any tracing or/and
1004 * streaming not usable.
ffe60014 1005 */
d9078d0c 1006 consumer->enabled = 0;
ffe60014 1007 }
9e218353
JR
1008 (void) relayd_close(rsock);
1009 free(rsock);
1010
1011relayd_comm_error:
9a654598 1012 return status;
2f77fc4b
DG
1013}
1014
1015/*
1016 * Send both relayd sockets to a specific consumer and domain. This is a
1017 * helper function to facilitate sending the information to the consumer for a
1018 * session.
43fade62
JG
1019 *
1020 * The consumer socket lock must be held by the caller.
9a654598
JG
1021 *
1022 * Returns LTTNG_OK, or an LTTng error code on failure.
2f77fc4b 1023 */
9a654598
JG
1024static enum lttng_error_code send_consumer_relayd_sockets(
1025 enum lttng_domain_type domain,
56a37563 1026 unsigned int session_id, struct consumer_output *consumer,
fb9a95c4 1027 struct consumer_socket *sock, const char *session_name,
6fa5fe7c 1028 const char *hostname, const char *base_path, int session_live_timer,
46ef2188
MD
1029 const uint64_t *current_chunk_id, time_t session_creation_time,
1030 bool session_name_contains_creation_time)
2f77fc4b 1031{
9a654598 1032 enum lttng_error_code status = LTTNG_OK;
2f77fc4b 1033
2f77fc4b 1034 assert(consumer);
6dc3064a 1035 assert(sock);
2f77fc4b 1036
2f77fc4b 1037 /* Sending control relayd socket. */
ffe60014 1038 if (!sock->control_sock_sent) {
9a654598 1039 status = send_consumer_relayd_socket(session_id,
d3e2ba59 1040 &consumer->dst.net.control, consumer, sock,
6fa5fe7c 1041 session_name, hostname, base_path, session_live_timer,
46ef2188
MD
1042 current_chunk_id, session_creation_time,
1043 session_name_contains_creation_time);
9a654598 1044 if (status != LTTNG_OK) {
c890b720
DG
1045 goto error;
1046 }
2f77fc4b
DG
1047 }
1048
1049 /* Sending data relayd socket. */
ffe60014 1050 if (!sock->data_sock_sent) {
9a654598 1051 status = send_consumer_relayd_socket(session_id,
d3e2ba59 1052 &consumer->dst.net.data, consumer, sock,
6fa5fe7c 1053 session_name, hostname, base_path, session_live_timer,
46ef2188
MD
1054 current_chunk_id, session_creation_time,
1055 session_name_contains_creation_time);
9a654598 1056 if (status != LTTNG_OK) {
c890b720
DG
1057 goto error;
1058 }
2f77fc4b
DG
1059 }
1060
2f77fc4b 1061error:
9a654598 1062 return status;
2f77fc4b
DG
1063}
1064
1065/*
1066 * Setup relayd connections for a tracing session. First creates the socket to
1067 * the relayd and send them to the right domain consumer. Consumer type MUST be
1068 * network.
1069 */
ffe60014 1070int cmd_setup_relayd(struct ltt_session *session)
2f77fc4b 1071{
f73fabfd 1072 int ret = LTTNG_OK;
2f77fc4b
DG
1073 struct ltt_ust_session *usess;
1074 struct ltt_kernel_session *ksess;
1075 struct consumer_socket *socket;
1076 struct lttng_ht_iter iter;
0e270a1e 1077 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
2f77fc4b 1078
0e270a1e 1079 assert(session);
2f77fc4b
DG
1080
1081 usess = session->ust_session;
1082 ksess = session->kernel_session;
1083
785d2d0d 1084 DBG("Setting relayd for session %s", session->name);
2f77fc4b 1085
aa997ea3 1086 rcu_read_lock();
1e791a74
JG
1087 if (session->current_trace_chunk) {
1088 enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
1089 session->current_trace_chunk, &current_chunk_id.value);
1090
1091 if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
1092 current_chunk_id.is_set = true;
1093 } else {
1094 ERR("Failed to get current trace chunk id");
1095 ret = LTTNG_ERR_UNK;
1096 goto error;
1097 }
1098 }
1099
2f77fc4b
DG
1100 if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
1101 && usess->consumer->enabled) {
1102 /* For each consumer socket, send relayd sockets */
1103 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
1104 socket, node.node) {
2f77fc4b 1105 pthread_mutex_lock(socket->lock);
6dc3064a 1106 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
d3e2ba59
JD
1107 usess->consumer, socket,
1108 session->name, session->hostname,
6fa5fe7c 1109 session->base_path,
1e791a74 1110 session->live_timer,
db1da059 1111 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
1112 session->creation_time,
1113 session->name_contains_creation_time);
2f77fc4b 1114 pthread_mutex_unlock(socket->lock);
f73fabfd 1115 if (ret != LTTNG_OK) {
2f77fc4b
DG
1116 goto error;
1117 }
6dc3064a
DG
1118 /* Session is now ready for network streaming. */
1119 session->net_handle = 1;
2f77fc4b 1120 }
b31610f2
JD
1121 session->consumer->relay_major_version =
1122 usess->consumer->relay_major_version;
1123 session->consumer->relay_minor_version =
1124 usess->consumer->relay_minor_version;
eacb7b6f
MD
1125 session->consumer->relay_allows_clear =
1126 usess->consumer->relay_allows_clear;
2f77fc4b
DG
1127 }
1128
1129 if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
1130 && ksess->consumer->enabled) {
1131 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1132 socket, node.node) {
2f77fc4b 1133 pthread_mutex_lock(socket->lock);
6dc3064a 1134 ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
d3e2ba59
JD
1135 ksess->consumer, socket,
1136 session->name, session->hostname,
6fa5fe7c 1137 session->base_path,
1e791a74 1138 session->live_timer,
db1da059 1139 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
1140 session->creation_time,
1141 session->name_contains_creation_time);
2f77fc4b 1142 pthread_mutex_unlock(socket->lock);
f73fabfd 1143 if (ret != LTTNG_OK) {
2f77fc4b
DG
1144 goto error;
1145 }
6dc3064a
DG
1146 /* Session is now ready for network streaming. */
1147 session->net_handle = 1;
2f77fc4b 1148 }
b31610f2
JD
1149 session->consumer->relay_major_version =
1150 ksess->consumer->relay_major_version;
1151 session->consumer->relay_minor_version =
1152 ksess->consumer->relay_minor_version;
eacb7b6f
MD
1153 session->consumer->relay_allows_clear =
1154 ksess->consumer->relay_allows_clear;
2f77fc4b
DG
1155 }
1156
1157error:
e7fe706f 1158 rcu_read_unlock();
2f77fc4b
DG
1159 return ret;
1160}
1161
9b6c7ec5
DG
1162/*
1163 * Start a kernel session by opening all necessary streams.
1164 */
4dbe1875 1165int start_kernel_session(struct ltt_kernel_session *ksess)
9b6c7ec5
DG
1166{
1167 int ret;
1168 struct ltt_kernel_channel *kchan;
1169
1170 /* Open kernel metadata */
07b86b52 1171 if (ksess->metadata == NULL && ksess->output_traces) {
9b6c7ec5
DG
1172 ret = kernel_open_metadata(ksess);
1173 if (ret < 0) {
1174 ret = LTTNG_ERR_KERN_META_FAIL;
1175 goto error;
1176 }
1177 }
1178
1179 /* Open kernel metadata stream */
07b86b52 1180 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
9b6c7ec5
DG
1181 ret = kernel_open_metadata_stream(ksess);
1182 if (ret < 0) {
1183 ERR("Kernel create metadata stream failed");
1184 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1185 goto error;
1186 }
1187 }
1188
1189 /* For each channel */
1190 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1191 if (kchan->stream_count == 0) {
1192 ret = kernel_open_channel_stream(kchan);
1193 if (ret < 0) {
1194 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1195 goto error;
1196 }
1197 /* Update the stream global counter */
1198 ksess->stream_count_global += ret;
1199 }
1200 }
1201
1202 /* Setup kernel consumer socket and send fds to it */
1203 ret = init_kernel_tracing(ksess);
e43c41c5 1204 if (ret != 0) {
9b6c7ec5
DG
1205 ret = LTTNG_ERR_KERN_START_FAIL;
1206 goto error;
1207 }
1208
1209 /* This start the kernel tracing */
1210 ret = kernel_start_session(ksess);
1211 if (ret < 0) {
1212 ret = LTTNG_ERR_KERN_START_FAIL;
1213 goto error;
1214 }
1215
1216 /* Quiescent wait after starting trace */
7d268848 1217 kernel_wait_quiescent();
9b6c7ec5 1218
14fb1ebe 1219 ksess->active = 1;
9b6c7ec5
DG
1220
1221 ret = LTTNG_OK;
1222
1223error:
1224 return ret;
1225}
1226
4dbe1875
MD
1227int stop_kernel_session(struct ltt_kernel_session *ksess)
1228{
1229 struct ltt_kernel_channel *kchan;
1230 bool error_occurred = false;
1231 int ret;
1232
1233 if (!ksess || !ksess->active) {
1234 return LTTNG_OK;
1235 }
1236 DBG("Stopping kernel tracing");
1237
1238 ret = kernel_stop_session(ksess);
1239 if (ret < 0) {
1240 ret = LTTNG_ERR_KERN_STOP_FAIL;
1241 goto error;
1242 }
1243
1244 kernel_wait_quiescent();
1245
1246 /* Flush metadata after stopping (if exists) */
1247 if (ksess->metadata_stream_fd >= 0) {
1248 ret = kernel_metadata_flush_buffer(ksess->metadata_stream_fd);
1249 if (ret < 0) {
1250 ERR("Kernel metadata flush failed");
1251 error_occurred = true;
1252 }
1253 }
1254
1255 /* Flush all buffers after stopping */
1256 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1257 ret = kernel_flush_buffer(kchan);
1258 if (ret < 0) {
1259 ERR("Kernel flush buffer error");
1260 error_occurred = true;
1261 }
1262 }
1263
1264 ksess->active = 0;
1265 if (error_occurred) {
1266 ret = LTTNG_ERR_UNK;
1267 } else {
1268 ret = LTTNG_OK;
1269 }
1270error:
1271 return ret;
1272}
1273
2f77fc4b
DG
1274/*
1275 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1276 */
56a37563
JG
1277int cmd_disable_channel(struct ltt_session *session,
1278 enum lttng_domain_type domain, char *channel_name)
2f77fc4b
DG
1279{
1280 int ret;
1281 struct ltt_ust_session *usess;
1282
1283 usess = session->ust_session;
1284
2223c96f
DG
1285 rcu_read_lock();
1286
2f77fc4b
DG
1287 switch (domain) {
1288 case LTTNG_DOMAIN_KERNEL:
1289 {
1290 ret = channel_kernel_disable(session->kernel_session,
1291 channel_name);
f73fabfd 1292 if (ret != LTTNG_OK) {
2f77fc4b
DG
1293 goto error;
1294 }
1295
7d268848 1296 kernel_wait_quiescent();
2f77fc4b
DG
1297 break;
1298 }
1299 case LTTNG_DOMAIN_UST:
1300 {
1301 struct ltt_ust_channel *uchan;
1302 struct lttng_ht *chan_ht;
1303
1304 chan_ht = usess->domain_global.channels;
1305
1306 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
1307 if (uchan == NULL) {
f73fabfd 1308 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
2f77fc4b
DG
1309 goto error;
1310 }
1311
7972aab2 1312 ret = channel_ust_disable(usess, uchan);
f73fabfd 1313 if (ret != LTTNG_OK) {
2f77fc4b
DG
1314 goto error;
1315 }
1316 break;
1317 }
2f77fc4b 1318 default:
f73fabfd 1319 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1320 goto error;
1321 }
1322
f73fabfd 1323 ret = LTTNG_OK;
2f77fc4b
DG
1324
1325error:
2223c96f 1326 rcu_read_unlock();
2f77fc4b
DG
1327 return ret;
1328}
1329
1330/*
1331 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1332 *
1333 * The wpipe arguments is used as a notifier for the kernel thread.
1334 */
1335int cmd_enable_channel(struct ltt_session *session,
df4f5a87 1336 const struct lttng_domain *domain, const struct lttng_channel *_attr, int wpipe)
2f77fc4b
DG
1337{
1338 int ret;
1339 struct ltt_ust_session *usess = session->ust_session;
1340 struct lttng_ht *chan_ht;
1f345e94 1341 size_t len;
df4f5a87 1342 struct lttng_channel attr;
2f77fc4b
DG
1343
1344 assert(session);
df4f5a87 1345 assert(_attr);
7972aab2 1346 assert(domain);
2f77fc4b 1347
df4f5a87
JG
1348 attr = *_attr;
1349 len = lttng_strnlen(attr.name, sizeof(attr.name));
1f345e94
PP
1350
1351 /* Validate channel name */
df4f5a87
JG
1352 if (attr.name[0] == '.' ||
1353 memchr(attr.name, '/', len) != NULL) {
1f345e94
PP
1354 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1355 goto end;
1356 }
1357
df4f5a87 1358 DBG("Enabling channel %s for session %s", attr.name, session->name);
2f77fc4b 1359
03b4fdcf
DG
1360 rcu_read_lock();
1361
ecc48a90
JD
1362 /*
1363 * Don't try to enable a channel if the session has been started at
1364 * some point in time before. The tracer does not allow it.
1365 */
8382cf6f 1366 if (session->has_been_started) {
ecc48a90
JD
1367 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1368 goto error;
1369 }
1370
1371 /*
1372 * If the session is a live session, remove the switch timer, the
1373 * live timer does the same thing but sends also synchronisation
1374 * beacons for inactive streams.
1375 */
1376 if (session->live_timer > 0) {
df4f5a87
JG
1377 attr.attr.live_timer_interval = session->live_timer;
1378 attr.attr.switch_timer_interval = 0;
ecc48a90
JD
1379 }
1380
6e21424e
JR
1381 /* Check for feature support */
1382 switch (domain->type) {
1383 case LTTNG_DOMAIN_KERNEL:
1384 {
7d268848 1385 if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) {
6e21424e
JR
1386 /* Sampling position of buffer is not supported */
1387 WARN("Kernel tracer does not support buffer monitoring. "
1388 "Setting the monitor interval timer to 0 "
1389 "(disabled) for channel '%s' of session '%s'",
df4f5a87
JG
1390 attr.name, session->name);
1391 lttng_channel_set_monitor_timer_interval(&attr, 0);
6e21424e
JR
1392 }
1393 break;
1394 }
1395 case LTTNG_DOMAIN_UST:
f28f9e44 1396 break;
6e21424e
JR
1397 case LTTNG_DOMAIN_JUL:
1398 case LTTNG_DOMAIN_LOG4J:
1399 case LTTNG_DOMAIN_PYTHON:
f28f9e44
JG
1400 if (!agent_tracing_is_enabled()) {
1401 DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
1402 ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
1403 goto error;
1404 }
6e21424e
JR
1405 break;
1406 default:
1407 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
1408 goto error;
1409 }
1410
7972aab2 1411 switch (domain->type) {
2f77fc4b
DG
1412 case LTTNG_DOMAIN_KERNEL:
1413 {
1414 struct ltt_kernel_channel *kchan;
1415
df4f5a87 1416 kchan = trace_kernel_get_channel_by_name(attr.name,
2f77fc4b
DG
1417 session->kernel_session);
1418 if (kchan == NULL) {
54213acc
JG
1419 if (session->snapshot.nb_output > 0 ||
1420 session->snapshot_mode) {
1421 /* Enforce mmap output for snapshot sessions. */
df4f5a87 1422 attr.attr.output = LTTNG_EVENT_MMAP;
54213acc 1423 }
df4f5a87
JG
1424 ret = channel_kernel_create(session->kernel_session, &attr, wpipe);
1425 if (attr.name[0] != '\0') {
85076754
MD
1426 session->kernel_session->has_non_default_channel = 1;
1427 }
2f77fc4b
DG
1428 } else {
1429 ret = channel_kernel_enable(session->kernel_session, kchan);
1430 }
1431
f73fabfd 1432 if (ret != LTTNG_OK) {
2f77fc4b
DG
1433 goto error;
1434 }
1435
7d268848 1436 kernel_wait_quiescent();
2f77fc4b
DG
1437 break;
1438 }
1439 case LTTNG_DOMAIN_UST:
9232818f
JG
1440 case LTTNG_DOMAIN_JUL:
1441 case LTTNG_DOMAIN_LOG4J:
1442 case LTTNG_DOMAIN_PYTHON:
2f77fc4b
DG
1443 {
1444 struct ltt_ust_channel *uchan;
1445
9232818f
JG
1446 /*
1447 * FIXME
1448 *
1449 * Current agent implementation limitations force us to allow
1450 * only one channel at once in "agent" subdomains. Each
1451 * subdomain has a default channel name which must be strictly
1452 * adhered to.
1453 */
1454 if (domain->type == LTTNG_DOMAIN_JUL) {
df4f5a87 1455 if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME,
9232818f
JG
1456 LTTNG_SYMBOL_NAME_LEN)) {
1457 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1458 goto error;
1459 }
1460 } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
df4f5a87 1461 if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME,
9232818f
JG
1462 LTTNG_SYMBOL_NAME_LEN)) {
1463 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1464 goto error;
1465 }
1466 } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
df4f5a87 1467 if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME,
9232818f
JG
1468 LTTNG_SYMBOL_NAME_LEN)) {
1469 ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
1470 goto error;
1471 }
1472 }
1473
2f77fc4b
DG
1474 chan_ht = usess->domain_global.channels;
1475
df4f5a87 1476 uchan = trace_ust_find_channel_by_name(chan_ht, attr.name);
2f77fc4b 1477 if (uchan == NULL) {
df4f5a87
JG
1478 ret = channel_ust_create(usess, &attr, domain->buf_type);
1479 if (attr.name[0] != '\0') {
85076754
MD
1480 usess->has_non_default_channel = 1;
1481 }
2f77fc4b 1482 } else {
7972aab2 1483 ret = channel_ust_enable(usess, uchan);
2f77fc4b
DG
1484 }
1485 break;
1486 }
2f77fc4b 1487 default:
f73fabfd 1488 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1489 goto error;
1490 }
1491
df4f5a87 1492 if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) {
54213acc
JG
1493 session->has_non_mmap_channel = true;
1494 }
2f77fc4b 1495error:
2223c96f 1496 rcu_read_unlock();
1f345e94 1497end:
2f77fc4b
DG
1498 return ret;
1499}
1500
159b042f
JG
1501enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy(
1502 struct ltt_session *session,
1503 enum lttng_domain_type domain,
1504 enum lttng_process_attr process_attr,
1505 enum lttng_tracking_policy *policy)
1506{
1507 enum lttng_error_code ret_code = LTTNG_OK;
1508 const struct process_attr_tracker *tracker;
1509
1510 switch (domain) {
1511 case LTTNG_DOMAIN_KERNEL:
1512 if (!session->kernel_session) {
1513 ret_code = LTTNG_ERR_INVALID;
1514 goto end;
1515 }
1516 tracker = kernel_get_process_attr_tracker(
1517 session->kernel_session, process_attr);
1518 break;
1519 case LTTNG_DOMAIN_UST:
1520 if (!session->ust_session) {
1521 ret_code = LTTNG_ERR_INVALID;
1522 goto end;
1523 }
1524 tracker = trace_ust_get_process_attr_tracker(
1525 session->ust_session, process_attr);
1526 break;
1527 default:
1528 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1529 goto end;
1530 }
1531 if (tracker) {
1532 *policy = process_attr_tracker_get_tracking_policy(tracker);
1533 } else {
1534 ret_code = LTTNG_ERR_INVALID;
1535 }
1536end:
1537 return ret_code;
1538}
1539
1540enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy(
1541 struct ltt_session *session,
1542 enum lttng_domain_type domain,
1543 enum lttng_process_attr process_attr,
1544 enum lttng_tracking_policy policy)
1545{
1546 enum lttng_error_code ret_code = LTTNG_OK;
1547
1548 switch (policy) {
1549 case LTTNG_TRACKING_POLICY_INCLUDE_SET:
1550 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
1551 case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
1552 break;
1553 default:
1554 ret_code = LTTNG_ERR_INVALID;
1555 goto end;
1556 }
1557
1558 switch (domain) {
1559 case LTTNG_DOMAIN_KERNEL:
1560 if (!session->kernel_session) {
1561 ret_code = LTTNG_ERR_INVALID;
1562 goto end;
1563 }
1564 ret_code = kernel_process_attr_tracker_set_tracking_policy(
1565 session->kernel_session, process_attr, policy);
1566 break;
1567 case LTTNG_DOMAIN_UST:
1568 if (!session->ust_session) {
1569 ret_code = LTTNG_ERR_INVALID;
1570 goto end;
1571 }
1572 ret_code = trace_ust_process_attr_tracker_set_tracking_policy(
1573 session->ust_session, process_attr, policy);
1574 break;
1575 default:
1576 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1577 break;
1578 }
1579end:
1580 return ret_code;
1581}
1582
1583enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value(
1584 struct ltt_session *session,
1585 enum lttng_domain_type domain,
1586 enum lttng_process_attr process_attr,
1587 const struct process_attr_value *value)
1588{
1589 enum lttng_error_code ret_code = LTTNG_OK;
1590
1591 switch (domain) {
1592 case LTTNG_DOMAIN_KERNEL:
1593 if (!session->kernel_session) {
1594 ret_code = LTTNG_ERR_INVALID;
1595 goto end;
1596 }
1597 ret_code = kernel_process_attr_tracker_inclusion_set_add_value(
1598 session->kernel_session, process_attr, value);
1599 break;
1600 case LTTNG_DOMAIN_UST:
1601 if (!session->ust_session) {
1602 ret_code = LTTNG_ERR_INVALID;
1603 goto end;
1604 }
1605 ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value(
1606 session->ust_session, process_attr, value);
1607 break;
1608 default:
1609 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1610 break;
1611 }
1612end:
1613 return ret_code;
1614}
1615
1616enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value(
1617 struct ltt_session *session,
1618 enum lttng_domain_type domain,
1619 enum lttng_process_attr process_attr,
1620 const struct process_attr_value *value)
1621{
1622 enum lttng_error_code ret_code = LTTNG_OK;
1623
1624 switch (domain) {
1625 case LTTNG_DOMAIN_KERNEL:
1626 if (!session->kernel_session) {
1627 ret_code = LTTNG_ERR_INVALID;
1628 goto end;
1629 }
1630 ret_code = kernel_process_attr_tracker_inclusion_set_remove_value(
1631 session->kernel_session, process_attr, value);
1632 break;
1633 case LTTNG_DOMAIN_UST:
1634 if (!session->ust_session) {
1635 ret_code = LTTNG_ERR_INVALID;
1636 goto end;
1637 }
1638 ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value(
1639 session->ust_session, process_attr, value);
1640 break;
1641 default:
1642 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1643 break;
1644 }
1645end:
1646 return ret_code;
1647}
1648
1649enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set(
1650 struct ltt_session *session,
1651 enum lttng_domain_type domain,
1652 enum lttng_process_attr process_attr,
1653 struct lttng_process_attr_values **values)
1654{
1655 enum lttng_error_code ret_code = LTTNG_OK;
1656 const struct process_attr_tracker *tracker;
1657 enum process_attr_tracker_status status;
1658
1659 switch (domain) {
1660 case LTTNG_DOMAIN_KERNEL:
1661 if (!session->kernel_session) {
1662 ret_code = LTTNG_ERR_INVALID;
1663 goto end;
1664 }
1665 tracker = kernel_get_process_attr_tracker(
1666 session->kernel_session, process_attr);
1667 break;
1668 case LTTNG_DOMAIN_UST:
1669 if (!session->ust_session) {
1670 ret_code = LTTNG_ERR_INVALID;
1671 goto end;
1672 }
1673 tracker = trace_ust_get_process_attr_tracker(
1674 session->ust_session, process_attr);
1675 break;
1676 default:
1677 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1678 goto end;
1679 }
1680
1681 if (!tracker) {
1682 ret_code = LTTNG_ERR_INVALID;
1683 goto end;
1684 }
1685
1686 status = process_attr_tracker_get_inclusion_set(tracker, values);
1687 switch (status) {
1688 case PROCESS_ATTR_TRACKER_STATUS_OK:
1689 ret_code = LTTNG_OK;
1690 break;
1691 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
1692 ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
1693 break;
1694 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
1695 ret_code = LTTNG_ERR_NOMEM;
1696 break;
1697 default:
1698 ret_code = LTTNG_ERR_UNK;
1699 break;
1700 }
1701
1702end:
1703 return ret_code;
1704}
1705
2f77fc4b
DG
1706/*
1707 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1708 */
56a37563 1709int cmd_disable_event(struct ltt_session *session,
df4f5a87
JG
1710 enum lttng_domain_type domain, const char *channel_name,
1711 const struct lttng_event *event)
2f77fc4b
DG
1712{
1713 int ret;
df4f5a87 1714 const char *event_name;
6e911cad 1715
18a720cd
MD
1716 DBG("Disable event command for event \'%s\'", event->name);
1717
6e911cad
MD
1718 event_name = event->name;
1719
9b7431cf
JG
1720 /* Error out on unhandled search criteria */
1721 if (event->loglevel_type || event->loglevel != -1 || event->enabled
6e911cad 1722 || event->pid || event->filter || event->exclusion) {
7076b56e
JG
1723 ret = LTTNG_ERR_UNK;
1724 goto error;
6e911cad 1725 }
2f77fc4b 1726
2223c96f
DG
1727 rcu_read_lock();
1728
2f77fc4b
DG
1729 switch (domain) {
1730 case LTTNG_DOMAIN_KERNEL:
1731 {
1732 struct ltt_kernel_channel *kchan;
1733 struct ltt_kernel_session *ksess;
1734
1735 ksess = session->kernel_session;
1736
85076754
MD
1737 /*
1738 * If a non-default channel has been created in the
1739 * session, explicitely require that -c chan_name needs
1740 * to be provided.
1741 */
1742 if (ksess->has_non_default_channel && channel_name[0] == '\0') {
1743 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
7076b56e 1744 goto error_unlock;
85076754
MD
1745 }
1746
2f77fc4b
DG
1747 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1748 if (kchan == NULL) {
f73fabfd 1749 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
7076b56e 1750 goto error_unlock;
2f77fc4b
DG
1751 }
1752
6e911cad
MD
1753 switch (event->type) {
1754 case LTTNG_EVENT_ALL:
9550ee81 1755 case LTTNG_EVENT_TRACEPOINT:
d0ae4ea8 1756 case LTTNG_EVENT_SYSCALL:
9550ee81
JR
1757 case LTTNG_EVENT_PROBE:
1758 case LTTNG_EVENT_FUNCTION:
1759 case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
1760 if (event_name[0] == '\0') {
1761 ret = event_kernel_disable_event(kchan,
1762 NULL, event->type);
29c62722 1763 } else {
d0ae4ea8 1764 ret = event_kernel_disable_event(kchan,
9550ee81 1765 event_name, event->type);
29c62722 1766 }
6e911cad 1767 if (ret != LTTNG_OK) {
7076b56e 1768 goto error_unlock;
6e911cad
MD
1769 }
1770 break;
6e911cad
MD
1771 default:
1772 ret = LTTNG_ERR_UNK;
7076b56e 1773 goto error_unlock;
2f77fc4b
DG
1774 }
1775
7d268848 1776 kernel_wait_quiescent();
2f77fc4b
DG
1777 break;
1778 }
1779 case LTTNG_DOMAIN_UST:
1780 {
1781 struct ltt_ust_channel *uchan;
1782 struct ltt_ust_session *usess;
1783
1784 usess = session->ust_session;
1785
7076b56e
JG
1786 if (validate_ust_event_name(event_name)) {
1787 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1788 goto error_unlock;
1789 }
1790
85076754
MD
1791 /*
1792 * If a non-default channel has been created in the
9550ee81 1793 * session, explicitly require that -c chan_name needs
85076754
MD
1794 * to be provided.
1795 */
1796 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1797 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
7076b56e 1798 goto error_unlock;
85076754
MD
1799 }
1800
2f77fc4b
DG
1801 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1802 channel_name);
1803 if (uchan == NULL) {
f73fabfd 1804 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
7076b56e 1805 goto error_unlock;
2f77fc4b
DG
1806 }
1807
6e911cad
MD
1808 switch (event->type) {
1809 case LTTNG_EVENT_ALL:
b3639870
JR
1810 /*
1811 * An empty event name means that everything
1812 * should be disabled.
1813 */
1814 if (event->name[0] == '\0') {
1815 ret = event_ust_disable_all_tracepoints(usess, uchan);
77d536b2
JR
1816 } else {
1817 ret = event_ust_disable_tracepoint(usess, uchan,
1818 event_name);
1819 }
6e911cad 1820 if (ret != LTTNG_OK) {
7076b56e 1821 goto error_unlock;
6e911cad
MD
1822 }
1823 break;
1824 default:
1825 ret = LTTNG_ERR_UNK;
7076b56e 1826 goto error_unlock;
2f77fc4b
DG
1827 }
1828
1829 DBG3("Disable UST event %s in channel %s completed", event_name,
1830 channel_name);
1831 break;
1832 }
5cdb6027 1833 case LTTNG_DOMAIN_LOG4J:
f20baf8e 1834 case LTTNG_DOMAIN_JUL:
0e115563 1835 case LTTNG_DOMAIN_PYTHON:
f20baf8e 1836 {
fefd409b 1837 struct agent *agt;
f20baf8e
DG
1838 struct ltt_ust_session *usess = session->ust_session;
1839
1840 assert(usess);
1841
6e911cad
MD
1842 switch (event->type) {
1843 case LTTNG_EVENT_ALL:
1844 break;
1845 default:
1846 ret = LTTNG_ERR_UNK;
7076b56e 1847 goto error_unlock;
6e911cad
MD
1848 }
1849
5cdb6027 1850 agt = trace_ust_find_agent(usess, domain);
fefd409b
DG
1851 if (!agt) {
1852 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
7076b56e 1853 goto error_unlock;
fefd409b 1854 }
b3639870
JR
1855 /*
1856 * An empty event name means that everything
1857 * should be disabled.
1858 */
1859 if (event->name[0] == '\0') {
18a720cd
MD
1860 ret = event_agent_disable_all(usess, agt);
1861 } else {
1862 ret = event_agent_disable(usess, agt, event_name);
1863 }
f20baf8e 1864 if (ret != LTTNG_OK) {
7076b56e 1865 goto error_unlock;
f20baf8e
DG
1866 }
1867
1868 break;
1869 }
2f77fc4b 1870 default:
f73fabfd 1871 ret = LTTNG_ERR_UND;
7076b56e 1872 goto error_unlock;
2f77fc4b
DG
1873 }
1874
f73fabfd 1875 ret = LTTNG_OK;
2f77fc4b 1876
7076b56e 1877error_unlock:
2223c96f 1878 rcu_read_unlock();
7076b56e 1879error:
2f77fc4b
DG
1880 return ret;
1881}
1882
2f77fc4b
DG
1883/*
1884 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1885 */
56a37563 1886int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
df4f5a87 1887 char *channel_name, const struct lttng_event_context *ctx, int kwpipe)
2f77fc4b 1888{
d5979e4a 1889 int ret, chan_kern_created = 0, chan_ust_created = 0;
bdf64013
JG
1890 char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
1891
9a699f7b
JR
1892 /*
1893 * Don't try to add a context if the session has been started at
1894 * some point in time before. The tracer does not allow it and would
1895 * result in a corrupted trace.
1896 */
1897 if (session->has_been_started) {
1898 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1899 goto end;
1900 }
1901
bdf64013
JG
1902 if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
1903 app_ctx_provider_name = ctx->u.app_ctx.provider_name;
1904 app_ctx_name = ctx->u.app_ctx.ctx_name;
1905 }
2f77fc4b
DG
1906
1907 switch (domain) {
1908 case LTTNG_DOMAIN_KERNEL:
979e618e
DG
1909 assert(session->kernel_session);
1910
1911 if (session->kernel_session->channel_count == 0) {
1912 /* Create default channel */
1913 ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
1914 if (ret != LTTNG_OK) {
1915 goto error;
1916 }
d5979e4a 1917 chan_kern_created = 1;
979e618e 1918 }
2f77fc4b 1919 /* Add kernel context to kernel tracer */
601d5acf 1920 ret = context_kernel_add(session->kernel_session, ctx, channel_name);
f73fabfd 1921 if (ret != LTTNG_OK) {
2f77fc4b
DG
1922 goto error;
1923 }
1924 break;
bdf64013
JG
1925 case LTTNG_DOMAIN_JUL:
1926 case LTTNG_DOMAIN_LOG4J:
1927 {
1928 /*
1929 * Validate channel name.
1930 * If no channel name is given and the domain is JUL or LOG4J,
1931 * set it to the appropriate domain-specific channel name. If
1932 * a name is provided but does not match the expexted channel
1933 * name, return an error.
1934 */
1935 if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
1936 strcmp(channel_name,
1937 DEFAULT_JUL_CHANNEL_NAME)) {
1938 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1939 goto error;
1940 } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
1941 strcmp(channel_name,
1942 DEFAULT_LOG4J_CHANNEL_NAME)) {
1943 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1944 goto error;
1945 }
a93b3916 1946 /* break is _not_ missing here. */
bdf64013 1947 }
2f77fc4b
DG
1948 case LTTNG_DOMAIN_UST:
1949 {
1950 struct ltt_ust_session *usess = session->ust_session;
85076754
MD
1951 unsigned int chan_count;
1952
2f77fc4b
DG
1953 assert(usess);
1954
85076754 1955 chan_count = lttng_ht_get_count(usess->domain_global.channels);
979e618e
DG
1956 if (chan_count == 0) {
1957 struct lttng_channel *attr;
1958 /* Create default channel */
0a9c6494 1959 attr = channel_new_default_attr(domain, usess->buffer_type);
979e618e
DG
1960 if (attr == NULL) {
1961 ret = LTTNG_ERR_FATAL;
1962 goto error;
1963 }
1964
7972aab2 1965 ret = channel_ust_create(usess, attr, usess->buffer_type);
979e618e
DG
1966 if (ret != LTTNG_OK) {
1967 free(attr);
1968 goto error;
1969 }
cf0bcb51 1970 channel_attr_destroy(attr);
d5979e4a 1971 chan_ust_created = 1;
979e618e
DG
1972 }
1973
601d5acf 1974 ret = context_ust_add(usess, domain, ctx, channel_name);
bdf64013
JG
1975 free(app_ctx_provider_name);
1976 free(app_ctx_name);
1977 app_ctx_name = NULL;
1978 app_ctx_provider_name = NULL;
f73fabfd 1979 if (ret != LTTNG_OK) {
2f77fc4b
DG
1980 goto error;
1981 }
1982 break;
1983 }
2f77fc4b 1984 default:
f73fabfd 1985 ret = LTTNG_ERR_UND;
2f77fc4b
DG
1986 goto error;
1987 }
1988
bdf64013
JG
1989 ret = LTTNG_OK;
1990 goto end;
2f77fc4b
DG
1991
1992error:
d5979e4a
DG
1993 if (chan_kern_created) {
1994 struct ltt_kernel_channel *kchan =
1995 trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
1996 session->kernel_session);
1997 /* Created previously, this should NOT fail. */
1998 assert(kchan);
1999 kernel_destroy_channel(kchan);
2000 }
2001
2002 if (chan_ust_created) {
2003 struct ltt_ust_channel *uchan =
2004 trace_ust_find_channel_by_name(
2005 session->ust_session->domain_global.channels,
2006 DEFAULT_CHANNEL_NAME);
2007 /* Created previously, this should NOT fail. */
2008 assert(uchan);
2009 /* Remove from the channel list of the session. */
2010 trace_ust_delete_channel(session->ust_session->domain_global.channels,
2011 uchan);
2012 trace_ust_destroy_channel(uchan);
2013 }
bdf64013
JG
2014end:
2015 free(app_ctx_provider_name);
2016 free(app_ctx_name);
2f77fc4b
DG
2017 return ret;
2018}
2019
dac8e046
JG
2020static inline bool name_starts_with(const char *name, const char *prefix)
2021{
2022 const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
2023
2024 return !strncmp(name, prefix, max_cmp_len);
2025}
2026
2027/* Perform userspace-specific event name validation */
2028static int validate_ust_event_name(const char *name)
2029{
2030 int ret = 0;
2031
2032 if (!name) {
2033 ret = -1;
2034 goto end;
2035 }
2036
2037 /*
2038 * Check name against all internal UST event component namespaces used
2039 * by the agents.
2040 */
2041 if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
2042 name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
2043 name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
2044 ret = -1;
2045 }
2046
2047end:
2048 return ret;
2049}
88f06f15 2050
2f77fc4b 2051/*
88f06f15
JG
2052 * Internal version of cmd_enable_event() with a supplemental
2053 * "internal_event" flag which is used to enable internal events which should
2054 * be hidden from clients. Such events are used in the agent implementation to
2055 * enable the events through which all "agent" events are funeled.
2f77fc4b 2056 */
88f06f15 2057static int _cmd_enable_event(struct ltt_session *session,
df4f5a87 2058 const struct lttng_domain *domain,
025faf73 2059 char *channel_name, struct lttng_event *event,
6b453b5e 2060 char *filter_expression,
db8f1377
JI
2061 struct lttng_filter_bytecode *filter,
2062 struct lttng_event_exclusion *exclusion,
88f06f15 2063 int wpipe, bool internal_event)
2f77fc4b 2064{
9f449915 2065 int ret = 0, channel_created = 0;
cfedea03 2066 struct lttng_channel *attr = NULL;
2f77fc4b
DG
2067
2068 assert(session);
2069 assert(event);
2070 assert(channel_name);
2071
2a385866
JG
2072 /* If we have a filter, we must have its filter expression */
2073 assert(!(!!filter_expression ^ !!filter));
2074
9f449915
PP
2075 /* Normalize event name as a globbing pattern */
2076 strutils_normalize_star_glob_pattern(event->name);
18a720cd 2077
9f449915
PP
2078 /* Normalize exclusion names as globbing patterns */
2079 if (exclusion) {
2080 size_t i;
f5ac4bd7 2081
9f449915
PP
2082 for (i = 0; i < exclusion->count; i++) {
2083 char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i);
2084
2085 strutils_normalize_star_glob_pattern(name);
2086 }
930a2e99
JG
2087 }
2088
9f449915
PP
2089 DBG("Enable event command for event \'%s\'", event->name);
2090
2091 rcu_read_lock();
2092
7972aab2 2093 switch (domain->type) {
2f77fc4b
DG
2094 case LTTNG_DOMAIN_KERNEL:
2095 {
2096 struct ltt_kernel_channel *kchan;
2097
85076754
MD
2098 /*
2099 * If a non-default channel has been created in the
2100 * session, explicitely require that -c chan_name needs
2101 * to be provided.
2102 */
2103 if (session->kernel_session->has_non_default_channel
2104 && channel_name[0] == '\0') {
2105 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2106 goto error;
2107 }
2108
2f77fc4b
DG
2109 kchan = trace_kernel_get_channel_by_name(channel_name,
2110 session->kernel_session);
2111 if (kchan == NULL) {
0a9c6494
DG
2112 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
2113 LTTNG_BUFFER_GLOBAL);
2f77fc4b 2114 if (attr == NULL) {
f73fabfd 2115 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2116 goto error;
2117 }
04c17253
MD
2118 if (lttng_strncpy(attr->name, channel_name,
2119 sizeof(attr->name))) {
2120 ret = LTTNG_ERR_INVALID;
04c17253
MD
2121 goto error;
2122 }
2f77fc4b
DG
2123
2124 ret = cmd_enable_channel(session, domain, attr, wpipe);
f73fabfd 2125 if (ret != LTTNG_OK) {
2f77fc4b
DG
2126 goto error;
2127 }
e5f5db7f 2128 channel_created = 1;
2f77fc4b
DG
2129 }
2130
2131 /* Get the newly created kernel channel pointer */
2132 kchan = trace_kernel_get_channel_by_name(channel_name,
2133 session->kernel_session);
2134 if (kchan == NULL) {
2135 /* This sould not happen... */
f73fabfd 2136 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2137 goto error;
2138 }
2139
6e911cad
MD
2140 switch (event->type) {
2141 case LTTNG_EVENT_ALL:
29c62722 2142 {
00a62084
MD
2143 char *filter_expression_a = NULL;
2144 struct lttng_filter_bytecode *filter_a = NULL;
2145
2146 /*
2147 * We need to duplicate filter_expression and filter,
2148 * because ownership is passed to first enable
2149 * event.
2150 */
2151 if (filter_expression) {
2152 filter_expression_a = strdup(filter_expression);
2153 if (!filter_expression_a) {
2154 ret = LTTNG_ERR_FATAL;
2155 goto error;
2156 }
2157 }
2158 if (filter) {
2159 filter_a = zmalloc(sizeof(*filter_a) + filter->len);
2160 if (!filter_a) {
2161 free(filter_expression_a);
2162 ret = LTTNG_ERR_FATAL;
2163 goto error;
2164 }
2165 memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
2166 }
29c62722 2167 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
00a62084
MD
2168 ret = event_kernel_enable_event(kchan, event,
2169 filter_expression, filter);
a969e101
MD
2170 /* We have passed ownership */
2171 filter_expression = NULL;
2172 filter = NULL;
29c62722
MD
2173 if (ret != LTTNG_OK) {
2174 if (channel_created) {
2175 /* Let's not leak a useless channel. */
2176 kernel_destroy_channel(kchan);
2177 }
00a62084
MD
2178 free(filter_expression_a);
2179 free(filter_a);
29c62722
MD
2180 goto error;
2181 }
2182 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
00a62084
MD
2183 ret = event_kernel_enable_event(kchan, event,
2184 filter_expression_a, filter_a);
60d21fa2
AB
2185 /* We have passed ownership */
2186 filter_expression_a = NULL;
2187 filter_a = NULL;
29c62722
MD
2188 if (ret != LTTNG_OK) {
2189 goto error;
2190 }
2191 break;
2192 }
6e6ef3d7 2193 case LTTNG_EVENT_PROBE:
dcabc190 2194 case LTTNG_EVENT_USERSPACE_PROBE:
6e6ef3d7
DG
2195 case LTTNG_EVENT_FUNCTION:
2196 case LTTNG_EVENT_FUNCTION_ENTRY:
6e911cad 2197 case LTTNG_EVENT_TRACEPOINT:
00a62084
MD
2198 ret = event_kernel_enable_event(kchan, event,
2199 filter_expression, filter);
a969e101
MD
2200 /* We have passed ownership */
2201 filter_expression = NULL;
2202 filter = NULL;
6e911cad
MD
2203 if (ret != LTTNG_OK) {
2204 if (channel_created) {
2205 /* Let's not leak a useless channel. */
2206 kernel_destroy_channel(kchan);
2207 }
2208 goto error;
e5f5db7f 2209 }
6e911cad
MD
2210 break;
2211 case LTTNG_EVENT_SYSCALL:
00a62084
MD
2212 ret = event_kernel_enable_event(kchan, event,
2213 filter_expression, filter);
a969e101
MD
2214 /* We have passed ownership */
2215 filter_expression = NULL;
2216 filter = NULL;
e2b957af
MD
2217 if (ret != LTTNG_OK) {
2218 goto error;
2219 }
6e911cad
MD
2220 break;
2221 default:
2222 ret = LTTNG_ERR_UNK;
2f77fc4b
DG
2223 goto error;
2224 }
2225
7d268848 2226 kernel_wait_quiescent();
2f77fc4b
DG
2227 break;
2228 }
2229 case LTTNG_DOMAIN_UST:
2230 {
2231 struct ltt_ust_channel *uchan;
2232 struct ltt_ust_session *usess = session->ust_session;
2233
2234 assert(usess);
2235
85076754
MD
2236 /*
2237 * If a non-default channel has been created in the
2238 * session, explicitely require that -c chan_name needs
2239 * to be provided.
2240 */
2241 if (usess->has_non_default_channel && channel_name[0] == '\0') {
2242 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2243 goto error;
2244 }
2245
2f77fc4b
DG
2246 /* Get channel from global UST domain */
2247 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2248 channel_name);
2249 if (uchan == NULL) {
2250 /* Create default channel */
0a9c6494
DG
2251 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2252 usess->buffer_type);
2f77fc4b 2253 if (attr == NULL) {
f73fabfd 2254 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2255 goto error;
2256 }
04c17253
MD
2257 if (lttng_strncpy(attr->name, channel_name,
2258 sizeof(attr->name))) {
2259 ret = LTTNG_ERR_INVALID;
04c17253
MD
2260 goto error;
2261 }
2f77fc4b
DG
2262
2263 ret = cmd_enable_channel(session, domain, attr, wpipe);
f73fabfd 2264 if (ret != LTTNG_OK) {
2f77fc4b
DG
2265 goto error;
2266 }
2f77fc4b
DG
2267
2268 /* Get the newly created channel reference back */
2269 uchan = trace_ust_find_channel_by_name(
2270 usess->domain_global.channels, channel_name);
2271 assert(uchan);
2272 }
2273
141feb8c
JG
2274 if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
2275 /*
2276 * Don't allow users to add UST events to channels which
2277 * are assigned to a userspace subdomain (JUL, Log4J,
2278 * Python, etc.).
2279 */
2280 ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
2281 goto error;
2282 }
2283
dac8e046
JG
2284 if (!internal_event) {
2285 /*
2286 * Ensure the event name is not reserved for internal
2287 * use.
2288 */
2289 ret = validate_ust_event_name(event->name);
2290 if (ret) {
0e270a1e 2291 WARN("Userspace event name %s failed validation.",
bbcab087 2292 event->name);
dac8e046
JG
2293 ret = LTTNG_ERR_INVALID_EVENT_NAME;
2294 goto error;
2295 }
2296 }
2297
2f77fc4b 2298 /* At this point, the session and channel exist on the tracer */
6b453b5e 2299 ret = event_ust_enable_tracepoint(usess, uchan, event,
88f06f15
JG
2300 filter_expression, filter, exclusion,
2301 internal_event);
49d21f93
MD
2302 /* We have passed ownership */
2303 filter_expression = NULL;
2304 filter = NULL;
2305 exclusion = NULL;
94382e15
JG
2306 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2307 goto already_enabled;
2308 } else if (ret != LTTNG_OK) {
2f77fc4b
DG
2309 goto error;
2310 }
2311 break;
2312 }
5cdb6027 2313 case LTTNG_DOMAIN_LOG4J:
f20baf8e 2314 case LTTNG_DOMAIN_JUL:
0e115563 2315 case LTTNG_DOMAIN_PYTHON:
f20baf8e 2316 {
da6c3a50 2317 const char *default_event_name, *default_chan_name;
fefd409b 2318 struct agent *agt;
f20baf8e
DG
2319 struct lttng_event uevent;
2320 struct lttng_domain tmp_dom;
2321 struct ltt_ust_session *usess = session->ust_session;
2322
2323 assert(usess);
2324
f28f9e44
JG
2325 if (!agent_tracing_is_enabled()) {
2326 DBG("Attempted to enable an event in an agent domain but the agent thread is not running");
2327 ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
2328 goto error;
2329 }
2330
5cdb6027 2331 agt = trace_ust_find_agent(usess, domain->type);
fefd409b 2332 if (!agt) {
5cdb6027 2333 agt = agent_create(domain->type);
fefd409b 2334 if (!agt) {
e5b3c48c 2335 ret = LTTNG_ERR_NOMEM;
fefd409b
DG
2336 goto error;
2337 }
2338 agent_add(agt, usess->agents);
2339 }
2340
022d91ba 2341 /* Create the default tracepoint. */
996de3c7 2342 memset(&uevent, 0, sizeof(uevent));
f20baf8e
DG
2343 uevent.type = LTTNG_EVENT_TRACEPOINT;
2344 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
51755dc8
JG
2345 default_event_name = event_get_default_agent_ust_name(
2346 domain->type);
da6c3a50 2347 if (!default_event_name) {
e5b3c48c 2348 ret = LTTNG_ERR_FATAL;
da6c3a50 2349 goto error;
f43f95a9 2350 }
da6c3a50 2351 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
f20baf8e
DG
2352 uevent.name[sizeof(uevent.name) - 1] = '\0';
2353
2354 /*
2355 * The domain type is changed because we are about to enable the
2356 * default channel and event for the JUL domain that are hardcoded.
2357 * This happens in the UST domain.
2358 */
2359 memcpy(&tmp_dom, domain, sizeof(tmp_dom));
2360 tmp_dom.type = LTTNG_DOMAIN_UST;
2361
0e115563
DG
2362 switch (domain->type) {
2363 case LTTNG_DOMAIN_LOG4J:
da6c3a50 2364 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
0e115563
DG
2365 break;
2366 case LTTNG_DOMAIN_JUL:
da6c3a50 2367 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
0e115563
DG
2368 break;
2369 case LTTNG_DOMAIN_PYTHON:
2370 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2371 break;
2372 default:
e98a44b0 2373 /* The switch/case we are in makes this impossible */
0e115563 2374 assert(0);
da6c3a50
DG
2375 }
2376
971da06a 2377 {
8404118c 2378 char *filter_expression_copy = NULL;
51755dc8 2379 struct lttng_filter_bytecode *filter_copy = NULL;
971da06a
JG
2380
2381 if (filter) {
51755dc8
JG
2382 const size_t filter_size = sizeof(
2383 struct lttng_filter_bytecode)
2384 + filter->len;
2385
2386 filter_copy = zmalloc(filter_size);
971da06a 2387 if (!filter_copy) {
018096a4 2388 ret = LTTNG_ERR_NOMEM;
b742e3e2 2389 goto error;
971da06a 2390 }
51755dc8 2391 memcpy(filter_copy, filter, filter_size);
971da06a 2392
8404118c
JG
2393 filter_expression_copy =
2394 strdup(filter_expression);
2395 if (!filter_expression) {
2396 ret = LTTNG_ERR_NOMEM;
51755dc8
JG
2397 }
2398
2399 if (!filter_expression_copy || !filter_copy) {
2400 free(filter_expression_copy);
2401 free(filter_copy);
2402 goto error;
8404118c 2403 }
971da06a
JG
2404 }
2405
88f06f15 2406 ret = cmd_enable_event_internal(session, &tmp_dom,
971da06a 2407 (char *) default_chan_name,
8404118c
JG
2408 &uevent, filter_expression_copy,
2409 filter_copy, NULL, wpipe);
971da06a
JG
2410 }
2411
94382e15
JG
2412 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2413 goto already_enabled;
2414 } else if (ret != LTTNG_OK) {
f20baf8e
DG
2415 goto error;
2416 }
2417
2418 /* The wild card * means that everything should be enabled. */
2419 if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
8404118c
JG
2420 ret = event_agent_enable_all(usess, agt, event, filter,
2421 filter_expression);
f20baf8e 2422 } else {
8404118c
JG
2423 ret = event_agent_enable(usess, agt, event, filter,
2424 filter_expression);
f20baf8e 2425 }
51755dc8
JG
2426 filter = NULL;
2427 filter_expression = NULL;
f20baf8e
DG
2428 if (ret != LTTNG_OK) {
2429 goto error;
2430 }
2431
2432 break;
2433 }
2f77fc4b 2434 default:
f73fabfd 2435 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2436 goto error;
2437 }
2438
f73fabfd 2439 ret = LTTNG_OK;
2f77fc4b 2440
94382e15 2441already_enabled:
2f77fc4b 2442error:
49d21f93
MD
2443 free(filter_expression);
2444 free(filter);
2445 free(exclusion);
cf0bcb51 2446 channel_attr_destroy(attr);
2223c96f 2447 rcu_read_unlock();
2f77fc4b
DG
2448 return ret;
2449}
2450
88f06f15
JG
2451/*
2452 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2453 * We own filter, exclusion, and filter_expression.
2454 */
df4f5a87
JG
2455int cmd_enable_event(struct ltt_session *session,
2456 const struct lttng_domain *domain,
88f06f15
JG
2457 char *channel_name, struct lttng_event *event,
2458 char *filter_expression,
2459 struct lttng_filter_bytecode *filter,
2460 struct lttng_event_exclusion *exclusion,
2461 int wpipe)
2462{
2463 return _cmd_enable_event(session, domain, channel_name, event,
2464 filter_expression, filter, exclusion, wpipe, false);
2465}
2466
2467/*
2468 * Enable an event which is internal to LTTng. An internal should
2469 * never be made visible to clients and are immune to checks such as
2470 * reserved names.
2471 */
2472static int cmd_enable_event_internal(struct ltt_session *session,
df4f5a87 2473 const struct lttng_domain *domain,
88f06f15
JG
2474 char *channel_name, struct lttng_event *event,
2475 char *filter_expression,
2476 struct lttng_filter_bytecode *filter,
2477 struct lttng_event_exclusion *exclusion,
2478 int wpipe)
2479{
2480 return _cmd_enable_event(session, domain, channel_name, event,
2481 filter_expression, filter, exclusion, wpipe, true);
2482}
2483
2f77fc4b
DG
2484/*
2485 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2486 */
56a37563
JG
2487ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
2488 struct lttng_event **events)
2f77fc4b
DG
2489{
2490 int ret;
2491 ssize_t nb_events = 0;
2492
2493 switch (domain) {
2494 case LTTNG_DOMAIN_KERNEL:
7d268848 2495 nb_events = kernel_list_events(events);
2f77fc4b 2496 if (nb_events < 0) {
f73fabfd 2497 ret = LTTNG_ERR_KERN_LIST_FAIL;
2f77fc4b
DG
2498 goto error;
2499 }
2500 break;
2501 case LTTNG_DOMAIN_UST:
2502 nb_events = ust_app_list_events(events);
2503 if (nb_events < 0) {
f73fabfd 2504 ret = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2505 goto error;
2506 }
2507 break;
5cdb6027 2508 case LTTNG_DOMAIN_LOG4J:
3c6a091f 2509 case LTTNG_DOMAIN_JUL:
0e115563 2510 case LTTNG_DOMAIN_PYTHON:
f60140a1 2511 nb_events = agent_list_events(events, domain);
3c6a091f
DG
2512 if (nb_events < 0) {
2513 ret = LTTNG_ERR_UST_LIST_FAIL;
2514 goto error;
2515 }
2516 break;
2f77fc4b 2517 default:
f73fabfd 2518 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2519 goto error;
2520 }
2521
2522 return nb_events;
2523
2524error:
2525 /* Return negative value to differentiate return code */
2526 return -ret;
2527}
2528
2529/*
2530 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2531 */
56a37563 2532ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2f77fc4b
DG
2533 struct lttng_event_field **fields)
2534{
2535 int ret;
2536 ssize_t nb_fields = 0;
2537
2538 switch (domain) {
2539 case LTTNG_DOMAIN_UST:
2540 nb_fields = ust_app_list_event_fields(fields);
2541 if (nb_fields < 0) {
f73fabfd 2542 ret = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2543 goto error;
2544 }
2545 break;
2546 case LTTNG_DOMAIN_KERNEL:
2547 default: /* fall-through */
f73fabfd 2548 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2549 goto error;
2550 }
2551
2552 return nb_fields;
2553
2554error:
2555 /* Return negative value to differentiate return code */
2556 return -ret;
2557}
2558
834978fd
DG
2559ssize_t cmd_list_syscalls(struct lttng_event **events)
2560{
2561 return syscall_table_list(events);
2562}
2563
2f77fc4b
DG
2564/*
2565 * Command LTTNG_START_TRACE processed by the client thread.
a9ad0c8f
MD
2566 *
2567 * Called with session mutex held.
2f77fc4b
DG
2568 */
2569int cmd_start_trace(struct ltt_session *session)
2570{
82b69413 2571 enum lttng_error_code ret;
cde3e505 2572 unsigned long nb_chan = 0;
2f77fc4b
DG
2573 struct ltt_kernel_session *ksession;
2574 struct ltt_ust_session *usess;
1f496244
JG
2575 const bool session_rotated_after_last_stop =
2576 session->rotated_after_last_stop;
b02f5986
MD
2577 const bool session_cleared_after_last_stop =
2578 session->cleared_after_last_stop;
2f77fc4b
DG
2579
2580 assert(session);
2581
2582 /* Ease our life a bit ;) */
2583 ksession = session->kernel_session;
2584 usess = session->ust_session;
2585
8382cf6f
DG
2586 /* Is the session already started? */
2587 if (session->active) {
f73fabfd 2588 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
7a24ece3
JR
2589 /* Perform nothing */
2590 goto end;
2f77fc4b
DG
2591 }
2592
1f496244
JG
2593 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
2594 !session->current_trace_chunk) {
2595 /*
2596 * A rotation was launched while the session was stopped and
2597 * it has not been completed yet. It is not possible to start
2598 * the session since starting the session here would require a
2599 * rotation from "NULL" to a new trace chunk. That rotation
2600 * would overlap with the ongoing rotation, which is not
2601 * supported.
2602 */
2603 WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing",
2604 session->name);
2605 ret = LTTNG_ERR_ROTATION_PENDING;
2606 goto error;
2607 }
2608
cde3e505
DG
2609 /*
2610 * Starting a session without channel is useless since after that it's not
2611 * possible to enable channel thus inform the client.
2612 */
2613 if (usess && usess->domain_global.channels) {
2614 nb_chan += lttng_ht_get_count(usess->domain_global.channels);
2615 }
2616 if (ksession) {
2617 nb_chan += ksession->channel_count;
2618 }
2619 if (!nb_chan) {
2620 ret = LTTNG_ERR_NO_CHANNEL;
2621 goto error;
2622 }
2623
1f496244
JG
2624 session->active = 1;
2625 session->rotated_after_last_stop = false;
b02f5986 2626 session->cleared_after_last_stop = false;
070b6a86 2627 if (session->output_traces && !session->current_trace_chunk) {
1f496244
JG
2628 if (!session->has_been_started) {
2629 struct lttng_trace_chunk *trace_chunk;
2630
2631 DBG("Creating initial trace chunk of session \"%s\"",
2632 session->name);
2633 trace_chunk = session_create_new_trace_chunk(
2634 session, NULL, NULL, NULL);
2635 if (!trace_chunk) {
2636 ret = LTTNG_ERR_CREATE_DIR_FAIL;
2637 goto error;
2638 }
2639 assert(!session->current_trace_chunk);
2640 ret = session_set_trace_chunk(session, trace_chunk,
2641 NULL);
2642 lttng_trace_chunk_put(trace_chunk);
2643 if (ret) {
2644 ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
2645 goto error;
2646 }
2647 } else {
2648 DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk",
2649 session->name);
2650 /*
2651 * Rotate existing streams into the new chunk.
2652 * This is a "quiet" rotation has no client has
2653 * explicitly requested this operation.
2654 *
2655 * There is also no need to wait for the rotation
2656 * to complete as it will happen immediately. No data
2657 * was produced as the session was stopped, so the
2658 * rotation should happen on reception of the command.
2659 */
343defc2
MD
2660 ret = cmd_rotate_session(session, NULL, true,
2661 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
1f496244
JG
2662 if (ret != LTTNG_OK) {
2663 goto error;
2664 }
5c408ad8 2665 }
c996624c
JD
2666 }
2667
2f77fc4b
DG
2668 /* Kernel tracing */
2669 if (ksession != NULL) {
c996624c 2670 DBG("Start kernel tracing session %s", session->name);
7d268848 2671 ret = start_kernel_session(ksession);
9b6c7ec5 2672 if (ret != LTTNG_OK) {
2f77fc4b
DG
2673 goto error;
2674 }
2f77fc4b
DG
2675 }
2676
2677 /* Flag session that trace should start automatically */
2678 if (usess) {
82b69413
JG
2679 int int_ret = ust_app_start_trace_all(usess);
2680
2681 if (int_ret < 0) {
f73fabfd 2682 ret = LTTNG_ERR_UST_START_FAIL;
2f77fc4b
DG
2683 goto error;
2684 }
2685 }
2686
04ed9e10
JG
2687 /*
2688 * Open a packet in every stream of the session to ensure that viewers
2689 * can correctly identify the boundaries of the periods during which
2690 * tracing was active for this session.
2691 */
2692 ret = session_open_packets(session);
2693 if (ret != LTTNG_OK) {
2694 goto error;
2695 }
2696
5c408ad8
JD
2697 /*
2698 * Clear the flag that indicates that a rotation was done while the
2699 * session was stopped.
2700 */
2701 session->rotated_after_last_stop = false;
2702
259c2674 2703 if (session->rotate_timer_period) {
82b69413
JG
2704 int int_ret = timer_session_rotation_schedule_timer_start(
2705 session, session->rotate_timer_period);
2706
2707 if (int_ret < 0) {
259c2674
JD
2708 ERR("Failed to enable rotate timer");
2709 ret = LTTNG_ERR_UNK;
2710 goto error;
2711 }
2712 }
2713
f73fabfd 2714 ret = LTTNG_OK;
2f77fc4b
DG
2715
2716error:
1f496244
JG
2717 if (ret == LTTNG_OK) {
2718 /* Flag this after a successful start. */
2719 session->has_been_started |= 1;
2720 } else {
2721 session->active = 0;
2722 /* Restore initial state on error. */
2723 session->rotated_after_last_stop =
2724 session_rotated_after_last_stop;
b02f5986
MD
2725 session->cleared_after_last_stop =
2726 session_cleared_after_last_stop;
1f496244 2727 }
7a24ece3 2728end:
2f77fc4b
DG
2729 return ret;
2730}
2731
2732/*
2733 * Command LTTNG_STOP_TRACE processed by the client thread.
2734 */
2735int cmd_stop_trace(struct ltt_session *session)
2736{
2737 int ret;
2f77fc4b
DG
2738 struct ltt_kernel_session *ksession;
2739 struct ltt_ust_session *usess;
2740
2741 assert(session);
2742
4dbe1875 2743 DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id);
2f77fc4b
DG
2744 /* Short cut */
2745 ksession = session->kernel_session;
2746 usess = session->ust_session;
2747
8382cf6f
DG
2748 /* Session is not active. Skip everythong and inform the client. */
2749 if (!session->active) {
f73fabfd 2750 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2f77fc4b
DG
2751 goto error;
2752 }
2753
4dbe1875
MD
2754 ret = stop_kernel_session(ksession);
2755 if (ret != LTTNG_OK) {
2756 goto error;
2f77fc4b
DG
2757 }
2758
14fb1ebe 2759 if (usess && usess->active) {
2f77fc4b
DG
2760 ret = ust_app_stop_trace_all(usess);
2761 if (ret < 0) {
f73fabfd 2762 ret = LTTNG_ERR_UST_STOP_FAIL;
2f77fc4b
DG
2763 goto error;
2764 }
2765 }
2766
4dbe1875
MD
2767 DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name,
2768 session->id);
8382cf6f
DG
2769 /* Flag inactive after a successful stop. */
2770 session->active = 0;
4dbe1875 2771 ret = LTTNG_OK;
2f77fc4b
DG
2772
2773error:
2774 return ret;
2775}
2776
2777/*
433f5ba9
JR
2778 * Set the base_path of the session only if subdir of a control uris is set.
2779 * Return LTTNG_OK on success, otherwise LTTNG_ERR_*.
2f77fc4b 2780 */
433f5ba9
JR
2781static int set_session_base_path_from_uris(struct ltt_session *session,
2782 size_t nb_uri,
bda32d56 2783 struct lttng_uri *uris)
2f77fc4b 2784{
433f5ba9
JR
2785 int ret;
2786 size_t i;
2f77fc4b 2787
e3876bf0
JR
2788 for (i = 0; i < nb_uri; i++) {
2789 if (uris[i].stype != LTTNG_STREAM_CONTROL ||
2790 uris[i].subdir[0] == '\0') {
2791 /* Not interested in these URIs */
2792 continue;
2793 }
2794
2795 if (session->base_path != NULL) {
2796 free(session->base_path);
2797 session->base_path = NULL;
2798 }
2799
2800 /* Set session base_path */
2801 session->base_path = strdup(uris[i].subdir);
2802 if (!session->base_path) {
433f5ba9
JR
2803 PERROR("Failed to copy base path \"%s\" to session \"%s\"",
2804 uris[i].subdir, session->name);
2805 ret = LTTNG_ERR_NOMEM;
e3876bf0
JR
2806 goto error;
2807 }
433f5ba9
JR
2808 DBG2("Setting base path \"%s\" for session \"%s\"",
2809 session->base_path, session->name);
2810 }
2811 ret = LTTNG_OK;
2812error:
2813 return ret;
2814}
2815
2816/*
2817 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2818 */
2819int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2820 struct lttng_uri *uris)
2821{
2822 int ret, i;
2823 struct ltt_kernel_session *ksess = session->kernel_session;
2824 struct ltt_ust_session *usess = session->ust_session;
2825
2826 assert(session);
2827 assert(uris);
2828 assert(nb_uri > 0);
2829
2830 /* Can't set consumer URI if the session is active. */
2831 if (session->active) {
2832 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2833 goto error;
2834 }
2835
2836 /*
2837 * Set the session base path if any. This is done inside
2838 * cmd_set_consumer_uri to preserve backward compatibility of the
2839 * previous session creation api vs the session descriptor api.
2840 */
2841 ret = set_session_base_path_from_uris(session, nb_uri, uris);
2842 if (ret != LTTNG_OK) {
2843 goto error;
e3876bf0
JR
2844 }
2845
bda32d56 2846 /* Set the "global" consumer URIs */
2f77fc4b 2847 for (i = 0; i < nb_uri; i++) {
e3876bf0
JR
2848 ret = add_uri_to_consumer(session, session->consumer, &uris[i],
2849 LTTNG_DOMAIN_NONE);
a74934ba 2850 if (ret != LTTNG_OK) {
2f77fc4b
DG
2851 goto error;
2852 }
2f77fc4b
DG
2853 }
2854
bda32d56
JG
2855 /* Set UST session URIs */
2856 if (session->ust_session) {
2857 for (i = 0; i < nb_uri; i++) {
b178f53e 2858 ret = add_uri_to_consumer(session,
bda32d56 2859 session->ust_session->consumer,
b178f53e 2860 &uris[i], LTTNG_DOMAIN_UST);
bda32d56
JG
2861 if (ret != LTTNG_OK) {
2862 goto error;
2863 }
2864 }
2865 }
2866
2867 /* Set kernel session URIs */
2868 if (session->kernel_session) {
2869 for (i = 0; i < nb_uri; i++) {
b178f53e 2870 ret = add_uri_to_consumer(session,
bda32d56 2871 session->kernel_session->consumer,
b178f53e 2872 &uris[i], LTTNG_DOMAIN_KERNEL);
bda32d56
JG
2873 if (ret != LTTNG_OK) {
2874 goto error;
2875 }
2876 }
2877 }
2878
7ab70fe0
DG
2879 /*
2880 * Make sure to set the session in output mode after we set URI since a
2881 * session can be created without URL (thus flagged in no output mode).
2882 */
2883 session->output_traces = 1;
2884 if (ksess) {
2885 ksess->output_traces = 1;
bda32d56
JG
2886 }
2887
2888 if (usess) {
7ab70fe0
DG
2889 usess->output_traces = 1;
2890 }
2891
2f77fc4b 2892 /* All good! */
f73fabfd 2893 ret = LTTNG_OK;
2f77fc4b
DG
2894
2895error:
2896 return ret;
2897}
2898
b178f53e
JG
2899static
2900enum lttng_error_code set_session_output_from_descriptor(
2901 struct ltt_session *session,
2902 const struct lttng_session_descriptor *descriptor)
2f77fc4b
DG
2903{
2904 int ret;
b178f53e
JG
2905 enum lttng_error_code ret_code = LTTNG_OK;
2906 enum lttng_session_descriptor_type session_type =
2907 lttng_session_descriptor_get_type(descriptor);
2908 enum lttng_session_descriptor_output_type output_type =
2909 lttng_session_descriptor_get_output_type(descriptor);
2910 struct lttng_uri uris[2] = {};
2911 size_t uri_count = 0;
2912
2913 switch (output_type) {
2914 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
2915 goto end;
2916 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
2917 lttng_session_descriptor_get_local_output_uri(descriptor,
2918 &uris[0]);
2919 uri_count = 1;
2920 break;
2921 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
2922 lttng_session_descriptor_get_network_output_uris(descriptor,
2923 &uris[0], &uris[1]);
2924 uri_count = 2;
2925 break;
2926 default:
2927 ret_code = LTTNG_ERR_INVALID;
e32d7f27 2928 goto end;
2f77fc4b
DG
2929 }
2930
b178f53e
JG
2931 switch (session_type) {
2932 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
2933 {
2934 struct snapshot_output *new_output = NULL;
2935
2936 new_output = snapshot_output_alloc();
2937 if (!new_output) {
2938 ret_code = LTTNG_ERR_NOMEM;
2939 goto end;
2940 }
2941
2942 ret = snapshot_output_init_with_uri(session,
2943 DEFAULT_SNAPSHOT_MAX_SIZE,
2944 NULL, uris, uri_count, session->consumer,
2945 new_output, &session->snapshot);
2946 if (ret < 0) {
2947 ret_code = (ret == -ENOMEM) ?
2948 LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID;
2949 snapshot_output_destroy(new_output);
2950 goto end;
2951 }
2952 snapshot_add_output(&session->snapshot, new_output);
2953 break;
2954 }
2955 case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
2956 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
2957 {
2958 ret_code = cmd_set_consumer_uri(session, uri_count, uris);
2959 break;
2960 }
2961 default:
2962 ret_code = LTTNG_ERR_INVALID;
e32d7f27 2963 goto end;
2f77fc4b 2964 }
b178f53e
JG
2965end:
2966 return ret_code;
2967}
2968
2969static
2970enum lttng_error_code cmd_create_session_from_descriptor(
2971 struct lttng_session_descriptor *descriptor,
2972 const lttng_sock_cred *creds,
2973 const char *home_path)
2974{
2975 int ret;
2976 enum lttng_error_code ret_code;
2977 const char *session_name;
2978 struct ltt_session *new_session = NULL;
2979 enum lttng_session_descriptor_status descriptor_status;
2f77fc4b 2980
e32d7f27 2981 session_lock_list();
b178f53e
JG
2982 if (home_path) {
2983 if (*home_path != '/') {
2984 ERR("Home path provided by client is not absolute");
2985 ret_code = LTTNG_ERR_INVALID;
2986 goto end;
2987 }
2988 }
2f77fc4b 2989
b178f53e
JG
2990 descriptor_status = lttng_session_descriptor_get_session_name(
2991 descriptor, &session_name);
2992 switch (descriptor_status) {
2993 case LTTNG_SESSION_DESCRIPTOR_STATUS_OK:
2994 break;
2995 case LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET:
2996 session_name = NULL;
2997 break;
2998 default:
2999 ret_code = LTTNG_ERR_INVALID;
3000 goto end;
3001 }
e3876bf0 3002
b178f53e 3003 ret_code = session_create(session_name, creds->uid, creds->gid,
e3876bf0 3004 &new_session);
b178f53e 3005 if (ret_code != LTTNG_OK) {
e32d7f27 3006 goto end;
2f77fc4b
DG
3007 }
3008
b178f53e
JG
3009 if (!session_name) {
3010 ret = lttng_session_descriptor_set_session_name(descriptor,
3011 new_session->name);
3012 if (ret) {
3013 ret_code = LTTNG_ERR_SESSION_FAIL;
3014 goto end;
3015 }
3016 }
3017
3018 if (!lttng_session_descriptor_is_output_destination_initialized(
3019 descriptor)) {
3020 /*
3021 * Only include the session's creation time in the output
3022 * destination if the name of the session itself was
3023 * not auto-generated.
3024 */
3025 ret_code = lttng_session_descriptor_set_default_output(
3026 descriptor,
3027 session_name ? &new_session->creation_time : NULL,
3028 home_path);
3029 if (ret_code != LTTNG_OK) {
e32d7f27 3030 goto end;
2bba9e53 3031 }
2bba9e53 3032 } else {
b178f53e
JG
3033 new_session->has_user_specified_directory =
3034 lttng_session_descriptor_has_output_directory(
3035 descriptor);
2f77fc4b
DG
3036 }
3037
b178f53e
JG
3038 switch (lttng_session_descriptor_get_type(descriptor)) {
3039 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
3040 new_session->snapshot_mode = 1;
3041 break;
3042 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
3043 new_session->live_timer =
3044 lttng_session_descriptor_live_get_timer_interval(
3045 descriptor);
3046 break;
3047 default:
3048 break;
3049 }
2f77fc4b 3050
b178f53e
JG
3051 ret_code = set_session_output_from_descriptor(new_session, descriptor);
3052 if (ret_code != LTTNG_OK) {
3053 goto end;
3054 }
3055 new_session->consumer->enabled = 1;
3056 ret_code = LTTNG_OK;
e32d7f27 3057end:
b178f53e
JG
3058 /* Release reference provided by the session_create function. */
3059 session_put(new_session);
3060 if (ret_code != LTTNG_OK && new_session) {
3061 /* Release the global reference on error. */
3062 session_destroy(new_session);
e32d7f27 3063 }
b178f53e
JG
3064 session_unlock_list();
3065 return ret_code;
2f77fc4b
DG
3066}
3067
b178f53e
JG
3068enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
3069 struct lttng_session_descriptor **return_descriptor)
27babd3a
DG
3070{
3071 int ret;
b178f53e
JG
3072 size_t payload_size;
3073 struct lttng_dynamic_buffer payload;
3074 struct lttng_buffer_view home_dir_view;
3075 struct lttng_buffer_view session_descriptor_view;
3076 struct lttng_session_descriptor *session_descriptor = NULL;
3077 enum lttng_error_code ret_code;
3078
3079 lttng_dynamic_buffer_init(&payload);
3a91de3a 3080 if (cmd_ctx->lsm.u.create_session.home_dir_size >=
b178f53e
JG
3081 LTTNG_PATH_MAX) {
3082 ret_code = LTTNG_ERR_INVALID;
3083 goto error;
27babd3a 3084 }
3a91de3a 3085 if (cmd_ctx->lsm.u.create_session.session_descriptor_size >
b178f53e
JG
3086 LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
3087 ret_code = LTTNG_ERR_INVALID;
3088 goto error;
27babd3a
DG
3089 }
3090
3a91de3a
JG
3091 payload_size = cmd_ctx->lsm.u.create_session.home_dir_size +
3092 cmd_ctx->lsm.u.create_session.session_descriptor_size;
b178f53e
JG
3093 ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
3094 if (ret) {
3095 ret_code = LTTNG_ERR_NOMEM;
3096 goto error;
27babd3a
DG
3097 }
3098
b178f53e
JG
3099 ret = lttcomm_recv_unix_sock(sock, payload.data, payload.size);
3100 if (ret <= 0) {
3101 ERR("Reception of session descriptor failed, aborting.");
3102 ret_code = LTTNG_ERR_SESSION_FAIL;
3103 goto error;
27babd3a
DG
3104 }
3105
b178f53e
JG
3106 home_dir_view = lttng_buffer_view_from_dynamic_buffer(
3107 &payload,
3108 0,
3a91de3a 3109 cmd_ctx->lsm.u.create_session.home_dir_size);
b178f53e
JG
3110 session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
3111 &payload,
3a91de3a
JG
3112 cmd_ctx->lsm.u.create_session.home_dir_size,
3113 cmd_ctx->lsm.u.create_session.session_descriptor_size);
27babd3a 3114
b178f53e
JG
3115 ret = lttng_session_descriptor_create_from_buffer(
3116 &session_descriptor_view, &session_descriptor);
3117 if (ret < 0) {
3118 ERR("Failed to create session descriptor from payload of \"create session\" command");
3119 ret_code = LTTNG_ERR_INVALID;
3120 goto error;
3121 }
27babd3a 3122
b178f53e
JG
3123 /*
3124 * Sets the descriptor's auto-generated properties (name, output) if
3125 * needed.
3126 */
3127 ret_code = cmd_create_session_from_descriptor(session_descriptor,
3128 &cmd_ctx->creds,
3129 home_dir_view.size ? home_dir_view.data : NULL);
3130 if (ret_code != LTTNG_OK) {
3131 goto error;
e32d7f27 3132 }
b178f53e
JG
3133
3134 ret_code = LTTNG_OK;
3135 *return_descriptor = session_descriptor;
3136 session_descriptor = NULL;
3137error:
3138 lttng_dynamic_buffer_reset(&payload);
3139 lttng_session_descriptor_destroy(session_descriptor);
3140 return ret_code;
27babd3a
DG
3141}
3142
3e3665b8
JG
3143static
3144void cmd_destroy_session_reply(const struct ltt_session *session,
3145 void *_reply_context)
3146{
3147 int ret;
3148 ssize_t comm_ret;
3149 const struct cmd_destroy_session_reply_context *reply_context =
3150 _reply_context;
3151 struct lttng_dynamic_buffer payload;
3152 struct lttcomm_session_destroy_command_header cmd_header;
3153 struct lttng_trace_archive_location *location = NULL;
3154 struct lttcomm_lttng_msg llm = {
3155 .cmd_type = LTTNG_DESTROY_SESSION,
3285a971 3156 .ret_code = reply_context->destruction_status,
3e3665b8
JG
3157 .pid = UINT32_MAX,
3158 .cmd_header_size =
3159 sizeof(struct lttcomm_session_destroy_command_header),
3160 .data_size = 0,
3161 };
3162 size_t payload_size_before_location;
3163
3164 lttng_dynamic_buffer_init(&payload);
3165
3166 ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm));
0e270a1e 3167 if (ret) {
3e3665b8
JG
3168 ERR("Failed to append session destruction message");
3169 goto error;
0e270a1e 3170 }
3e3665b8
JG
3171
3172 cmd_header.rotation_state =
3173 (int32_t) (reply_context->implicit_rotation_on_destroy ?
3174 session->rotation_state :
3175 LTTNG_ROTATION_STATE_NO_ROTATION);
3176 ret = lttng_dynamic_buffer_append(&payload, &cmd_header,
3177 sizeof(cmd_header));
3178 if (ret) {
3179 ERR("Failed to append session destruction command header");
3180 goto error;
3181 }
3182
3183 if (!reply_context->implicit_rotation_on_destroy) {
3184 DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply",
3185 session->name);
3186 goto send_reply;
3187 }
3188 if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) {
3189 DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply",
3190 session->name);
3191 goto send_reply;
3192 }
3193
3194 location = session_get_trace_archive_location(session);
3195 if (!location) {
3196 ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"",
3197 session->name);
3198 goto error;
3199 }
3200
3201 payload_size_before_location = payload.size;
3202 comm_ret = lttng_trace_archive_location_serialize(location,
3203 &payload);
3204 if (comm_ret < 0) {
3205 ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
3206 session->name);
3207 goto error;
3208 }
3209 /* Update the message to indicate the location's length. */
3210 ((struct lttcomm_lttng_msg *) payload.data)->data_size =
3211 payload.size - payload_size_before_location;
3212send_reply:
3213 comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd,
3214 payload.data, payload.size);
3215 if (comm_ret != (ssize_t) payload.size) {
3216 ERR("Failed to send result of the destruction of session \"%s\" to client",
3217 session->name);
3218 }
3219error:
3220 ret = close(reply_context->reply_sock_fd);
3221 if (ret) {
3222 PERROR("Failed to close client socket in deferred session destroy reply");
3223 }
3224 lttng_dynamic_buffer_reset(&payload);
3225 free(_reply_context);
3226}
3227
2f77fc4b
DG
3228/*
3229 * Command LTTNG_DESTROY_SESSION processed by the client thread.
a9ad0c8f
MD
3230 *
3231 * Called with session lock held.
2f77fc4b 3232 */
e32d7f27 3233int cmd_destroy_session(struct ltt_session *session,
3e3665b8
JG
3234 struct notification_thread_handle *notification_thread_handle,
3235 int *sock_fd)
2f77fc4b
DG
3236{
3237 int ret;
3285a971 3238 enum lttng_error_code destruction_last_error = LTTNG_OK;
3e3665b8
JG
3239 struct cmd_destroy_session_reply_context *reply_context = NULL;
3240
3241 if (sock_fd) {
3242 reply_context = zmalloc(sizeof(*reply_context));
3243 if (!reply_context) {
3244 ret = LTTNG_ERR_NOMEM;
3245 goto end;
3246 }
3247 reply_context->reply_sock_fd = *sock_fd;
3248 }
2f77fc4b
DG
3249
3250 /* Safety net */
3251 assert(session);
3252
3e3665b8
JG
3253 DBG("Begin destroy session %s (id %" PRIu64 ")", session->name,
3254 session->id);
3255 if (session->active) {
3256 DBG("Session \"%s\" is active, attempting to stop it before destroying it",
3257 session->name);
3258 ret = cmd_stop_trace(session);
3259 if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) {
3260 /* Carry on with the destruction of the session. */
3261 ERR("Failed to stop session \"%s\" as part of its destruction: %s",
3262 session->name, lttng_strerror(-ret));
3285a971 3263 destruction_last_error = ret;
3e3665b8
JG
3264 }
3265 }
5c408ad8 3266
92816cc3
JG
3267 if (session->rotation_schedule_timer_enabled) {
3268 if (timer_session_rotation_schedule_timer_stop(
3269 session)) {
3270 ERR("Failed to stop the \"rotation schedule\" timer of session %s",
3271 session->name);
3285a971 3272 destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;