consumerd: send a buffer static sample on flush command
[lttng-tools.git] / src / bin / lttng-sessiond / cmd.cpp
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
588c4b0d 9
6c1c0768 10#define _LGPL_SOURCE
7966af57 11#include <algorithm>
6dc3064a 12#include <inttypes.h>
588c4b0d
JG
13#include <stdio.h>
14#include <sys/stat.h>
2f77fc4b
DG
15#include <urcu/list.h>
16#include <urcu/uatomic.h>
17
c9e313bc
SM
18#include <common/buffer-view.hpp>
19#include <common/common.hpp>
20#include <common/compat/string.hpp>
21#include <common/defaults.hpp>
22#include <common/dynamic-buffer.hpp>
23#include <common/kernel-ctl/kernel-ctl.hpp>
24#include <common/payload-view.hpp>
25#include <common/payload.hpp>
26#include <common/relayd/relayd.hpp>
27#include <common/sessiond-comm/sessiond-comm.hpp>
28#include <common/string-utils/string-utils.hpp>
29#include <common/trace-chunk.hpp>
30#include <common/utils.hpp>
31#include <lttng/action/action-internal.hpp>
588c4b0d 32#include <lttng/action/action.h>
c9e313bc 33#include <lttng/channel-internal.hpp>
588c4b0d 34#include <lttng/channel.h>
c9e313bc 35#include <lttng/condition/condition-internal.hpp>
588c4b0d 36#include <lttng/condition/condition.h>
c9e313bc
SM
37#include <lttng/condition/event-rule-matches-internal.hpp>
38#include <lttng/condition/event-rule-matches.h>
39#include <lttng/error-query-internal.hpp>
40#include <lttng/event-internal.hpp>
41#include <lttng/event-rule/event-rule-internal.hpp>
42#include <lttng/event-rule/event-rule.h>
43#include <lttng/location-internal.hpp>
44#include <lttng/lttng-error.h>
45#include <lttng/rotate-internal.hpp>
46#include <lttng/session-descriptor-internal.hpp>
47#include <lttng/session-internal.hpp>
48#include <lttng/tracker.h>
49#include <lttng/trigger/trigger-internal.hpp>
50#include <lttng/userspace-probe-internal.hpp>
2f77fc4b 51
c9e313bc
SM
52#include "agent-thread.hpp"
53#include "agent.hpp"
54#include "buffer-registry.hpp"
55#include "channel.hpp"
56#include "cmd.hpp"
57#include "consumer.hpp"
58#include "event-notifier-error-accounting.hpp"
59#include "event.hpp"
60#include "health-sessiond.hpp"
61#include "kernel-consumer.hpp"
62#include "kernel.hpp"
63#include "lttng-sessiond.hpp"
64#include "lttng-syscall.hpp"
65#include "notification-thread-commands.hpp"
66#include "notification-thread.hpp"
67#include "rotate.hpp"
68#include "rotation-thread.hpp"
69#include "session.hpp"
70#include "timer.hpp"
71#include "tracker.hpp"
72#include "utils.hpp"
2f77fc4b 73
a503e1ef
JG
74/* Sleep for 100ms between each check for the shm path's deletion. */
75#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
76
d7bfb9b0
JG
77namespace lsu = lttng::sessiond::ust;
78
f1494934
JG
79static enum lttng_error_code wait_on_path(void *path);
80
81namespace {
3e3665b8
JG
82struct cmd_destroy_session_reply_context {
83 int reply_sock_fd;
84 bool implicit_rotation_on_destroy;
3285a971
JG
85 /*
86 * Indicates whether or not an error occurred while launching the
87 * destruction of a session.
88 */
89 enum lttng_error_code destruction_status;
3e3665b8
JG
90};
91
a503e1ef
JG
92/*
93 * Command completion handler that is used by the destroy command
94 * when a session that has a non-default shm_path is being destroyed.
95 *
96 * See comment in cmd_destroy_session() for the rationale.
97 */
f1494934 98struct destroy_completion_handler {
a503e1ef
JG
99 struct cmd_completion_handler handler;
100 char shm_path[member_sizeof(struct ltt_session, shm_path)];
101} destroy_completion_handler = {
102 .handler = {
103 .run = wait_on_path,
104 .data = destroy_completion_handler.shm_path
105 },
106 .shm_path = { 0 },
107};
108
2f77fc4b
DG
109/*
110 * Used to keep a unique index for each relayd socket created where this value
111 * is associated with streams on the consumer so it can match the right relayd
d88aee68
DG
112 * to send to. It must be accessed with the relayd_net_seq_idx_lock
113 * held.
2f77fc4b 114 */
f1494934
JG
115pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
116uint64_t relayd_net_seq_idx;
117} /* namespace */
2f77fc4b 118
f1494934 119static struct cmd_completion_handler *current_completion_handler;
7076b56e
JG
120static int validate_ust_event_name(const char *);
121static int cmd_enable_event_internal(struct ltt_session *session,
df4f5a87 122 const struct lttng_domain *domain,
7076b56e
JG
123 char *channel_name, struct lttng_event *event,
124 char *filter_expression,
2b00d462 125 struct lttng_bytecode *filter,
7076b56e
JG
126 struct lttng_event_exclusion *exclusion,
127 int wpipe);
4878de5c
JG
128static enum lttng_error_code cmd_enable_channel_internal(
129 struct ltt_session *session,
999af9c1
JR
130 const struct lttng_domain *domain,
131 const struct lttng_channel *_attr,
132 int wpipe);
7076b56e 133
2f77fc4b
DG
134/*
135 * Create a session path used by list_lttng_sessions for the case that the
136 * session consumer is on the network.
137 */
138static int build_network_session_path(char *dst, size_t size,
139 struct ltt_session *session)
140{
141 int ret, kdata_port, udata_port;
142 struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
143 char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
144
a0377dfe
FD
145 LTTNG_ASSERT(session);
146 LTTNG_ASSERT(dst);
2f77fc4b
DG
147
148 memset(tmp_urls, 0, sizeof(tmp_urls));
149 memset(tmp_uurl, 0, sizeof(tmp_uurl));
150
151 kdata_port = udata_port = DEFAULT_NETWORK_DATA_PORT;
152
153 if (session->kernel_session && session->kernel_session->consumer) {
154 kuri = &session->kernel_session->consumer->dst.net.control;
155 kdata_port = session->kernel_session->consumer->dst.net.data.port;
156 }
157
158 if (session->ust_session && session->ust_session->consumer) {
159 uuri = &session->ust_session->consumer->dst.net.control;
160 udata_port = session->ust_session->consumer->dst.net.data.port;
161 }
162
163 if (uuri == NULL && kuri == NULL) {
164 uri = &session->consumer->dst.net.control;
165 kdata_port = session->consumer->dst.net.data.port;
166 } else if (kuri && uuri) {
167 ret = uri_compare(kuri, uuri);
168 if (ret) {
169 /* Not Equal */
170 uri = kuri;
171 /* Build uuri URL string */
172 ret = uri_to_str_url(uuri, tmp_uurl, sizeof(tmp_uurl));
173 if (ret < 0) {
174 goto error;
175 }
176 } else {
177 uri = kuri;
178 }
179 } else if (kuri && uuri == NULL) {
180 uri = kuri;
181 } else if (uuri && kuri == NULL) {
182 uri = uuri;
183 }
184
185 ret = uri_to_str_url(uri, tmp_urls, sizeof(tmp_urls));
186 if (ret < 0) {
187 goto error;
188 }
189
9aa9f900
DG
190 /*
191 * Do we have a UST url set. If yes, this means we have both kernel and UST
192 * to print.
193 */
9d035200 194 if (*tmp_uurl != '\0') {
2f77fc4b
DG
195 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
196 tmp_urls, kdata_port, tmp_uurl, udata_port);
197 } else {
9aa9f900 198 int dport;
bef08707 199 if (kuri || (!kuri && !uuri)) {
9aa9f900
DG
200 dport = kdata_port;
201 } else {
202 /* No kernel URI, use the UST port. */
203 dport = udata_port;
204 }
205 ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, dport);
2f77fc4b
DG
206 }
207
208error:
209 return ret;
210}
211
fb83fe64
JD
212/*
213 * Get run-time attributes if the session has been started (discarded events,
214 * lost packets).
215 */
216static int get_kernel_runtime_stats(struct ltt_session *session,
217 struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
218 uint64_t *lost_packets)
219{
220 int ret;
221
222 if (!session->has_been_started) {
223 ret = 0;
224 *discarded_events = 0;
225 *lost_packets = 0;
226 goto end;
227 }
228
e1f3997a 229 ret = consumer_get_discarded_events(session->id, kchan->key,
fb83fe64
JD
230 session->kernel_session->consumer,
231 discarded_events);
232 if (ret < 0) {
233 goto end;
234 }
235
e1f3997a 236 ret = consumer_get_lost_packets(session->id, kchan->key,
fb83fe64
JD
237 session->kernel_session->consumer,
238 lost_packets);
239 if (ret < 0) {
240 goto end;
241 }
242
243end:
244 return ret;
245}
246
247/*
248 * Get run-time attributes if the session has been started (discarded events,
249 * lost packets).
250 */
251static int get_ust_runtime_stats(struct ltt_session *session,
252 struct ltt_ust_channel *uchan, uint64_t *discarded_events,
253 uint64_t *lost_packets)
254{
255 int ret;
256 struct ltt_ust_session *usess;
257
a91c5803
JG
258 if (!discarded_events || !lost_packets) {
259 ret = -1;
260 goto end;
261 }
262
fb83fe64 263 usess = session->ust_session;
a0377dfe
FD
264 LTTNG_ASSERT(discarded_events);
265 LTTNG_ASSERT(lost_packets);
fb83fe64
JD
266
267 if (!usess || !session->has_been_started) {
268 *discarded_events = 0;
269 *lost_packets = 0;
270 ret = 0;
271 goto end;
272 }
273
274 if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
275 ret = ust_app_uid_get_channel_runtime_stats(usess->id,
276 &usess->buffer_reg_uid_list,
277 usess->consumer, uchan->id,
278 uchan->attr.overwrite,
279 discarded_events,
280 lost_packets);
281 } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
282 ret = ust_app_pid_get_channel_runtime_stats(usess,
283 uchan, usess->consumer,
284 uchan->attr.overwrite,
285 discarded_events,
286 lost_packets);
287 if (ret < 0) {
288 goto end;
289 }
290 *discarded_events += uchan->per_pid_closed_app_discarded;
291 *lost_packets += uchan->per_pid_closed_app_lost;
292 } else {
293 ERR("Unsupported buffer type");
a0377dfe 294 abort();
fb83fe64
JD
295 ret = -1;
296 goto end;
297 }
298
299end:
300 return ret;
301}
302
3c6a091f 303/*
022d91ba 304 * Create a list of agent domain events.
3c6a091f
DG
305 *
306 * Return number of events in list on success or else a negative value.
307 */
8ddd72ef
JR
308static enum lttng_error_code list_lttng_agent_events(
309 struct agent *agt, struct lttng_payload *reply_payload,
310 unsigned int *nb_events)
3c6a091f 311{
8ddd72ef
JR
312 enum lttng_error_code ret_code;
313 int ret = 0;
314 unsigned int local_nb_events = 0;
315 struct agent_event *event;
3c6a091f 316 struct lttng_ht_iter iter;
8ddd72ef 317 unsigned long agent_event_count;
3c6a091f 318
8ddd72ef
JR
319 assert(agt);
320 assert(reply_payload);
3c6a091f 321
022d91ba 322 DBG3("Listing agent events");
3c6a091f 323
e5bbf678 324 rcu_read_lock();
8ddd72ef
JR
325 agent_event_count = lttng_ht_get_count(agt->events);
326 if (agent_event_count == 0) {
327 /* Early exit. */
328 goto end;
329 }
7966af57 330
8ddd72ef
JR
331 if (agent_event_count > UINT_MAX) {
332 ret_code = LTTNG_ERR_OVERFLOW;
333 goto error;
334 }
e368fb43 335
8ddd72ef 336 local_nb_events = (unsigned int) agent_event_count;
e368fb43 337
8ddd72ef
JR
338 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
339 struct lttng_event *tmp_event = lttng_event_create();
340
341 if (!tmp_event) {
342 ret_code = LTTNG_ERR_NOMEM;
343 goto error;
3c02e545 344 }
b4e3ceb9 345
8ddd72ef
JR
346 if (lttng_strncpy(tmp_event->name, event->name, sizeof(tmp_event->name))) {
347 lttng_event_destroy(tmp_event);
348 ret_code = LTTNG_ERR_FATAL;
349 goto error;
350 }
351
352 tmp_event->name[sizeof(tmp_event->name) - 1] = '\0';
353 tmp_event->enabled = !!event->enabled_count;
354 tmp_event->loglevel = event->loglevel_value;
355 tmp_event->loglevel_type = event->loglevel_type;
3c6a091f 356
8ddd72ef
JR
357 ret = lttng_event_serialize(tmp_event, 0, NULL,
358 event->filter_expression, 0, NULL, reply_payload);
359 lttng_event_destroy(tmp_event);
3c02e545 360 if (ret) {
8ddd72ef
JR
361 ret_code = LTTNG_ERR_FATAL;
362 goto error;
3c02e545 363 }
3c6a091f 364 }
3c6a091f 365
47e52862 366end:
8ddd72ef
JR
367 ret_code = LTTNG_OK;
368 *nb_events = local_nb_events;
369error:
3c02e545 370 rcu_read_unlock();
8ddd72ef 371 return ret_code;
3c6a091f
DG
372}
373
2f77fc4b
DG
374/*
375 * Create a list of ust global domain events.
376 */
8ddd72ef 377static enum lttng_error_code list_lttng_ust_global_events(char *channel_name,
b4e3ceb9 378 struct ltt_ust_domain_global *ust_global,
8ddd72ef
JR
379 struct lttng_payload *reply_payload,
380 unsigned int *nb_events)
2f77fc4b 381{
8ddd72ef
JR
382 enum lttng_error_code ret_code;
383 int ret;
2f77fc4b 384 struct lttng_ht_iter iter;
8ddd72ef
JR
385 struct lttng_ht_node_str *node;
386 struct ltt_ust_channel *uchan;
387 struct ltt_ust_event *uevent;
388 unsigned long channel_event_count;
389 unsigned int local_nb_events = 0;
390
391 assert(reply_payload);
392 assert(nb_events);
2f77fc4b
DG
393
394 DBG("Listing UST global events for channel %s", channel_name);
395
396 rcu_read_lock();
397
e368fb43 398 lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter);
2f77fc4b
DG
399 node = lttng_ht_iter_get_node_str(&iter);
400 if (node == NULL) {
8ddd72ef 401 ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND;
e68d8bdb 402 goto error;
2f77fc4b
DG
403 }
404
405 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
406
8ddd72ef
JR
407 channel_event_count = lttng_ht_get_count(uchan->events);
408 if (channel_event_count == 0) {
409 /* Early exit. */
410 ret_code = LTTNG_OK;
411 goto end;
412 }
413
414 if (channel_event_count > UINT_MAX) {
415 ret_code = LTTNG_ERR_OVERFLOW;
416 goto error;
417 }
418
419 local_nb_events = (unsigned int) channel_event_count;
420
421 DBG3("Listing UST global %d events", *nb_events);
2f77fc4b 422
b4e3ceb9 423 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
8ddd72ef 424 struct lttng_event *tmp_event = NULL;
e368fb43 425
b4e3ceb9 426 if (uevent->internal) {
8ddd72ef
JR
427 /* This event should remain hidden from clients */
428 local_nb_events--;
b4e3ceb9
PP
429 continue;
430 }
431
8ddd72ef
JR
432 tmp_event = lttng_event_create();
433 if (!tmp_event) {
434 ret_code = LTTNG_ERR_NOMEM;
e68d8bdb 435 goto error;
43ed1485 436 }
2f77fc4b 437
8ddd72ef
JR
438 if (lttng_strncpy(tmp_event->name, uevent->attr.name,
439 LTTNG_SYMBOL_NAME_LEN)) {
440 ret_code = LTTNG_ERR_FATAL;
441 lttng_event_destroy(tmp_event);
e68d8bdb 442 goto error;
8ddd72ef
JR
443 }
444
445 tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
446 tmp_event->enabled = uevent->enabled;
2f77fc4b
DG
447
448 switch (uevent->attr.instrumentation) {
fc4b93fa 449 case LTTNG_UST_ABI_TRACEPOINT:
8ddd72ef 450 tmp_event->type = LTTNG_EVENT_TRACEPOINT;
2f77fc4b 451 break;
fc4b93fa 452 case LTTNG_UST_ABI_PROBE:
8ddd72ef 453 tmp_event->type = LTTNG_EVENT_PROBE;
2f77fc4b 454 break;
fc4b93fa 455 case LTTNG_UST_ABI_FUNCTION:
8ddd72ef 456 tmp_event->type = LTTNG_EVENT_FUNCTION;
2f77fc4b
DG
457 break;
458 }
459
8ddd72ef 460 tmp_event->loglevel = uevent->attr.loglevel;
2f77fc4b 461 switch (uevent->attr.loglevel_type) {
fc4b93fa 462 case LTTNG_UST_ABI_LOGLEVEL_ALL:
8ddd72ef 463 tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
2f77fc4b 464 break;
fc4b93fa 465 case LTTNG_UST_ABI_LOGLEVEL_RANGE:
8ddd72ef 466 tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
2f77fc4b 467 break;
fc4b93fa 468 case LTTNG_UST_ABI_LOGLEVEL_SINGLE:
8ddd72ef 469 tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
2f77fc4b
DG
470 break;
471 }
472 if (uevent->filter) {
8ddd72ef 473 tmp_event->filter = 1;
2f77fc4b 474 }
4634f12e 475 if (uevent->exclusion) {
8ddd72ef 476 tmp_event->exclusion = 1;
4634f12e 477 }
b4e3ceb9 478
8ddd72ef
JR
479 /*
480 * We do not care about the filter bytecode and the fd from the
481 * userspace_probe_location.
482 */
483 ret = lttng_event_serialize(tmp_event, uevent->exclusion ? uevent->exclusion->count : 0,
484 uevent->exclusion ? (char **) uevent->exclusion ->names : NULL,
485 uevent->filter_expression, 0, NULL, reply_payload);
486 lttng_event_destroy(tmp_event);
3c02e545 487 if (ret) {
8ddd72ef
JR
488 ret_code = LTTNG_ERR_FATAL;
489 goto error;
3c02e545 490 }
2f77fc4b
DG
491 }
492
d31d3e8c 493end:
8ddd72ef
JR
494 /* nb_events is already set at this point. */
495 ret_code = LTTNG_OK;
496 *nb_events = local_nb_events;
497error:
2f77fc4b 498 rcu_read_unlock();
8ddd72ef 499 return ret_code;
2f77fc4b
DG
500}
501
502/*
503 * Fill lttng_event array of all kernel events in the channel.
504 */
8ddd72ef 505static enum lttng_error_code list_lttng_kernel_events(char *channel_name,
b4e3ceb9 506 struct ltt_kernel_session *kernel_session,
8ddd72ef
JR
507 struct lttng_payload *reply_payload,
508 unsigned int *nb_events)
2f77fc4b 509{
8ddd72ef 510 enum lttng_error_code ret_code;
e368fb43 511 int ret;
8ddd72ef
JR
512 struct ltt_kernel_event *event;
513 struct ltt_kernel_channel *kchan;
514
515 assert(reply_payload);
2f77fc4b
DG
516
517 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
518 if (kchan == NULL) {
8ddd72ef
JR
519 ret_code = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
520 goto end;
2f77fc4b
DG
521 }
522
8ddd72ef 523 *nb_events = kchan->event_count;
2f77fc4b
DG
524
525 DBG("Listing events for channel %s", kchan->channel->name);
526
8ddd72ef
JR
527 if (*nb_events == 0) {
528 ret_code = LTTNG_OK;
529 goto end;
530 }
531
e368fb43 532 /* Kernel channels */
8ddd72ef
JR
533 cds_list_for_each_entry(event, &kchan->events_list.head , list) {
534 struct lttng_event *tmp_event = lttng_event_create();
2f77fc4b 535
8ddd72ef
JR
536 if (!tmp_event) {
537 ret_code = LTTNG_ERR_NOMEM;
538 goto end;
539 }
540
541 if (lttng_strncpy(tmp_event->name, event->event->name, LTTNG_SYMBOL_NAME_LEN)) {
542 lttng_event_destroy(tmp_event);
543 ret_code = LTTNG_ERR_FATAL;
43ed1485 544 goto end;
8ddd72ef 545
43ed1485
JG
546 }
547
8ddd72ef
JR
548 tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
549 tmp_event->enabled = event->enabled;
550 tmp_event->filter = (unsigned char) !!event->filter_expression;
b4e3ceb9 551
8ddd72ef 552 switch (event->event->instrumentation) {
b8e2fb80 553 case LTTNG_KERNEL_ABI_TRACEPOINT:
8ddd72ef 554 tmp_event->type = LTTNG_EVENT_TRACEPOINT;
2f77fc4b 555 break;
b8e2fb80 556 case LTTNG_KERNEL_ABI_KRETPROBE:
8ddd72ef
JR
557 tmp_event->type = LTTNG_EVENT_FUNCTION;
558 memcpy(&tmp_event->attr.probe, &event->event->u.kprobe,
b8e2fb80 559 sizeof(struct lttng_kernel_abi_kprobe));
1896972b 560 break;
b8e2fb80 561 case LTTNG_KERNEL_ABI_KPROBE:
8ddd72ef
JR
562 tmp_event->type = LTTNG_EVENT_PROBE;
563 memcpy(&tmp_event->attr.probe, &event->event->u.kprobe,
b8e2fb80 564 sizeof(struct lttng_kernel_abi_kprobe));
2f77fc4b 565 break;
b8e2fb80 566 case LTTNG_KERNEL_ABI_UPROBE:
8ddd72ef 567 tmp_event->type = LTTNG_EVENT_USERSPACE_PROBE;
b955b4d4 568 break;
b8e2fb80 569 case LTTNG_KERNEL_ABI_FUNCTION:
8ddd72ef
JR
570 tmp_event->type = LTTNG_EVENT_FUNCTION;
571 memcpy(&(tmp_event->attr.ftrace), &event->event->u.ftrace,
b8e2fb80 572 sizeof(struct lttng_kernel_abi_function));
2f77fc4b 573 break;
b8e2fb80 574 case LTTNG_KERNEL_ABI_NOOP:
8ddd72ef 575 tmp_event->type = LTTNG_EVENT_NOOP;
2f77fc4b 576 break;
b8e2fb80 577 case LTTNG_KERNEL_ABI_SYSCALL:
8ddd72ef 578 tmp_event->type = LTTNG_EVENT_SYSCALL;
2f77fc4b 579 break;
b8e2fb80 580 case LTTNG_KERNEL_ABI_ALL:
1ab8c2ad
FD
581 /* fall-through. */
582 default:
a0377dfe 583 abort();
2f77fc4b
DG
584 break;
585 }
b4e3ceb9 586
8ddd72ef
JR
587 if (event->userspace_probe_location) {
588 struct lttng_userspace_probe_location *location_copy =
589 lttng_userspace_probe_location_copy(
590 event->userspace_probe_location);
591
592 if (!location_copy) {
593 lttng_event_destroy(tmp_event);
594 ret_code = LTTNG_ERR_NOMEM;
595 goto end;
596 }
597
598 ret = lttng_event_set_userspace_probe_location(
599 tmp_event, location_copy);
600 if (ret) {
601 lttng_event_destroy(tmp_event);
602 lttng_userspace_probe_location_destroy(
603 location_copy);
604 ret_code = LTTNG_ERR_INVALID;
605 goto end;
606 }
e368fb43 607 }
e368fb43 608
8ddd72ef
JR
609 ret = lttng_event_serialize(tmp_event, 0, NULL,
610 event->filter_expression, 0, NULL, reply_payload);
611 lttng_event_destroy(tmp_event);
3c02e545 612 if (ret) {
8ddd72ef
JR
613 ret_code = LTTNG_ERR_FATAL;
614 goto end;
3c02e545 615 }
2f77fc4b
DG
616 }
617
8ddd72ef 618 ret_code = LTTNG_OK;
db906c12 619end:
8ddd72ef 620 return ret_code;
2f77fc4b
DG
621}
622
623/*
624 * Add URI so the consumer output object. Set the correct path depending on the
625 * domain adding the default trace directory.
626 */
b178f53e
JG
627static enum lttng_error_code add_uri_to_consumer(
628 const struct ltt_session *session,
629 struct consumer_output *consumer,
630 struct lttng_uri *uri, enum lttng_domain_type domain)
2f77fc4b 631{
b178f53e
JG
632 int ret;
633 enum lttng_error_code ret_code = LTTNG_OK;
2f77fc4b 634
a0377dfe 635 LTTNG_ASSERT(uri);
2f77fc4b
DG
636
637 if (consumer == NULL) {
638 DBG("No consumer detected. Don't add URI. Stopping.");
b178f53e 639 ret_code = LTTNG_ERR_NO_CONSUMER;
2f77fc4b
DG
640 goto error;
641 }
642
643 switch (domain) {
644 case LTTNG_DOMAIN_KERNEL:
b178f53e
JG
645 ret = lttng_strncpy(consumer->domain_subdir,
646 DEFAULT_KERNEL_TRACE_DIR,
647 sizeof(consumer->domain_subdir));
2f77fc4b
DG
648 break;
649 case LTTNG_DOMAIN_UST:
b178f53e
JG
650 ret = lttng_strncpy(consumer->domain_subdir,
651 DEFAULT_UST_TRACE_DIR,
652 sizeof(consumer->domain_subdir));
2f77fc4b
DG
653 break;
654 default:
655 /*
b178f53e
JG
656 * This case is possible is we try to add the URI to the global
657 * tracing session consumer object which in this case there is
658 * no subdir.
2f77fc4b 659 */
b178f53e
JG
660 memset(consumer->domain_subdir, 0,
661 sizeof(consumer->domain_subdir));
662 ret = 0;
663 }
664 if (ret) {
665 ERR("Failed to initialize consumer output domain subdirectory");
666 ret_code = LTTNG_ERR_FATAL;
667 goto error;
2f77fc4b
DG
668 }
669
670 switch (uri->dtype) {
671 case LTTNG_DST_IPV4:
672 case LTTNG_DST_IPV6:
673 DBG2("Setting network URI to consumer");
674
df75acac
DG
675 if (consumer->type == CONSUMER_DST_NET) {
676 if ((uri->stype == LTTNG_STREAM_CONTROL &&
785d2d0d
DG
677 consumer->dst.net.control_isset) ||
678 (uri->stype == LTTNG_STREAM_DATA &&
679 consumer->dst.net.data_isset)) {
b178f53e 680 ret_code = LTTNG_ERR_URL_EXIST;
df75acac
DG
681 goto error;
682 }
683 } else {
b178f53e 684 memset(&consumer->dst, 0, sizeof(consumer->dst));
785d2d0d
DG
685 }
686
2f77fc4b 687 /* Set URI into consumer output object */
b178f53e 688 ret = consumer_set_network_uri(session, consumer, uri);
2f77fc4b 689 if (ret < 0) {
7966af57 690 ret_code = (lttng_error_code) -ret;
2f77fc4b
DG
691 goto error;
692 } else if (ret == 1) {
693 /*
694 * URI was the same in the consumer so we do not append the subdir
695 * again so to not duplicate output dir.
696 */
b178f53e 697 ret_code = LTTNG_OK;
2f77fc4b
DG
698 goto error;
699 }
2f77fc4b
DG
700 break;
701 case LTTNG_DST_PATH:
b178f53e
JG
702 if (*uri->dst.path != '/' || strstr(uri->dst.path, "../")) {
703 ret_code = LTTNG_ERR_INVALID;
9ac05d92
MD
704 goto error;
705 }
b178f53e
JG
706 DBG2("Setting trace directory path from URI to %s",
707 uri->dst.path);
708 memset(&consumer->dst, 0, sizeof(consumer->dst));
709
710 ret = lttng_strncpy(consumer->dst.session_root_path,
711 uri->dst.path,
712 sizeof(consumer->dst.session_root_path));
4df41cad
JG
713 if (ret) {
714 ret_code = LTTNG_ERR_FATAL;
715 goto error;
716 }
2f77fc4b
DG
717 consumer->type = CONSUMER_DST_LOCAL;
718 break;
719 }
720
b178f53e 721 ret_code = LTTNG_OK;
2f77fc4b 722error:
b178f53e 723 return ret_code;
2f77fc4b
DG
724}
725
726/*
727 * Init tracing by creating trace directory and sending fds kernel consumer.
728 */
729static int init_kernel_tracing(struct ltt_kernel_session *session)
730{
731 int ret = 0;
732 struct lttng_ht_iter iter;
733 struct consumer_socket *socket;
734
a0377dfe 735 LTTNG_ASSERT(session);
2f77fc4b 736
e7fe706f
DG
737 rcu_read_lock();
738
2f77fc4b
DG
739 if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
740 cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
741 socket, node.node) {
2f77fc4b 742 pthread_mutex_lock(socket->lock);
f50f23d9 743 ret = kernel_consumer_send_session(socket, session);
2f77fc4b
DG
744 pthread_mutex_unlock(socket->lock);
745 if (ret < 0) {
f73fabfd 746 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
747 goto error;
748 }
749 }
750 }
751
752error:
e7fe706f 753 rcu_read_unlock();
2f77fc4b
DG
754 return ret;
755}
756
757/*
758 * Create a socket to the relayd using the URI.
759 *
760 * On success, the relayd_sock pointer is set to the created socket.
9a654598 761 * Else, it remains untouched and an LTTng error code is returned.
2f77fc4b 762 */
9a654598 763static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
b31610f2
JD
764 struct lttcomm_relayd_sock **relayd_sock,
765 struct consumer_output *consumer)
2f77fc4b
DG
766{
767 int ret;
9a654598 768 enum lttng_error_code status = LTTNG_OK;
6151a90f 769 struct lttcomm_relayd_sock *rsock;
2f77fc4b 770
6151a90f
JD
771 rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
772 RELAYD_VERSION_COMM_MINOR);
773 if (!rsock) {
9a654598 774 status = LTTNG_ERR_FATAL;
2f77fc4b
DG
775 goto error;
776 }
777
ffe60014
DG
778 /*
779 * Connect to relayd so we can proceed with a session creation. This call
780 * can possibly block for an arbitrary amount of time to set the health
781 * state to be in poll execution.
782 */
783 health_poll_entry();
6151a90f 784 ret = relayd_connect(rsock);
ffe60014 785 health_poll_exit();
2f77fc4b
DG
786 if (ret < 0) {
787 ERR("Unable to reach lttng-relayd");
9a654598 788 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
2f77fc4b
DG
789 goto free_sock;
790 }
791
792 /* Create socket for control stream. */
793 if (uri->stype == LTTNG_STREAM_CONTROL) {
eacb7b6f
MD
794 uint64_t result_flags;
795
2f77fc4b
DG
796 DBG3("Creating relayd stream socket from URI");
797
798 /* Check relayd version */
6151a90f 799 ret = relayd_version_check(rsock);
67d5aa28 800 if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) {
9a654598 801 status = LTTNG_ERR_RELAYD_VERSION_FAIL;
67d5aa28
JD
802 goto close_sock;
803 } else if (ret < 0) {
804 ERR("Unable to reach lttng-relayd");
9a654598 805 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
2f77fc4b
DG
806 goto close_sock;
807 }
b31610f2
JD
808 consumer->relay_major_version = rsock->major;
809 consumer->relay_minor_version = rsock->minor;
eacb7b6f
MD
810 ret = relayd_get_configuration(rsock, 0,
811 &result_flags);
812 if (ret < 0) {
813 ERR("Unable to get relayd configuration");
814 status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
815 goto close_sock;
816 }
817 if (result_flags & LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED) {
818 consumer->relay_allows_clear = true;
819 }
2f77fc4b
DG
820 } else if (uri->stype == LTTNG_STREAM_DATA) {
821 DBG3("Creating relayd data socket from URI");
822 } else {
823 /* Command is not valid */
824 ERR("Relayd invalid stream type: %d", uri->stype);
9a654598 825 status = LTTNG_ERR_INVALID;
2f77fc4b
DG
826 goto close_sock;
827 }
828
6151a90f 829 *relayd_sock = rsock;
2f77fc4b 830
9a654598 831 return status;
2f77fc4b
DG
832
833close_sock:
6151a90f
JD
834 /* The returned value is not useful since we are on an error path. */
835 (void) relayd_close(rsock);
2f77fc4b 836free_sock:
6151a90f 837 free(rsock);
2f77fc4b 838error:
9a654598 839 return status;
2f77fc4b
DG
840}
841
842/*
843 * Connect to the relayd using URI and send the socket to the right consumer.
43fade62
JG
844 *
845 * The consumer socket lock must be held by the caller.
9a654598
JG
846 *
847 * Returns LTTNG_OK on success or an LTTng error code on failure.
2f77fc4b 848 */
9a654598
JG
849static enum lttng_error_code send_consumer_relayd_socket(
850 unsigned int session_id,
3044f922 851 struct lttng_uri *relayd_uri,
56a37563 852 struct consumer_output *consumer,
d3e2ba59 853 struct consumer_socket *consumer_sock,
fb9a95c4 854 const char *session_name, const char *hostname,
6fa5fe7c 855 const char *base_path, int session_live_timer,
0e270a1e 856 const uint64_t *current_chunk_id,
46ef2188
MD
857 time_t session_creation_time,
858 bool session_name_contains_creation_time)
2f77fc4b
DG
859{
860 int ret;
6151a90f 861 struct lttcomm_relayd_sock *rsock = NULL;
9a654598 862 enum lttng_error_code status;
2f77fc4b 863
ffe60014 864 /* Connect to relayd and make version check if uri is the control. */
9a654598
JG
865 status = create_connect_relayd(relayd_uri, &rsock, consumer);
866 if (status != LTTNG_OK) {
9e218353 867 goto relayd_comm_error;
ffe60014 868 }
a0377dfe 869 LTTNG_ASSERT(rsock);
ffe60014 870
2f77fc4b 871 /* Set the network sequence index if not set. */
d88aee68
DG
872 if (consumer->net_seq_index == (uint64_t) -1ULL) {
873 pthread_mutex_lock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
874 /*
875 * Increment net_seq_idx because we are about to transfer the
876 * new relayd socket to the consumer.
d88aee68 877 * Assign unique key so the consumer can match streams.
2f77fc4b 878 */
d88aee68
DG
879 consumer->net_seq_index = ++relayd_net_seq_idx;
880 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
881 }
882
2f77fc4b 883 /* Send relayd socket to consumer. */
6151a90f 884 ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
d3e2ba59 885 relayd_uri->stype, session_id,
6fa5fe7c
MD
886 session_name, hostname, base_path,
887 session_live_timer, current_chunk_id,
46ef2188 888 session_creation_time, session_name_contains_creation_time);
2f77fc4b 889 if (ret < 0) {
9a654598 890 status = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2f77fc4b
DG
891 goto close_sock;
892 }
893
c890b720
DG
894 /* Flag that the corresponding socket was sent. */
895 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
ffe60014 896 consumer_sock->control_sock_sent = 1;
c890b720 897 } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
ffe60014 898 consumer_sock->data_sock_sent = 1;
c890b720
DG
899 }
900
2f77fc4b
DG
901 /*
902 * Close socket which was dup on the consumer side. The session daemon does
903 * NOT keep track of the relayd socket(s) once transfer to the consumer.
904 */
905
906close_sock:
9a654598 907 if (status != LTTNG_OK) {
ffe60014 908 /*
d9078d0c
DG
909 * The consumer output for this session should not be used anymore
910 * since the relayd connection failed thus making any tracing or/and
911 * streaming not usable.
ffe60014 912 */
d9078d0c 913 consumer->enabled = 0;
ffe60014 914 }
9e218353
JR
915 (void) relayd_close(rsock);
916 free(rsock);
917
918relayd_comm_error:
9a654598 919 return status;
2f77fc4b
DG
920}
921
922/*
923 * Send both relayd sockets to a specific consumer and domain. This is a
924 * helper function to facilitate sending the information to the consumer for a
925 * session.
43fade62
JG
926 *
927 * The consumer socket lock must be held by the caller.
9a654598
JG
928 *
929 * Returns LTTNG_OK, or an LTTng error code on failure.
2f77fc4b 930 */
9a654598 931static enum lttng_error_code send_consumer_relayd_sockets(
56a37563 932 unsigned int session_id, struct consumer_output *consumer,
fb9a95c4 933 struct consumer_socket *sock, const char *session_name,
6fa5fe7c 934 const char *hostname, const char *base_path, int session_live_timer,
46ef2188
MD
935 const uint64_t *current_chunk_id, time_t session_creation_time,
936 bool session_name_contains_creation_time)
2f77fc4b 937{
9a654598 938 enum lttng_error_code status = LTTNG_OK;
2f77fc4b 939
a0377dfe
FD
940 LTTNG_ASSERT(consumer);
941 LTTNG_ASSERT(sock);
2f77fc4b 942
2f77fc4b 943 /* Sending control relayd socket. */
ffe60014 944 if (!sock->control_sock_sent) {
9a654598 945 status = send_consumer_relayd_socket(session_id,
d3e2ba59 946 &consumer->dst.net.control, consumer, sock,
6fa5fe7c 947 session_name, hostname, base_path, session_live_timer,
46ef2188
MD
948 current_chunk_id, session_creation_time,
949 session_name_contains_creation_time);
9a654598 950 if (status != LTTNG_OK) {
c890b720
DG
951 goto error;
952 }
2f77fc4b
DG
953 }
954
955 /* Sending data relayd socket. */
ffe60014 956 if (!sock->data_sock_sent) {
9a654598 957 status = send_consumer_relayd_socket(session_id,
d3e2ba59 958 &consumer->dst.net.data, consumer, sock,
6fa5fe7c 959 session_name, hostname, base_path, session_live_timer,
46ef2188
MD
960 current_chunk_id, session_creation_time,
961 session_name_contains_creation_time);
9a654598 962 if (status != LTTNG_OK) {
c890b720
DG
963 goto error;
964 }
2f77fc4b
DG
965 }
966
2f77fc4b 967error:
9a654598 968 return status;
2f77fc4b
DG
969}
970
971/*
972 * Setup relayd connections for a tracing session. First creates the socket to
973 * the relayd and send them to the right domain consumer. Consumer type MUST be
974 * network.
975 */
ffe60014 976int cmd_setup_relayd(struct ltt_session *session)
2f77fc4b 977{
f73fabfd 978 int ret = LTTNG_OK;
2f77fc4b
DG
979 struct ltt_ust_session *usess;
980 struct ltt_kernel_session *ksess;
981 struct consumer_socket *socket;
982 struct lttng_ht_iter iter;
0e270a1e 983 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
2f77fc4b 984
a0377dfe 985 LTTNG_ASSERT(session);
2f77fc4b
DG
986
987 usess = session->ust_session;
988 ksess = session->kernel_session;
989
785d2d0d 990 DBG("Setting relayd for session %s", session->name);
2f77fc4b 991
aa997ea3 992 rcu_read_lock();
1e791a74
JG
993 if (session->current_trace_chunk) {
994 enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
995 session->current_trace_chunk, &current_chunk_id.value);
996
997 if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
998 current_chunk_id.is_set = true;
999 } else {
1000 ERR("Failed to get current trace chunk id");
1001 ret = LTTNG_ERR_UNK;
1002 goto error;
1003 }
1004 }
1005
2f77fc4b
DG
1006 if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
1007 && usess->consumer->enabled) {
1008 /* For each consumer socket, send relayd sockets */
1009 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
1010 socket, node.node) {
2f77fc4b 1011 pthread_mutex_lock(socket->lock);
f46376a1 1012 ret = send_consumer_relayd_sockets(session->id,
d3e2ba59
JD
1013 usess->consumer, socket,
1014 session->name, session->hostname,
6fa5fe7c 1015 session->base_path,
1e791a74 1016 session->live_timer,
db1da059 1017 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
1018 session->creation_time,
1019 session->name_contains_creation_time);
2f77fc4b 1020 pthread_mutex_unlock(socket->lock);
f73fabfd 1021 if (ret != LTTNG_OK) {
2f77fc4b
DG
1022 goto error;
1023 }
6dc3064a
DG
1024 /* Session is now ready for network streaming. */
1025 session->net_handle = 1;
2f77fc4b 1026 }
b31610f2
JD
1027 session->consumer->relay_major_version =
1028 usess->consumer->relay_major_version;
1029 session->consumer->relay_minor_version =
1030 usess->consumer->relay_minor_version;
eacb7b6f
MD
1031 session->consumer->relay_allows_clear =
1032 usess->consumer->relay_allows_clear;
2f77fc4b
DG
1033 }
1034
1035 if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
1036 && ksess->consumer->enabled) {
1037 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1038 socket, node.node) {
2f77fc4b 1039 pthread_mutex_lock(socket->lock);
f46376a1 1040 ret = send_consumer_relayd_sockets(session->id,
d3e2ba59
JD
1041 ksess->consumer, socket,
1042 session->name, session->hostname,
6fa5fe7c 1043 session->base_path,
1e791a74 1044 session->live_timer,
db1da059 1045 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
1046 session->creation_time,
1047 session->name_contains_creation_time);
2f77fc4b 1048 pthread_mutex_unlock(socket->lock);
f73fabfd 1049 if (ret != LTTNG_OK) {
2f77fc4b
DG
1050 goto error;
1051 }
6dc3064a
DG
1052 /* Session is now ready for network streaming. */
1053 session->net_handle = 1;
2f77fc4b 1054 }
b31610f2
JD
1055 session->consumer->relay_major_version =
1056 ksess->consumer->relay_major_version;
1057 session->consumer->relay_minor_version =
1058 ksess->consumer->relay_minor_version;
eacb7b6f
MD
1059 session->consumer->relay_allows_clear =
1060 ksess->consumer->relay_allows_clear;
2f77fc4b
DG
1061 }
1062
1063error:
e7fe706f 1064 rcu_read_unlock();
2f77fc4b
DG
1065 return ret;
1066}
1067
9b6c7ec5
DG
1068/*
1069 * Start a kernel session by opening all necessary streams.
1070 */
4dbe1875 1071int start_kernel_session(struct ltt_kernel_session *ksess)
9b6c7ec5
DG
1072{
1073 int ret;
1074 struct ltt_kernel_channel *kchan;
1075
1076 /* Open kernel metadata */
07b86b52 1077 if (ksess->metadata == NULL && ksess->output_traces) {
9b6c7ec5
DG
1078 ret = kernel_open_metadata(ksess);
1079 if (ret < 0) {
1080 ret = LTTNG_ERR_KERN_META_FAIL;
1081 goto error;
1082 }
1083 }
1084
1085 /* Open kernel metadata stream */
07b86b52 1086 if (ksess->metadata && ksess->metadata_stream_fd < 0) {
9b6c7ec5
DG
1087 ret = kernel_open_metadata_stream(ksess);
1088 if (ret < 0) {
1089 ERR("Kernel create metadata stream failed");
1090 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1091 goto error;
1092 }
1093 }
1094
1095 /* For each channel */
1096 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1097 if (kchan->stream_count == 0) {
1098 ret = kernel_open_channel_stream(kchan);
1099 if (ret < 0) {
1100 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1101 goto error;
1102 }
1103 /* Update the stream global counter */
1104 ksess->stream_count_global += ret;
1105 }
1106 }
1107
1108 /* Setup kernel consumer socket and send fds to it */
1109 ret = init_kernel_tracing(ksess);
e43c41c5 1110 if (ret != 0) {
9b6c7ec5
DG
1111 ret = LTTNG_ERR_KERN_START_FAIL;
1112 goto error;
1113 }
1114
1115 /* This start the kernel tracing */
1116 ret = kernel_start_session(ksess);
1117 if (ret < 0) {
1118 ret = LTTNG_ERR_KERN_START_FAIL;
1119 goto error;
1120 }
1121
1122 /* Quiescent wait after starting trace */
7d268848 1123 kernel_wait_quiescent();
9b6c7ec5 1124
14fb1ebe 1125 ksess->active = 1;
9b6c7ec5
DG
1126
1127 ret = LTTNG_OK;
1128
1129error:
1130 return ret;
1131}
1132
4dbe1875
MD
1133int stop_kernel_session(struct ltt_kernel_session *ksess)
1134{
1135 struct ltt_kernel_channel *kchan;
1136 bool error_occurred = false;
1137 int ret;
1138
1139 if (!ksess || !ksess->active) {
1140 return LTTNG_OK;
1141 }
1142 DBG("Stopping kernel tracing");
1143
1144 ret = kernel_stop_session(ksess);
1145 if (ret < 0) {
1146 ret = LTTNG_ERR_KERN_STOP_FAIL;
1147 goto error;
1148 }
1149
1150 kernel_wait_quiescent();
1151
1152 /* Flush metadata after stopping (if exists) */
1153 if (ksess->metadata_stream_fd >= 0) {
1154 ret = kernel_metadata_flush_buffer(ksess->metadata_stream_fd);
1155 if (ret < 0) {
1156 ERR("Kernel metadata flush failed");
1157 error_occurred = true;
1158 }
1159 }
1160
1161 /* Flush all buffers after stopping */
1162 cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
1163 ret = kernel_flush_buffer(kchan);
1164 if (ret < 0) {
1165 ERR("Kernel flush buffer error");
1166 error_occurred = true;
1167 }
1168 }
1169
1170 ksess->active = 0;
1171 if (error_occurred) {
1172 ret = LTTNG_ERR_UNK;
1173 } else {
1174 ret = LTTNG_OK;
1175 }
1176error:
1177 return ret;
1178}
1179
2f77fc4b
DG
1180/*
1181 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
1182 */
56a37563
JG
1183int cmd_disable_channel(struct ltt_session *session,
1184 enum lttng_domain_type domain, char *channel_name)
2f77fc4b
DG
1185{
1186 int ret;
1187 struct ltt_ust_session *usess;
1188
1189 usess = session->ust_session;
1190
2223c96f
DG
1191 rcu_read_lock();
1192
2f77fc4b
DG
1193 switch (domain) {
1194 case LTTNG_DOMAIN_KERNEL:
1195 {
1196 ret = channel_kernel_disable(session->kernel_session,
1197 channel_name);
f73fabfd 1198 if (ret != LTTNG_OK) {
2f77fc4b
DG
1199 goto error;
1200 }
1201
7d268848 1202 kernel_wait_quiescent();
2f77fc4b
DG
1203 break;
1204 }
1205 case LTTNG_DOMAIN_UST:
1206 {
1207 struct ltt_ust_channel *uchan;
1208 struct lttng_ht *chan_ht;
1209
1210 chan_ht = usess->domain_global.channels;
1211
1212 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
1213 if (uchan == NULL) {
f73fabfd 1214 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
2f77fc4b
DG
1215 goto error;
1216 }
1217
7972aab2 1218 ret = channel_ust_disable(usess, uchan);
f73fabfd 1219 if (ret != LTTNG_OK) {
2f77fc4b
DG
1220 goto error;
1221 }
1222 break;
1223 }
2f77fc4b 1224 default:
f73fabfd 1225 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1226 goto error;
1227 }
1228
f73fabfd 1229 ret = LTTNG_OK;
2f77fc4b
DG
1230
1231error:
2223c96f 1232 rcu_read_unlock();
2f77fc4b
DG
1233 return ret;
1234}
1235
1236/*
1237 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1238 *
1239 * The wpipe arguments is used as a notifier for the kernel thread.
1240 */
999af9c1
JR
1241int cmd_enable_channel(struct command_ctx *cmd_ctx, int sock, int wpipe)
1242{
1243 int ret;
1244 size_t channel_len;
1245 ssize_t sock_recv_len;
1246 struct lttng_channel *channel = NULL;
1247 struct lttng_buffer_view view;
1248 struct lttng_dynamic_buffer channel_buffer;
1249 const struct lttng_domain command_domain = cmd_ctx->lsm.domain;
1250
1251 lttng_dynamic_buffer_init(&channel_buffer);
1252 channel_len = (size_t) cmd_ctx->lsm.u.channel.length;
1253 ret = lttng_dynamic_buffer_set_size(&channel_buffer, channel_len);
1254 if (ret) {
1255 ret = LTTNG_ERR_NOMEM;
1256 goto end;
1257 }
1258
1259 sock_recv_len = lttcomm_recv_unix_sock(sock, channel_buffer.data,
1260 channel_len);
1261 if (sock_recv_len < 0 || sock_recv_len != channel_len) {
1262 ERR("Failed to receive \"enable channel\" command payload");
1263 ret = LTTNG_ERR_INVALID;
1264 goto end;
1265 }
1266
1267 view = lttng_buffer_view_from_dynamic_buffer(&channel_buffer, 0, channel_len);
1268 if (!lttng_buffer_view_is_valid(&view)) {
1269 ret = LTTNG_ERR_INVALID;
1270 goto end;
1271 }
1272
1273 if (lttng_channel_create_from_buffer(&view, &channel) != channel_len) {
1274 ERR("Invalid channel payload received in \"enable channel\" command");
1275 ret = LTTNG_ERR_INVALID;
1276 goto end;
1277 }
1278
1279 ret = cmd_enable_channel_internal(
1280 cmd_ctx->session, &command_domain, channel, wpipe);
1281
1282end:
1283 lttng_dynamic_buffer_reset(&channel_buffer);
1284 lttng_channel_destroy(channel);
1285 return ret;
1286}
1287
4878de5c
JG
1288static enum lttng_error_code cmd_enable_channel_internal(
1289 struct ltt_session *session,
999af9c1
JR
1290 const struct lttng_domain *domain,
1291 const struct lttng_channel *_attr,
1292 int wpipe)
2f77fc4b 1293{
4878de5c 1294 enum lttng_error_code ret_code;
2f77fc4b
DG
1295 struct ltt_ust_session *usess = session->ust_session;
1296 struct lttng_ht *chan_ht;
1f345e94 1297 size_t len;
999af9c1 1298 struct lttng_channel *attr = NULL;
2f77fc4b 1299
a0377dfe
FD
1300 LTTNG_ASSERT(session);
1301 LTTNG_ASSERT(_attr);
1302 LTTNG_ASSERT(domain);
2f77fc4b 1303
999af9c1
JR
1304 attr = lttng_channel_copy(_attr);
1305 if (!attr) {
4878de5c 1306 ret_code = LTTNG_ERR_NOMEM;
999af9c1
JR
1307 goto end;
1308 }
1309
1310 len = lttng_strnlen(attr->name, sizeof(attr->name));
1f345e94
PP
1311
1312 /* Validate channel name */
999af9c1
JR
1313 if (attr->name[0] == '.' ||
1314 memchr(attr->name, '/', len) != NULL) {
4878de5c 1315 ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
1f345e94
PP
1316 goto end;
1317 }
1318
999af9c1 1319 DBG("Enabling channel %s for session %s", attr->name, session->name);
2f77fc4b 1320
03b4fdcf
DG
1321 rcu_read_lock();
1322
ecc48a90
JD
1323 /*
1324 * If the session is a live session, remove the switch timer, the
1325 * live timer does the same thing but sends also synchronisation
1326 * beacons for inactive streams.
1327 */
1328 if (session->live_timer > 0) {
999af9c1
JR
1329 attr->attr.live_timer_interval = session->live_timer;
1330 attr->attr.switch_timer_interval = 0;
ecc48a90
JD
1331 }
1332
6e21424e
JR
1333 /* Check for feature support */
1334 switch (domain->type) {
1335 case LTTNG_DOMAIN_KERNEL:
1336 {
7d268848 1337 if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) {
6e21424e
JR
1338 /* Sampling position of buffer is not supported */
1339 WARN("Kernel tracer does not support buffer monitoring. "
1340 "Setting the monitor interval timer to 0 "
1341 "(disabled) for channel '%s' of session '%s'",
999af9c1
JR
1342 attr->name, session->name);
1343 lttng_channel_set_monitor_timer_interval(attr, 0);
6e21424e
JR
1344 }
1345 break;
1346 }
1347 case LTTNG_DOMAIN_UST:
f28f9e44 1348 break;
6e21424e
JR
1349 case LTTNG_DOMAIN_JUL:
1350 case LTTNG_DOMAIN_LOG4J:
1351 case LTTNG_DOMAIN_PYTHON:
f28f9e44
JG
1352 if (!agent_tracing_is_enabled()) {
1353 DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
4878de5c 1354 ret_code = LTTNG_ERR_AGENT_TRACING_DISABLED;
f28f9e44
JG
1355 goto error;
1356 }
6e21424e
JR
1357 break;
1358 default:
4878de5c 1359 ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
6e21424e
JR
1360 goto error;
1361 }
1362
7972aab2 1363 switch (domain->type) {
2f77fc4b
DG
1364 case LTTNG_DOMAIN_KERNEL:
1365 {
1366 struct ltt_kernel_channel *kchan;
1367
999af9c1
JR
1368 kchan = trace_kernel_get_channel_by_name(
1369 attr->name, session->kernel_session);
2f77fc4b 1370 if (kchan == NULL) {
8cc65d5c
JR
1371 /*
1372 * Don't try to create a channel if the session has been started at
1373 * some point in time before. The tracer does not allow it.
1374 */
1375 if (session->has_been_started) {
4878de5c 1376 ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
8cc65d5c
JR
1377 goto error;
1378 }
1379
54213acc
JG
1380 if (session->snapshot.nb_output > 0 ||
1381 session->snapshot_mode) {
1382 /* Enforce mmap output for snapshot sessions. */
999af9c1 1383 attr->attr.output = LTTNG_EVENT_MMAP;
54213acc 1384 }
4878de5c 1385 ret_code = channel_kernel_create(
999af9c1
JR
1386 session->kernel_session, attr, wpipe);
1387 if (attr->name[0] != '\0') {
85076754
MD
1388 session->kernel_session->has_non_default_channel = 1;
1389 }
2f77fc4b 1390 } else {
4878de5c 1391 ret_code = channel_kernel_enable(session->kernel_session, kchan);
2f77fc4b
DG
1392 }
1393
4878de5c 1394 if (ret_code != LTTNG_OK) {
2f77fc4b
DG
1395 goto error;
1396 }
1397
7d268848 1398 kernel_wait_quiescent();
2f77fc4b
DG
1399 break;
1400 }
1401 case LTTNG_DOMAIN_UST:
9232818f
JG
1402 case LTTNG_DOMAIN_JUL:
1403 case LTTNG_DOMAIN_LOG4J:
1404 case LTTNG_DOMAIN_PYTHON:
2f77fc4b
DG
1405 {
1406 struct ltt_ust_channel *uchan;
1407
9232818f
JG
1408 /*
1409 * FIXME
1410 *
1411 * Current agent implementation limitations force us to allow
1412 * only one channel at once in "agent" subdomains. Each
1413 * subdomain has a default channel name which must be strictly
1414 * adhered to.
1415 */
1416 if (domain->type == LTTNG_DOMAIN_JUL) {
999af9c1 1417 if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
9232818f 1418 LTTNG_SYMBOL_NAME_LEN)) {
4878de5c 1419 ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
9232818f
JG
1420 goto error;
1421 }
1422 } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
999af9c1 1423 if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
9232818f 1424 LTTNG_SYMBOL_NAME_LEN)) {
4878de5c 1425 ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
9232818f
JG
1426 goto error;
1427 }
1428 } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
999af9c1 1429 if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
9232818f 1430 LTTNG_SYMBOL_NAME_LEN)) {
4878de5c 1431 ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
9232818f
JG
1432 goto error;
1433 }
1434 }
1435
2f77fc4b
DG
1436 chan_ht = usess->domain_global.channels;
1437
999af9c1 1438 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
2f77fc4b 1439 if (uchan == NULL) {
8cc65d5c
JR
1440 /*
1441 * Don't try to create a channel if the session has been started at
1442 * some point in time before. The tracer does not allow it.
1443 */
1444 if (session->has_been_started) {
4878de5c 1445 ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
8cc65d5c
JR
1446 goto error;
1447 }
1448
4878de5c 1449 ret_code = channel_ust_create(usess, attr, domain->buf_type);
999af9c1 1450 if (attr->name[0] != '\0') {
85076754
MD
1451 usess->has_non_default_channel = 1;
1452 }
2f77fc4b 1453 } else {
4878de5c 1454 ret_code = channel_ust_enable(usess, uchan);
2f77fc4b
DG
1455 }
1456 break;
1457 }
2f77fc4b 1458 default:
4878de5c 1459 ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
2f77fc4b
DG
1460 goto error;
1461 }
1462
4878de5c 1463 if (ret_code == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
54213acc
JG
1464 session->has_non_mmap_channel = true;
1465 }
2f77fc4b 1466error:
2223c96f 1467 rcu_read_unlock();
1f345e94 1468end:
999af9c1 1469 lttng_channel_destroy(attr);
4878de5c 1470 return ret_code;
2f77fc4b
DG
1471}
1472
159b042f
JG
1473enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy(
1474 struct ltt_session *session,
1475 enum lttng_domain_type domain,
1476 enum lttng_process_attr process_attr,
1477 enum lttng_tracking_policy *policy)
1478{
1479 enum lttng_error_code ret_code = LTTNG_OK;
1480 const struct process_attr_tracker *tracker;
1481
1482 switch (domain) {
1483 case LTTNG_DOMAIN_KERNEL:
1484 if (!session->kernel_session) {
1485 ret_code = LTTNG_ERR_INVALID;
1486 goto end;
1487 }
1488 tracker = kernel_get_process_attr_tracker(
1489 session->kernel_session, process_attr);
1490 break;
1491 case LTTNG_DOMAIN_UST:
1492 if (!session->ust_session) {
1493 ret_code = LTTNG_ERR_INVALID;
1494 goto end;
1495 }
1496 tracker = trace_ust_get_process_attr_tracker(
1497 session->ust_session, process_attr);
1498 break;
1499 default:
1500 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1501 goto end;
1502 }
1503 if (tracker) {
1504 *policy = process_attr_tracker_get_tracking_policy(tracker);
1505 } else {
1506 ret_code = LTTNG_ERR_INVALID;
1507 }
1508end:
1509 return ret_code;
1510}
1511
1512enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy(
1513 struct ltt_session *session,
1514 enum lttng_domain_type domain,
1515 enum lttng_process_attr process_attr,
1516 enum lttng_tracking_policy policy)
1517{
1518 enum lttng_error_code ret_code = LTTNG_OK;
1519
1520 switch (policy) {
1521 case LTTNG_TRACKING_POLICY_INCLUDE_SET:
1522 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
1523 case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
1524 break;
1525 default:
1526 ret_code = LTTNG_ERR_INVALID;
1527 goto end;
1528 }
1529
1530 switch (domain) {
1531 case LTTNG_DOMAIN_KERNEL:
1532 if (!session->kernel_session) {
1533 ret_code = LTTNG_ERR_INVALID;
1534 goto end;
1535 }
1536 ret_code = kernel_process_attr_tracker_set_tracking_policy(
1537 session->kernel_session, process_attr, policy);
1538 break;
1539 case LTTNG_DOMAIN_UST:
1540 if (!session->ust_session) {
1541 ret_code = LTTNG_ERR_INVALID;
1542 goto end;
1543 }
1544 ret_code = trace_ust_process_attr_tracker_set_tracking_policy(
1545 session->ust_session, process_attr, policy);
1546 break;
1547 default:
1548 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1549 break;
1550 }
1551end:
1552 return ret_code;
1553}
1554
1555enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value(
1556 struct ltt_session *session,
1557 enum lttng_domain_type domain,
1558 enum lttng_process_attr process_attr,
1559 const struct process_attr_value *value)
1560{
1561 enum lttng_error_code ret_code = LTTNG_OK;
1562
1563 switch (domain) {
1564 case LTTNG_DOMAIN_KERNEL:
1565 if (!session->kernel_session) {
1566 ret_code = LTTNG_ERR_INVALID;
1567 goto end;
1568 }
1569 ret_code = kernel_process_attr_tracker_inclusion_set_add_value(
1570 session->kernel_session, process_attr, value);
1571 break;
1572 case LTTNG_DOMAIN_UST:
1573 if (!session->ust_session) {
1574 ret_code = LTTNG_ERR_INVALID;
1575 goto end;
1576 }
1577 ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value(
1578 session->ust_session, process_attr, value);
1579 break;
1580 default:
1581 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1582 break;
1583 }
1584end:
1585 return ret_code;
1586}
1587
1588enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value(
1589 struct ltt_session *session,
1590 enum lttng_domain_type domain,
1591 enum lttng_process_attr process_attr,
1592 const struct process_attr_value *value)
1593{
1594 enum lttng_error_code ret_code = LTTNG_OK;
1595
1596 switch (domain) {
1597 case LTTNG_DOMAIN_KERNEL:
1598 if (!session->kernel_session) {
1599 ret_code = LTTNG_ERR_INVALID;
1600 goto end;
1601 }
1602 ret_code = kernel_process_attr_tracker_inclusion_set_remove_value(
1603 session->kernel_session, process_attr, value);
1604 break;
1605 case LTTNG_DOMAIN_UST:
1606 if (!session->ust_session) {
1607 ret_code = LTTNG_ERR_INVALID;
1608 goto end;
1609 }
1610 ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value(
1611 session->ust_session, process_attr, value);
1612 break;
1613 default:
1614 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1615 break;
1616 }
1617end:
1618 return ret_code;
1619}
1620
1621enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set(
1622 struct ltt_session *session,
1623 enum lttng_domain_type domain,
1624 enum lttng_process_attr process_attr,
1625 struct lttng_process_attr_values **values)
1626{
1627 enum lttng_error_code ret_code = LTTNG_OK;
1628 const struct process_attr_tracker *tracker;
1629 enum process_attr_tracker_status status;
1630
1631 switch (domain) {
1632 case LTTNG_DOMAIN_KERNEL:
1633 if (!session->kernel_session) {
1634 ret_code = LTTNG_ERR_INVALID;
1635 goto end;
1636 }
1637 tracker = kernel_get_process_attr_tracker(
1638 session->kernel_session, process_attr);
1639 break;
1640 case LTTNG_DOMAIN_UST:
1641 if (!session->ust_session) {
1642 ret_code = LTTNG_ERR_INVALID;
1643 goto end;
1644 }
1645 tracker = trace_ust_get_process_attr_tracker(
1646 session->ust_session, process_attr);
1647 break;
1648 default:
1649 ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
1650 goto end;
1651 }
1652
1653 if (!tracker) {
1654 ret_code = LTTNG_ERR_INVALID;
1655 goto end;
1656 }
1657
1658 status = process_attr_tracker_get_inclusion_set(tracker, values);
1659 switch (status) {
1660 case PROCESS_ATTR_TRACKER_STATUS_OK:
1661 ret_code = LTTNG_OK;
1662 break;
1663 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
1664 ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
1665 break;
1666 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
1667 ret_code = LTTNG_ERR_NOMEM;
1668 break;
1669 default:
1670 ret_code = LTTNG_ERR_UNK;
1671 break;
1672 }
1673
1674end:
1675 return ret_code;
1676}
1677
2f77fc4b
DG
1678/*
1679 * Command LTTNG_DISABLE_EVENT processed by the client thread.
1680 */
8ddd72ef
JR
1681int cmd_disable_event(struct command_ctx *cmd_ctx,
1682 struct lttng_event *event,
1683 char *filter_expression,
1684 struct lttng_bytecode *bytecode,
1685 struct lttng_event_exclusion *exclusion)
2f77fc4b
DG
1686{
1687 int ret;
df4f5a87 1688 const char *event_name;
8ddd72ef
JR
1689 const struct ltt_session *session = cmd_ctx->session;
1690 const char *channel_name = cmd_ctx->lsm.u.disable.channel_name;
1691 const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type;
6e911cad 1692
18a720cd
MD
1693 DBG("Disable event command for event \'%s\'", event->name);
1694
8ddd72ef
JR
1695 /*
1696 * Filter and exclusions are simply not handled by the
1697 * disable event command at this time.
1698 *
1699 * FIXME
1700 */
1701 (void) filter_expression;
1702 (void) exclusion;
1703
1704 /* Ignore the presence of filter or exclusion for the event */
1705 event->filter = 0;
1706 event->exclusion = 0;
1707
6e911cad
MD
1708 event_name = event->name;
1709
9b7431cf
JG
1710 /* Error out on unhandled search criteria */
1711 if (event->loglevel_type || event->loglevel != -1 || event->enabled
6e911cad 1712 || event->pid || event->filter || event->exclusion) {
7076b56e
JG
1713 ret = LTTNG_ERR_UNK;
1714 goto error;
6e911cad 1715 }
2f77fc4b 1716
2223c96f
DG
1717 rcu_read_lock();
1718
2f77fc4b
DG
1719 switch (domain) {
1720 case LTTNG_DOMAIN_KERNEL:
1721 {
1722 struct ltt_kernel_channel *kchan;
1723 struct ltt_kernel_session *ksess;
1724
1725 ksess = session->kernel_session;
1726
85076754
MD
1727 /*
1728 * If a non-default channel has been created in the
1729 * session, explicitely require that -c chan_name needs
1730 * to be provided.
1731 */
1732 if (ksess->has_non_default_channel && channel_name[0] == '\0') {
1733 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
7076b56e 1734 goto error_unlock;
85076754
MD
1735 }
1736
2f77fc4b
DG
1737 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
1738 if (kchan == NULL) {
f73fabfd 1739 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
7076b56e 1740 goto error_unlock;
2f77fc4b
DG
1741 }
1742
6e911cad
MD
1743 switch (event->type) {
1744 case LTTNG_EVENT_ALL:
9550ee81 1745 case LTTNG_EVENT_TRACEPOINT:
d0ae4ea8 1746 case LTTNG_EVENT_SYSCALL:
9550ee81
JR
1747 case LTTNG_EVENT_PROBE:
1748 case LTTNG_EVENT_FUNCTION:
1749 case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
1750 if (event_name[0] == '\0') {
1751 ret = event_kernel_disable_event(kchan,
1752 NULL, event->type);
29c62722 1753 } else {
d0ae4ea8 1754 ret = event_kernel_disable_event(kchan,
9550ee81 1755 event_name, event->type);
29c62722 1756 }
6e911cad 1757 if (ret != LTTNG_OK) {
7076b56e 1758 goto error_unlock;
6e911cad
MD
1759 }
1760 break;
6e911cad
MD
1761 default:
1762 ret = LTTNG_ERR_UNK;
7076b56e 1763 goto error_unlock;
2f77fc4b
DG
1764 }
1765
7d268848 1766 kernel_wait_quiescent();
2f77fc4b
DG
1767 break;
1768 }
1769 case LTTNG_DOMAIN_UST:
1770 {
1771 struct ltt_ust_channel *uchan;
1772 struct ltt_ust_session *usess;
1773
1774 usess = session->ust_session;
1775
7076b56e
JG
1776 if (validate_ust_event_name(event_name)) {
1777 ret = LTTNG_ERR_INVALID_EVENT_NAME;
1778 goto error_unlock;
1779 }
1780
85076754
MD
1781 /*
1782 * If a non-default channel has been created in the
9550ee81 1783 * session, explicitly require that -c chan_name needs
85076754
MD
1784 * to be provided.
1785 */
1786 if (usess->has_non_default_channel && channel_name[0] == '\0') {
1787 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
7076b56e 1788 goto error_unlock;
85076754
MD
1789 }
1790
2f77fc4b
DG
1791 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1792 channel_name);
1793 if (uchan == NULL) {
f73fabfd 1794 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
7076b56e 1795 goto error_unlock;
2f77fc4b
DG
1796 }
1797
6e911cad
MD
1798 switch (event->type) {
1799 case LTTNG_EVENT_ALL:
b3639870
JR
1800 /*
1801 * An empty event name means that everything
1802 * should be disabled.
1803 */
1804 if (event->name[0] == '\0') {
1805 ret = event_ust_disable_all_tracepoints(usess, uchan);
77d536b2
JR
1806 } else {
1807 ret = event_ust_disable_tracepoint(usess, uchan,
1808 event_name);
1809 }
6e911cad 1810 if (ret != LTTNG_OK) {
7076b56e 1811 goto error_unlock;
6e911cad
MD
1812 }
1813 break;
1814 default:
1815 ret = LTTNG_ERR_UNK;
7076b56e 1816 goto error_unlock;
2f77fc4b
DG
1817 }
1818
1819 DBG3("Disable UST event %s in channel %s completed", event_name,
1820 channel_name);
1821 break;
1822 }
5cdb6027 1823 case LTTNG_DOMAIN_LOG4J:
f20baf8e 1824 case LTTNG_DOMAIN_JUL:
0e115563 1825 case LTTNG_DOMAIN_PYTHON:
f20baf8e 1826 {
fefd409b 1827 struct agent *agt;
f20baf8e
DG
1828 struct ltt_ust_session *usess = session->ust_session;
1829
a0377dfe 1830 LTTNG_ASSERT(usess);
f20baf8e 1831
6e911cad
MD
1832 switch (event->type) {
1833 case LTTNG_EVENT_ALL:
1834 break;
1835 default:
1836 ret = LTTNG_ERR_UNK;
7076b56e 1837 goto error_unlock;
6e911cad
MD
1838 }
1839
5cdb6027 1840 agt = trace_ust_find_agent(usess, domain);
fefd409b
DG
1841 if (!agt) {
1842 ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
7076b56e 1843 goto error_unlock;
fefd409b 1844 }
b3639870
JR
1845 /*
1846 * An empty event name means that everything
1847 * should be disabled.
1848 */
1849 if (event->name[0] == '\0') {
18a720cd
MD
1850 ret = event_agent_disable_all(usess, agt);
1851 } else {
1852 ret = event_agent_disable(usess, agt, event_name);
1853 }
f20baf8e 1854 if (ret != LTTNG_OK) {
7076b56e 1855 goto error_unlock;
f20baf8e
DG
1856 }
1857
1858 break;
1859 }
2f77fc4b 1860 default:
f73fabfd 1861 ret = LTTNG_ERR_UND;
7076b56e 1862 goto error_unlock;
2f77fc4b
DG
1863 }
1864
f73fabfd 1865 ret = LTTNG_OK;
2f77fc4b 1866
7076b56e 1867error_unlock:
2223c96f 1868 rcu_read_unlock();
7076b56e 1869error:
8ddd72ef
JR
1870 free(exclusion);
1871 free(bytecode);
1872 free(filter_expression);
2f77fc4b
DG
1873 return ret;
1874}
1875
2f77fc4b
DG
1876/*
1877 * Command LTTNG_ADD_CONTEXT processed by the client thread.
1878 */
26e1c61f
JR
1879int cmd_add_context(struct command_ctx *cmd_ctx,
1880 const struct lttng_event_context *event_context, int kwpipe)
2f77fc4b 1881{
d5979e4a 1882 int ret, chan_kern_created = 0, chan_ust_created = 0;
26e1c61f
JR
1883 const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type;
1884 const struct ltt_session *session = cmd_ctx->session;
1885 const char *channel_name = cmd_ctx->lsm.u.context.channel_name;
bdf64013 1886
9a699f7b
JR
1887 /*
1888 * Don't try to add a context if the session has been started at
1889 * some point in time before. The tracer does not allow it and would
1890 * result in a corrupted trace.
1891 */
26e1c61f 1892 if (cmd_ctx->session->has_been_started) {
9a699f7b
JR
1893 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1894 goto end;
1895 }
1896
2f77fc4b
DG
1897 switch (domain) {
1898 case LTTNG_DOMAIN_KERNEL:
a0377dfe 1899 LTTNG_ASSERT(session->kernel_session);
979e618e
DG
1900
1901 if (session->kernel_session->channel_count == 0) {
1902 /* Create default channel */
1903 ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
1904 if (ret != LTTNG_OK) {
1905 goto error;
1906 }
d5979e4a 1907 chan_kern_created = 1;
979e618e 1908 }
2f77fc4b 1909 /* Add kernel context to kernel tracer */
26e1c61f
JR
1910 ret = context_kernel_add(session->kernel_session,
1911 event_context, channel_name);
f73fabfd 1912 if (ret != LTTNG_OK) {
2f77fc4b
DG
1913 goto error;
1914 }
1915 break;
bdf64013
JG
1916 case LTTNG_DOMAIN_JUL:
1917 case LTTNG_DOMAIN_LOG4J:
1918 {
1919 /*
1920 * Validate channel name.
1921 * If no channel name is given and the domain is JUL or LOG4J,
1922 * set it to the appropriate domain-specific channel name. If
1923 * a name is provided but does not match the expexted channel
1924 * name, return an error.
1925 */
1926 if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
1927 strcmp(channel_name,
1928 DEFAULT_JUL_CHANNEL_NAME)) {
1929 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1930 goto error;
1931 } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
1932 strcmp(channel_name,
1933 DEFAULT_LOG4J_CHANNEL_NAME)) {
1934 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1935 goto error;
1936 }
1937 }
30eb3927 1938 /* fall through */
2f77fc4b
DG
1939 case LTTNG_DOMAIN_UST:
1940 {
1941 struct ltt_ust_session *usess = session->ust_session;
85076754
MD
1942 unsigned int chan_count;
1943
a0377dfe 1944 LTTNG_ASSERT(usess);
2f77fc4b 1945
85076754 1946 chan_count = lttng_ht_get_count(usess->domain_global.channels);
979e618e
DG
1947 if (chan_count == 0) {
1948 struct lttng_channel *attr;
1949 /* Create default channel */
0a9c6494 1950 attr = channel_new_default_attr(domain, usess->buffer_type);
979e618e
DG
1951 if (attr == NULL) {
1952 ret = LTTNG_ERR_FATAL;
1953 goto error;
1954 }
1955
7972aab2 1956 ret = channel_ust_create(usess, attr, usess->buffer_type);
979e618e
DG
1957 if (ret != LTTNG_OK) {
1958 free(attr);
1959 goto error;
1960 }
cf0bcb51 1961 channel_attr_destroy(attr);
d5979e4a 1962 chan_ust_created = 1;
979e618e
DG
1963 }
1964
26e1c61f
JR
1965 ret = context_ust_add(usess, domain, event_context,
1966 channel_name);
f73fabfd 1967 if (ret != LTTNG_OK) {
2f77fc4b
DG
1968 goto error;
1969 }
1970 break;
1971 }
2f77fc4b 1972 default:
f73fabfd 1973 ret = LTTNG_ERR_UND;
2f77fc4b
DG
1974 goto error;
1975 }
1976
bdf64013
JG
1977 ret = LTTNG_OK;
1978 goto end;
2f77fc4b
DG
1979
1980error:
d5979e4a
DG
1981 if (chan_kern_created) {
1982 struct ltt_kernel_channel *kchan =
1983 trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
1984 session->kernel_session);
1985 /* Created previously, this should NOT fail. */
a0377dfe 1986 LTTNG_ASSERT(kchan);
d5979e4a
DG
1987 kernel_destroy_channel(kchan);
1988 }
1989
1990 if (chan_ust_created) {
1991 struct ltt_ust_channel *uchan =
1992 trace_ust_find_channel_by_name(
1993 session->ust_session->domain_global.channels,
1994 DEFAULT_CHANNEL_NAME);
1995 /* Created previously, this should NOT fail. */
a0377dfe 1996 LTTNG_ASSERT(uchan);
d5979e4a
DG
1997 /* Remove from the channel list of the session. */
1998 trace_ust_delete_channel(session->ust_session->domain_global.channels,
1999 uchan);
2000 trace_ust_destroy_channel(uchan);
2001 }
bdf64013 2002end:
2f77fc4b
DG
2003 return ret;
2004}
2005
dac8e046
JG
2006static inline bool name_starts_with(const char *name, const char *prefix)
2007{
7966af57 2008 const size_t max_cmp_len = std::min(strlen(prefix), (size_t) LTTNG_SYMBOL_NAME_LEN);
dac8e046
JG
2009
2010 return !strncmp(name, prefix, max_cmp_len);
2011}
2012
2013/* Perform userspace-specific event name validation */
2014static int validate_ust_event_name(const char *name)
2015{
2016 int ret = 0;
2017
2018 if (!name) {
2019 ret = -1;
2020 goto end;
2021 }
2022
2023 /*
2024 * Check name against all internal UST event component namespaces used
2025 * by the agents.
2026 */
2027 if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
2028 name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
2029 name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
2030 ret = -1;
2031 }
2032
2033end:
2034 return ret;
2035}
88f06f15 2036
2f77fc4b 2037/*
88f06f15
JG
2038 * Internal version of cmd_enable_event() with a supplemental
2039 * "internal_event" flag which is used to enable internal events which should
2040 * be hidden from clients. Such events are used in the agent implementation to
2041 * enable the events through which all "agent" events are funeled.
2f77fc4b 2042 */
88f06f15 2043static int _cmd_enable_event(struct ltt_session *session,
df4f5a87 2044 const struct lttng_domain *domain,
025faf73 2045 char *channel_name, struct lttng_event *event,
6b453b5e 2046 char *filter_expression,
2b00d462 2047 struct lttng_bytecode *filter,
db8f1377 2048 struct lttng_event_exclusion *exclusion,
88f06f15 2049 int wpipe, bool internal_event)
2f77fc4b 2050{
9f449915 2051 int ret = 0, channel_created = 0;
cfedea03 2052 struct lttng_channel *attr = NULL;
2f77fc4b 2053
a0377dfe
FD
2054 LTTNG_ASSERT(session);
2055 LTTNG_ASSERT(event);
2056 LTTNG_ASSERT(channel_name);
2f77fc4b 2057
2a385866 2058 /* If we have a filter, we must have its filter expression */
a0377dfe 2059 LTTNG_ASSERT(!(!!filter_expression ^ !!filter));
2a385866 2060
9f449915
PP
2061 /* Normalize event name as a globbing pattern */
2062 strutils_normalize_star_glob_pattern(event->name);
18a720cd 2063
9f449915
PP
2064 /* Normalize exclusion names as globbing patterns */
2065 if (exclusion) {
2066 size_t i;
f5ac4bd7 2067
9f449915
PP
2068 for (i = 0; i < exclusion->count; i++) {
2069 char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i);
2070
2071 strutils_normalize_star_glob_pattern(name);
2072 }
930a2e99
JG
2073 }
2074
9f449915
PP
2075 DBG("Enable event command for event \'%s\'", event->name);
2076
2077 rcu_read_lock();
2078
7972aab2 2079 switch (domain->type) {
2f77fc4b
DG
2080 case LTTNG_DOMAIN_KERNEL:
2081 {
2082 struct ltt_kernel_channel *kchan;
2083
85076754
MD
2084 /*
2085 * If a non-default channel has been created in the
2086 * session, explicitely require that -c chan_name needs
2087 * to be provided.
2088 */
2089 if (session->kernel_session->has_non_default_channel
2090 && channel_name[0] == '\0') {
2091 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2092 goto error;
2093 }
2094
2f77fc4b
DG
2095 kchan = trace_kernel_get_channel_by_name(channel_name,
2096 session->kernel_session);
2097 if (kchan == NULL) {
0a9c6494
DG
2098 attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
2099 LTTNG_BUFFER_GLOBAL);
2f77fc4b 2100 if (attr == NULL) {
f73fabfd 2101 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2102 goto error;
2103 }
04c17253
MD
2104 if (lttng_strncpy(attr->name, channel_name,
2105 sizeof(attr->name))) {
2106 ret = LTTNG_ERR_INVALID;
04c17253
MD
2107 goto error;
2108 }
2f77fc4b 2109
999af9c1
JR
2110 ret = cmd_enable_channel_internal(
2111 session, domain, attr, wpipe);
f73fabfd 2112 if (ret != LTTNG_OK) {
2f77fc4b
DG
2113 goto error;
2114 }
e5f5db7f 2115 channel_created = 1;
2f77fc4b
DG
2116 }
2117
2118 /* Get the newly created kernel channel pointer */
2119 kchan = trace_kernel_get_channel_by_name(channel_name,
2120 session->kernel_session);
2121 if (kchan == NULL) {
2122 /* This sould not happen... */
f73fabfd 2123 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2124 goto error;
2125 }
2126
6e911cad
MD
2127 switch (event->type) {
2128 case LTTNG_EVENT_ALL:
29c62722 2129 {
00a62084 2130 char *filter_expression_a = NULL;
2b00d462 2131 struct lttng_bytecode *filter_a = NULL;
00a62084
MD
2132
2133 /*
2134 * We need to duplicate filter_expression and filter,
2135 * because ownership is passed to first enable
2136 * event.
2137 */
2138 if (filter_expression) {
2139 filter_expression_a = strdup(filter_expression);
2140 if (!filter_expression_a) {
2141 ret = LTTNG_ERR_FATAL;
2142 goto error;
2143 }
2144 }
2145 if (filter) {
64803277 2146 filter_a = zmalloc<lttng_bytecode>(sizeof(*filter_a) + filter->len);
00a62084
MD
2147 if (!filter_a) {
2148 free(filter_expression_a);
2149 ret = LTTNG_ERR_FATAL;
2150 goto error;
2151 }
2152 memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
2153 }
29c62722 2154 event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
00a62084
MD
2155 ret = event_kernel_enable_event(kchan, event,
2156 filter_expression, filter);
a969e101
MD
2157 /* We have passed ownership */
2158 filter_expression = NULL;
2159 filter = NULL;
29c62722
MD
2160 if (ret != LTTNG_OK) {
2161 if (channel_created) {
2162 /* Let's not leak a useless channel. */
2163 kernel_destroy_channel(kchan);
2164 }
00a62084
MD
2165 free(filter_expression_a);
2166 free(filter_a);
29c62722
MD
2167 goto error;
2168 }
2169 event->type = LTTNG_EVENT_SYSCALL; /* Hack */
00a62084
MD
2170 ret = event_kernel_enable_event(kchan, event,
2171 filter_expression_a, filter_a);
60d21fa2
AB
2172 /* We have passed ownership */
2173 filter_expression_a = NULL;
2174 filter_a = NULL;
29c62722
MD
2175 if (ret != LTTNG_OK) {
2176 goto error;
2177 }
2178 break;
2179 }
6e6ef3d7 2180 case LTTNG_EVENT_PROBE:
dcabc190 2181 case LTTNG_EVENT_USERSPACE_PROBE:
6e6ef3d7
DG
2182 case LTTNG_EVENT_FUNCTION:
2183 case LTTNG_EVENT_FUNCTION_ENTRY:
6e911cad 2184 case LTTNG_EVENT_TRACEPOINT:
00a62084
MD
2185 ret = event_kernel_enable_event(kchan, event,
2186 filter_expression, filter);
a969e101
MD
2187 /* We have passed ownership */
2188 filter_expression = NULL;
2189 filter = NULL;
6e911cad
MD
2190 if (ret != LTTNG_OK) {
2191 if (channel_created) {
2192 /* Let's not leak a useless channel. */
2193 kernel_destroy_channel(kchan);
2194 }
2195 goto error;
e5f5db7f 2196 }
6e911cad
MD
2197 break;
2198 case LTTNG_EVENT_SYSCALL:
00a62084
MD
2199 ret = event_kernel_enable_event(kchan, event,
2200 filter_expression, filter);
a969e101
MD
2201 /* We have passed ownership */
2202 filter_expression = NULL;
2203 filter = NULL;
e2b957af
MD
2204 if (ret != LTTNG_OK) {
2205 goto error;
2206 }
6e911cad
MD
2207 break;
2208 default:
2209 ret = LTTNG_ERR_UNK;
2f77fc4b
DG
2210 goto error;
2211 }
2212
7d268848 2213 kernel_wait_quiescent();
2f77fc4b
DG
2214 break;
2215 }
2216 case LTTNG_DOMAIN_UST:
2217 {
2218 struct ltt_ust_channel *uchan;
2219 struct ltt_ust_session *usess = session->ust_session;
2220
a0377dfe 2221 LTTNG_ASSERT(usess);
2f77fc4b 2222
85076754
MD
2223 /*
2224 * If a non-default channel has been created in the
2225 * session, explicitely require that -c chan_name needs
2226 * to be provided.
2227 */
2228 if (usess->has_non_default_channel && channel_name[0] == '\0') {
2229 ret = LTTNG_ERR_NEED_CHANNEL_NAME;
2230 goto error;
2231 }
2232
2f77fc4b
DG
2233 /* Get channel from global UST domain */
2234 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2235 channel_name);
2236 if (uchan == NULL) {
2237 /* Create default channel */
0a9c6494
DG
2238 attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
2239 usess->buffer_type);
2f77fc4b 2240 if (attr == NULL) {
f73fabfd 2241 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
2242 goto error;
2243 }
04c17253
MD
2244 if (lttng_strncpy(attr->name, channel_name,
2245 sizeof(attr->name))) {
2246 ret = LTTNG_ERR_INVALID;
04c17253
MD
2247 goto error;
2248 }
2f77fc4b 2249
999af9c1
JR
2250 ret = cmd_enable_channel_internal(
2251 session, domain, attr, wpipe);
f73fabfd 2252 if (ret != LTTNG_OK) {
2f77fc4b
DG
2253 goto error;
2254 }
2f77fc4b
DG
2255
2256 /* Get the newly created channel reference back */
2257 uchan = trace_ust_find_channel_by_name(
2258 usess->domain_global.channels, channel_name);
a0377dfe 2259 LTTNG_ASSERT(uchan);
2f77fc4b
DG
2260 }
2261
141feb8c
JG
2262 if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
2263 /*
2264 * Don't allow users to add UST events to channels which
2265 * are assigned to a userspace subdomain (JUL, Log4J,
2266 * Python, etc.).
2267 */
2268 ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
2269 goto error;
2270 }
2271
dac8e046
JG
2272 if (!internal_event) {
2273 /*
2274 * Ensure the event name is not reserved for internal
2275 * use.
2276 */
2277 ret = validate_ust_event_name(event->name);
2278 if (ret) {
0e270a1e 2279 WARN("Userspace event name %s failed validation.",
bbcab087 2280 event->name);
dac8e046
JG
2281 ret = LTTNG_ERR_INVALID_EVENT_NAME;
2282 goto error;
2283 }
2284 }
2285
2f77fc4b 2286 /* At this point, the session and channel exist on the tracer */
6b453b5e 2287 ret = event_ust_enable_tracepoint(usess, uchan, event,
88f06f15
JG
2288 filter_expression, filter, exclusion,
2289 internal_event);
49d21f93
MD
2290 /* We have passed ownership */
2291 filter_expression = NULL;
2292 filter = NULL;
2293 exclusion = NULL;
94382e15
JG
2294 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2295 goto already_enabled;
2296 } else if (ret != LTTNG_OK) {
2f77fc4b
DG
2297 goto error;
2298 }
2299 break;
2300 }
5cdb6027 2301 case LTTNG_DOMAIN_LOG4J:
f20baf8e 2302 case LTTNG_DOMAIN_JUL:
0e115563 2303 case LTTNG_DOMAIN_PYTHON:
f20baf8e 2304 {
da6c3a50 2305 const char *default_event_name, *default_chan_name;
fefd409b 2306 struct agent *agt;
f20baf8e
DG
2307 struct lttng_event uevent;
2308 struct lttng_domain tmp_dom;
2309 struct ltt_ust_session *usess = session->ust_session;
2310
a0377dfe 2311 LTTNG_ASSERT(usess);
f20baf8e 2312
f28f9e44
JG
2313 if (!agent_tracing_is_enabled()) {
2314 DBG("Attempted to enable an event in an agent domain but the agent thread is not running");
2315 ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
2316 goto error;
2317 }
2318
5cdb6027 2319 agt = trace_ust_find_agent(usess, domain->type);
fefd409b 2320 if (!agt) {
5cdb6027 2321 agt = agent_create(domain->type);
fefd409b 2322 if (!agt) {
e5b3c48c 2323 ret = LTTNG_ERR_NOMEM;
fefd409b
DG
2324 goto error;
2325 }
2326 agent_add(agt, usess->agents);
2327 }
2328
022d91ba 2329 /* Create the default tracepoint. */
996de3c7 2330 memset(&uevent, 0, sizeof(uevent));
f20baf8e
DG
2331 uevent.type = LTTNG_EVENT_TRACEPOINT;
2332 uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
51755dc8
JG
2333 default_event_name = event_get_default_agent_ust_name(
2334 domain->type);
da6c3a50 2335 if (!default_event_name) {
e5b3c48c 2336 ret = LTTNG_ERR_FATAL;
da6c3a50 2337 goto error;
f43f95a9 2338 }
da6c3a50 2339 strncpy(uevent.name, default_event_name, sizeof(uevent.name));
f20baf8e
DG
2340 uevent.name[sizeof(uevent.name) - 1] = '\0';
2341
2342 /*
2343 * The domain type is changed because we are about to enable the
2344 * default channel and event for the JUL domain that are hardcoded.
2345 * This happens in the UST domain.
2346 */
2347 memcpy(&tmp_dom, domain, sizeof(tmp_dom));
2348 tmp_dom.type = LTTNG_DOMAIN_UST;
2349
0e115563
DG
2350 switch (domain->type) {
2351 case LTTNG_DOMAIN_LOG4J:
da6c3a50 2352 default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME;
0e115563
DG
2353 break;
2354 case LTTNG_DOMAIN_JUL:
da6c3a50 2355 default_chan_name = DEFAULT_JUL_CHANNEL_NAME;
0e115563
DG
2356 break;
2357 case LTTNG_DOMAIN_PYTHON:
2358 default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
2359 break;
2360 default:
e98a44b0 2361 /* The switch/case we are in makes this impossible */
a0377dfe 2362 abort();
da6c3a50
DG
2363 }
2364
971da06a 2365 {
8404118c 2366 char *filter_expression_copy = NULL;
2b00d462 2367 struct lttng_bytecode *filter_copy = NULL;
971da06a
JG
2368
2369 if (filter) {
51755dc8 2370 const size_t filter_size = sizeof(
2b00d462 2371 struct lttng_bytecode)
51755dc8
JG
2372 + filter->len;
2373
64803277 2374 filter_copy = zmalloc<lttng_bytecode>(filter_size);
971da06a 2375 if (!filter_copy) {
018096a4 2376 ret = LTTNG_ERR_NOMEM;
b742e3e2 2377 goto error;
971da06a 2378 }
51755dc8 2379 memcpy(filter_copy, filter, filter_size);
971da06a 2380
8404118c
JG
2381 filter_expression_copy =
2382 strdup(filter_expression);
2383 if (!filter_expression) {
2384 ret = LTTNG_ERR_NOMEM;
51755dc8
JG
2385 }
2386
2387 if (!filter_expression_copy || !filter_copy) {
2388 free(filter_expression_copy);
2389 free(filter_copy);
2390 goto error;
8404118c 2391 }
971da06a
JG
2392 }
2393
88f06f15 2394 ret = cmd_enable_event_internal(session, &tmp_dom,
971da06a 2395 (char *) default_chan_name,
8404118c
JG
2396 &uevent, filter_expression_copy,
2397 filter_copy, NULL, wpipe);
971da06a
JG
2398 }
2399
94382e15
JG
2400 if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
2401 goto already_enabled;
2402 } else if (ret != LTTNG_OK) {
f20baf8e
DG
2403 goto error;
2404 }
2405
2406 /* The wild card * means that everything should be enabled. */
2407 if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
8404118c
JG
2408 ret = event_agent_enable_all(usess, agt, event, filter,
2409 filter_expression);
f20baf8e 2410 } else {
8404118c
JG
2411 ret = event_agent_enable(usess, agt, event, filter,
2412 filter_expression);
f20baf8e 2413 }
51755dc8
JG
2414 filter = NULL;
2415 filter_expression = NULL;
f20baf8e
DG
2416 if (ret != LTTNG_OK) {
2417 goto error;
2418 }
2419
2420 break;
2421 }
2f77fc4b 2422 default:
f73fabfd 2423 ret = LTTNG_ERR_UND;
2f77fc4b
DG
2424 goto error;
2425 }
2426
f73fabfd 2427 ret = LTTNG_OK;
2f77fc4b 2428
94382e15 2429already_enabled:
2f77fc4b 2430error:
49d21f93
MD
2431 free(filter_expression);
2432 free(filter);
2433 free(exclusion);
cf0bcb51 2434 channel_attr_destroy(attr);
2223c96f 2435 rcu_read_unlock();
2f77fc4b
DG
2436 return ret;
2437}
2438
88f06f15
JG
2439/*
2440 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2441 * We own filter, exclusion, and filter_expression.
2442 */
8ddd72ef
JR
2443int cmd_enable_event(struct command_ctx *cmd_ctx,
2444 struct lttng_event *event,
88f06f15 2445 char *filter_expression,
88f06f15 2446 struct lttng_event_exclusion *exclusion,
8ddd72ef 2447 struct lttng_bytecode *bytecode,
88f06f15
JG
2448 int wpipe)
2449{
8ddd72ef
JR
2450 int ret;
2451 /*
2452 * Copied to ensure proper alignment since 'lsm' is a packed structure.
2453 */
2454 const lttng_domain command_domain = cmd_ctx->lsm.domain;
2455
2456 /*
2457 * The ownership of the following parameters is transferred to
2458 * _cmd_enable_event:
2459 *
2460 * - filter_expression,
2461 * - bytecode,
2462 * - exclusion
2463 */
2464 ret = _cmd_enable_event(cmd_ctx->session,
2465 &command_domain,
2466 cmd_ctx->lsm.u.enable.channel_name, event,
2467 filter_expression, bytecode, exclusion, wpipe, false);
2468 filter_expression = NULL;
2469 bytecode = NULL;
2470 exclusion = NULL;
2471 return ret;
88f06f15
JG
2472}
2473
2474/*
2475 * Enable an event which is internal to LTTng. An internal should
2476 * never be made visible to clients and are immune to checks such as
2477 * reserved names.
2478 */
2479static int cmd_enable_event_internal(struct ltt_session *session,
df4f5a87 2480 const struct lttng_domain *domain,
88f06f15
JG
2481 char *channel_name, struct lttng_event *event,
2482 char *filter_expression,
2b00d462 2483 struct lttng_bytecode *filter,
88f06f15
JG
2484 struct lttng_event_exclusion *exclusion,
2485 int wpipe)
2486{
2487 return _cmd_enable_event(session, domain, channel_name, event,
2488 filter_expression, filter, exclusion, wpipe, true);
2489}
2490
2f77fc4b
DG
2491/*
2492 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2493 */
8ddd72ef
JR
2494enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain,
2495 struct lttng_payload *reply_payload)
2f77fc4b 2496{
8ddd72ef 2497 enum lttng_error_code ret_code;
2f77fc4b 2498 int ret;
8ddd72ef
JR
2499 ssize_t i, nb_events = 0;
2500 struct lttng_event *events = NULL;
2501 struct lttcomm_list_command_header reply_command_header = {};
2502 size_t reply_command_header_offset;
2503
2504 assert(reply_payload);
2505
2506 /* Reserve space for command reply header. */
2507 reply_command_header_offset = reply_payload->buffer.size;
2508 ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
2509 reply_command_header_offset +
2510 sizeof(struct lttcomm_list_command_header));
2511 if (ret) {
2512 ret_code = LTTNG_ERR_NOMEM;
2513 goto error;
2514 }
2f77fc4b
DG
2515
2516 switch (domain) {
2517 case LTTNG_DOMAIN_KERNEL:
8ddd72ef 2518 nb_events = kernel_list_events(&events);
2f77fc4b 2519 if (nb_events < 0) {
8ddd72ef 2520 ret_code = LTTNG_ERR_KERN_LIST_FAIL;
2f77fc4b
DG
2521 goto error;
2522 }
2523 break;
2524 case LTTNG_DOMAIN_UST:
8ddd72ef 2525 nb_events = ust_app_list_events(&events);
2f77fc4b 2526 if (nb_events < 0) {
8ddd72ef 2527 ret_code = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2528 goto error;
2529 }
2530 break;
5cdb6027 2531 case LTTNG_DOMAIN_LOG4J:
3c6a091f 2532 case LTTNG_DOMAIN_JUL:
0e115563 2533 case LTTNG_DOMAIN_PYTHON:
8ddd72ef 2534 nb_events = agent_list_events(&events, domain);
3c6a091f 2535 if (nb_events < 0) {
8ddd72ef 2536 ret_code = LTTNG_ERR_UST_LIST_FAIL;
3c6a091f
DG
2537 goto error;
2538 }
2539 break;
2f77fc4b 2540 default:
8ddd72ef
JR
2541 ret_code = LTTNG_ERR_UND;
2542 goto error;
2543 }
2544
2545 for (i = 0; i < nb_events; i++) {
2546 ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL,
2547 reply_payload);
2548 if (ret) {
2549 ret_code = LTTNG_ERR_NOMEM;
2550 goto error;
2551 }
2552 }
2553
2554 if (nb_events > UINT32_MAX) {
2555 ERR("Tracepoint count would overflow the tracepoint listing command's reply");
2556 ret_code = LTTNG_ERR_OVERFLOW;
2f77fc4b
DG
2557 goto error;
2558 }
2559
8ddd72ef
JR
2560 /* Update command reply header. */
2561 reply_command_header.count = (uint32_t) nb_events;
2562 memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
2563 sizeof(reply_command_header));
2f77fc4b 2564
8ddd72ef 2565 ret_code = LTTNG_OK;
2f77fc4b 2566error:
8ddd72ef
JR
2567 free(events);
2568 return ret_code;
2f77fc4b
DG
2569}
2570
2571/*
2572 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2573 */
b2d68839
JR
2574enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain,
2575 struct lttng_payload *reply)
2f77fc4b 2576{
b2d68839 2577 enum lttng_error_code ret_code;
2f77fc4b 2578 int ret;
b2d68839
JR
2579 unsigned int i, nb_fields;
2580 struct lttng_event_field *fields = NULL;
2581 struct lttcomm_list_command_header reply_command_header = {};
2582 size_t reply_command_header_offset;
2583
2584 assert(reply);
2585
2586 /* Reserve space for command reply header. */
2587 reply_command_header_offset = reply->buffer.size;
2588 ret = lttng_dynamic_buffer_set_size(&reply->buffer,
2589 reply_command_header_offset +
2590 sizeof(struct lttcomm_list_command_header));
2591 if (ret) {
2592 ret_code = LTTNG_ERR_NOMEM;
2593 goto error;
2594 }
2f77fc4b
DG
2595
2596 switch (domain) {
2597 case LTTNG_DOMAIN_UST:
b2d68839
JR
2598 ret = ust_app_list_event_fields(&fields);
2599 if (ret < 0) {
2600 ret_code = LTTNG_ERR_UST_LIST_FAIL;
2f77fc4b
DG
2601 goto error;
2602 }
b2d68839 2603
2f77fc4b
DG
2604 break;
2605 case LTTNG_DOMAIN_KERNEL:
2606 default: /* fall-through */
b2d68839 2607 ret_code = LTTNG_ERR_UND;
2f77fc4b
DG
2608 goto error;
2609 }
2610
b2d68839
JR
2611 nb_fields = ret;
2612
2613 for (i = 0; i < nb_fields; i++) {
2614 ret = lttng_event_field_serialize(&fields[i], reply);
2615 if (ret) {
2616 ret_code = LTTNG_ERR_NOMEM;
2617 goto error;
2618 }
2619 }
2620
2621 if (nb_fields > UINT32_MAX) {
2622 ERR("Tracepoint field count would overflow the tracepoint field listing command's reply");
2623 ret_code = LTTNG_ERR_OVERFLOW;
2624 goto error;
2625 }
2626
2627 /* Update command reply header. */
2628 reply_command_header.count = (uint32_t) nb_fields;
2629
2630 memcpy(reply->buffer.data + reply_command_header_offset, &reply_command_header,
2631 sizeof(reply_command_header));
2632
2633 ret_code = LTTNG_OK;
2f77fc4b
DG
2634
2635error:
b2d68839
JR
2636 free(fields);
2637 return ret_code;
2f77fc4b
DG
2638}
2639
8ddd72ef
JR
2640enum lttng_error_code cmd_list_syscalls(
2641 struct lttng_payload *reply_payload)
834978fd 2642{
8ddd72ef
JR
2643 enum lttng_error_code ret_code;
2644 ssize_t nb_events, i;
2645 int ret;
2646 struct lttng_event *events = NULL;
2647 struct lttcomm_list_command_header reply_command_header = {};
2648 size_t reply_command_header_offset;
2649
2650 assert(reply_payload);
2651
2652 /* Reserve space for command reply header. */
2653 reply_command_header_offset = reply_payload->buffer.size;
2654 ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
2655 reply_command_header_offset +
2656 sizeof(struct lttcomm_list_command_header));
2657 if (ret) {
2658 ret_code = LTTNG_ERR_NOMEM;
2659 goto end;
2660 }
2661
2662 nb_events = syscall_table_list(&events);
2663 if (nb_events < 0) {
2664 ret_code = (enum lttng_error_code) -nb_events;
2665 goto end;
2666 }
2667
2668 for (i = 0; i < nb_events; i++) {
2669 ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL,
2670 reply_payload);
2671 if (ret) {
2672 ret_code = LTTNG_ERR_NOMEM;
2673 goto end;
2674 }
2675 }
2676
2677 if (nb_events > UINT32_MAX) {
2678 ERR("Syscall count would overflow the syscall listing command's reply");
2679 ret_code = LTTNG_ERR_OVERFLOW;
2680 goto end;
2681 }
2682
2683 /* Update command reply header. */
2684 reply_command_header.count = (uint32_t) nb_events;
2685 memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
2686 sizeof(reply_command_header));
2687
2688 ret_code = LTTNG_OK;
2689end:
2690 free(events);
2691 return ret_code;
834978fd
DG
2692}
2693
2f77fc4b
DG
2694/*
2695 * Command LTTNG_START_TRACE processed by the client thread.
a9ad0c8f
MD
2696 *
2697 * Called with session mutex held.
2f77fc4b
DG
2698 */
2699int cmd_start_trace(struct ltt_session *session)
2700{
82b69413 2701 enum lttng_error_code ret;
cde3e505 2702 unsigned long nb_chan = 0;
2f77fc4b
DG
2703 struct ltt_kernel_session *ksession;
2704 struct ltt_ust_session *usess;
1f496244
JG
2705 const bool session_rotated_after_last_stop =
2706 session->rotated_after_last_stop;
b02f5986
MD
2707 const bool session_cleared_after_last_stop =
2708 session->cleared_after_last_stop;
2f77fc4b 2709
a0377dfe 2710 LTTNG_ASSERT(session);
2f77fc4b
DG
2711
2712 /* Ease our life a bit ;) */
2713 ksession = session->kernel_session;
2714 usess = session->ust_session;
2715
8382cf6f
DG
2716 /* Is the session already started? */
2717 if (session->active) {
f73fabfd 2718 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
7a24ece3
JR
2719 /* Perform nothing */
2720 goto end;
2f77fc4b
DG
2721 }
2722
1f496244
JG
2723 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
2724 !session->current_trace_chunk) {
2725 /*
2726 * A rotation was launched while the session was stopped and
2727 * it has not been completed yet. It is not possible to start
2728 * the session since starting the session here would require a
2729 * rotation from "NULL" to a new trace chunk. That rotation
2730 * would overlap with the ongoing rotation, which is not
2731 * supported.
2732 */
2733 WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing",
2734 session->name);
2735 ret = LTTNG_ERR_ROTATION_PENDING;
2736 goto error;
2737 }
2738
cde3e505
DG
2739 /*
2740 * Starting a session without channel is useless since after that it's not
2741 * possible to enable channel thus inform the client.
2742 */
2743 if (usess && usess->domain_global.channels) {
2744 nb_chan += lttng_ht_get_count(usess->domain_global.channels);
2745 }
2746 if (ksession) {
2747 nb_chan += ksession->channel_count;
2748 }
2749 if (!nb_chan) {
2750 ret = LTTNG_ERR_NO_CHANNEL;
2751 goto error;
2752 }
2753
1f496244
JG
2754 session->active = 1;
2755 session->rotated_after_last_stop = false;
b02f5986 2756 session->cleared_after_last_stop = false;
070b6a86 2757 if (session->output_traces && !session->current_trace_chunk) {
1f496244
JG
2758 if (!session->has_been_started) {
2759 struct lttng_trace_chunk *trace_chunk;
2760
2761 DBG("Creating initial trace chunk of session \"%s\"",
2762 session->name);
2763 trace_chunk = session_create_new_trace_chunk(
2764 session, NULL, NULL, NULL);
2765 if (!trace_chunk) {
2766 ret = LTTNG_ERR_CREATE_DIR_FAIL;
2767 goto error;
2768 }
a0377dfe 2769 LTTNG_ASSERT(!session->current_trace_chunk);
7966af57 2770 ret = (lttng_error_code) session_set_trace_chunk(session, trace_chunk,
1f496244
JG
2771 NULL);
2772 lttng_trace_chunk_put(trace_chunk);
2773 if (ret) {
2774 ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
2775 goto error;
2776 }
2777 } else {
2778 DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk",
2779 session->name);
2780 /*
2781 * Rotate existing streams into the new chunk.
2782 * This is a "quiet" rotation has no client has
2783 * explicitly requested this operation.
2784 *
2785 * There is also no need to wait for the rotation
2786 * to complete as it will happen immediately. No data
2787 * was produced as the session was stopped, so the
2788 * rotation should happen on reception of the command.
2789 */
7966af57 2790 ret = (lttng_error_code) cmd_rotate_session(session, NULL, true,
343defc2 2791 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
1f496244
JG
2792 if (ret != LTTNG_OK) {
2793 goto error;
2794 }
5c408ad8 2795 }
c996624c
JD
2796 }
2797
2f77fc4b
DG
2798 /* Kernel tracing */
2799 if (ksession != NULL) {
c996624c 2800 DBG("Start kernel tracing session %s", session->name);
7966af57 2801 ret = (lttng_error_code) start_kernel_session(ksession);
9b6c7ec5 2802 if (ret != LTTNG_OK) {
2f77fc4b
DG
2803 goto error;
2804 }
2f77fc4b
DG
2805 }
2806
2807 /* Flag session that trace should start automatically */
2808 if (usess) {
82b69413
JG
2809 int int_ret = ust_app_start_trace_all(usess);
2810
2811 if (int_ret < 0) {
f73fabfd 2812 ret = LTTNG_ERR_UST_START_FAIL;
2f77fc4b
DG
2813 goto error;
2814 }
2815 }
2816
04ed9e10
JG
2817 /*
2818 * Open a packet in every stream of the session to ensure that viewers
2819 * can correctly identify the boundaries of the periods during which
2820 * tracing was active for this session.
2821 */
2822 ret = session_open_packets(session);
2823 if (ret != LTTNG_OK) {
2824 goto error;
2825 }
2826
5c408ad8
JD
2827 /*
2828 * Clear the flag that indicates that a rotation was done while the
2829 * session was stopped.
2830 */
2831 session->rotated_after_last_stop = false;
2832
355cf1bd 2833 if (session->rotate_timer_period && !session->rotation_schedule_timer_enabled) {
82b69413
JG
2834 int int_ret = timer_session_rotation_schedule_timer_start(
2835 session, session->rotate_timer_period);
2836
2837 if (int_ret < 0) {
259c2674
JD
2838 ERR("Failed to enable rotate timer");
2839 ret = LTTNG_ERR_UNK;
2840 goto error;
2841 }
2842 }
2843
f73fabfd 2844 ret = LTTNG_OK;
2f77fc4b
DG
2845
2846error:
1f496244
JG
2847 if (ret == LTTNG_OK) {
2848 /* Flag this after a successful start. */
2849 session->has_been_started |= 1;
2850 } else {
2851 session->active = 0;
2852 /* Restore initial state on error. */
2853 session->rotated_after_last_stop =
2854 session_rotated_after_last_stop;
b02f5986
MD
2855 session->cleared_after_last_stop =
2856 session_cleared_after_last_stop;
1f496244 2857 }
7a24ece3 2858end:
2f77fc4b
DG
2859 return ret;
2860}
2861
2862/*
2863 * Command LTTNG_STOP_TRACE processed by the client thread.
2864 */
2865int cmd_stop_trace(struct ltt_session *session)
2866{
2867 int ret;
2f77fc4b
DG
2868 struct ltt_kernel_session *ksession;
2869 struct ltt_ust_session *usess;
2870
a0377dfe 2871 LTTNG_ASSERT(session);
2f77fc4b 2872
4dbe1875 2873 DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id);
2f77fc4b
DG
2874 /* Short cut */
2875 ksession = session->kernel_session;
2876 usess = session->ust_session;
2877
40afd77d 2878 /* Session is not active. Skip everything and inform the client. */
8382cf6f 2879 if (!session->active) {
f73fabfd 2880 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
2f77fc4b
DG
2881 goto error;
2882 }
2883
4dbe1875
MD
2884 ret = stop_kernel_session(ksession);
2885 if (ret != LTTNG_OK) {
2886 goto error;
2f77fc4b
DG
2887 }
2888
14fb1ebe 2889 if (usess && usess->active) {
2f77fc4b
DG
2890 ret = ust_app_stop_trace_all(usess);
2891 if (ret < 0) {
f73fabfd 2892 ret = LTTNG_ERR_UST_STOP_FAIL;
2f77fc4b
DG
2893 goto error;
2894 }
2895 }
2896
4dbe1875
MD
2897 DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name,
2898 session->id);
8382cf6f
DG
2899 /* Flag inactive after a successful stop. */
2900 session->active = 0;
4dbe1875 2901 ret = LTTNG_OK;
2f77fc4b
DG
2902
2903error:
2904 return ret;
2905}
2906
2907/*
433f5ba9
JR
2908 * Set the base_path of the session only if subdir of a control uris is set.
2909 * Return LTTNG_OK on success, otherwise LTTNG_ERR_*.
2f77fc4b 2910 */
433f5ba9
JR
2911static int set_session_base_path_from_uris(struct ltt_session *session,
2912 size_t nb_uri,
bda32d56 2913 struct lttng_uri *uris)
2f77fc4b 2914{
433f5ba9
JR
2915 int ret;
2916 size_t i;
2f77fc4b 2917
e3876bf0
JR
2918 for (i = 0; i < nb_uri; i++) {
2919 if (uris[i].stype != LTTNG_STREAM_CONTROL ||
2920 uris[i].subdir[0] == '\0') {
2921 /* Not interested in these URIs */
2922 continue;
2923 }
2924
2925 if (session->base_path != NULL) {
2926 free(session->base_path);
2927 session->base_path = NULL;
2928 }
2929
2930 /* Set session base_path */
2931 session->base_path = strdup(uris[i].subdir);
2932 if (!session->base_path) {
433f5ba9
JR
2933 PERROR("Failed to copy base path \"%s\" to session \"%s\"",
2934 uris[i].subdir, session->name);
2935 ret = LTTNG_ERR_NOMEM;
e3876bf0
JR
2936 goto error;
2937 }
433f5ba9
JR
2938 DBG2("Setting base path \"%s\" for session \"%s\"",
2939 session->base_path, session->name);
2940 }
2941 ret = LTTNG_OK;
2942error:
2943 return ret;
2944}
2945
2946/*
2947 * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
2948 */
2949int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
2950 struct lttng_uri *uris)
2951{
2952 int ret, i;
2953 struct ltt_kernel_session *ksess = session->kernel_session;
2954 struct ltt_ust_session *usess = session->ust_session;
2955
a0377dfe
FD
2956 LTTNG_ASSERT(session);
2957 LTTNG_ASSERT(uris);
2958 LTTNG_ASSERT(nb_uri > 0);
433f5ba9
JR
2959
2960 /* Can't set consumer URI if the session is active. */
2961 if (session->active) {
2962 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2963 goto error;
2964 }
2965
2966 /*
2967 * Set the session base path if any. This is done inside
2968 * cmd_set_consumer_uri to preserve backward compatibility of the
2969 * previous session creation api vs the session descriptor api.
2970 */
2971 ret = set_session_base_path_from_uris(session, nb_uri, uris);
2972 if (ret != LTTNG_OK) {
2973 goto error;
e3876bf0
JR
2974 }
2975
bda32d56 2976 /* Set the "global" consumer URIs */
2f77fc4b 2977 for (i = 0; i < nb_uri; i++) {
e3876bf0
JR
2978 ret = add_uri_to_consumer(session, session->consumer, &uris[i],
2979 LTTNG_DOMAIN_NONE);
a74934ba 2980 if (ret != LTTNG_OK) {
2f77fc4b
DG
2981 goto error;
2982 }
2f77fc4b
DG
2983 }
2984
bda32d56
JG
2985 /* Set UST session URIs */
2986 if (session->ust_session) {
2987 for (i = 0; i < nb_uri; i++) {
b178f53e 2988 ret = add_uri_to_consumer(session,
bda32d56 2989 session->ust_session->consumer,
b178f53e 2990 &uris[i], LTTNG_DOMAIN_UST);
bda32d56
JG
2991 if (ret != LTTNG_OK) {
2992 goto error;
2993 }
2994 }
2995 }
2996
2997 /* Set kernel session URIs */
2998 if (session->kernel_session) {
2999 for (i = 0; i < nb_uri; i++) {
b178f53e 3000 ret = add_uri_to_consumer(session,
bda32d56 3001 session->kernel_session->consumer,
b178f53e 3002 &uris[i], LTTNG_DOMAIN_KERNEL);
bda32d56
JG
3003 if (ret != LTTNG_OK) {
3004 goto error;
3005 }
3006 }
3007 }
3008
7ab70fe0
DG
3009 /*
3010 * Make sure to set the session in output mode after we set URI since a
3011 * session can be created without URL (thus flagged in no output mode).
3012 */
3013 session->output_traces = 1;
3014 if (ksess) {
3015 ksess->output_traces = 1;
bda32d56
JG
3016 }
3017
3018 if (usess) {
7ab70fe0
DG
3019 usess->output_traces = 1;
3020 }
3021
2f77fc4b 3022 /* All good! */
f73fabfd 3023 ret = LTTNG_OK;
2f77fc4b
DG
3024
3025error:
3026 return ret;
3027}
3028
b178f53e
JG
3029static
3030enum lttng_error_code set_session_output_from_descriptor(
3031 struct ltt_session *session,
3032 const struct lttng_session_descriptor *descriptor)
2f77fc4b
DG
3033{
3034 int ret;
b178f53e
JG
3035 enum lttng_error_code ret_code = LTTNG_OK;
3036 enum lttng_session_descriptor_type session_type =
3037 lttng_session_descriptor_get_type(descriptor);
3038 enum lttng_session_descriptor_output_type output_type =
3039 lttng_session_descriptor_get_output_type(descriptor);
3040 struct lttng_uri uris[2] = {};
3041 size_t uri_count = 0;
3042
3043 switch (output_type) {
3044 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
3045 goto end;
3046 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
3047 lttng_session_descriptor_get_local_output_uri(descriptor,
3048 &uris[0]);
3049 uri_count = 1;
3050 break;
3051 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
3052 lttng_session_descriptor_get_network_output_uris(descriptor,
3053 &uris[0], &uris[1]);
3054 uri_count = 2;
3055 break;
3056 default:
3057 ret_code = LTTNG_ERR_INVALID;
e32d7f27 3058 goto end;
2f77fc4b
DG
3059 }
3060
b178f53e
JG
3061 switch (session_type) {
3062 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
3063 {
3064 struct snapshot_output *new_output = NULL;
3065
3066 new_output = snapshot_output_alloc();
3067 if (!new_output) {
3068 ret_code = LTTNG_ERR_NOMEM;
3069 goto end;
3070 }
3071
3072 ret = snapshot_output_init_with_uri(session,
3073 DEFAULT_SNAPSHOT_MAX_SIZE,
3074 NULL, uris, uri_count, session->consumer,
3075 new_output, &session->snapshot);
3076 if (ret < 0) {
3077 ret_code = (ret == -ENOMEM) ?
3078 LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID;
3079 snapshot_output_destroy(new_output);
3080 goto end;
3081 }
3082 snapshot_add_output(&session->snapshot, new_output);
3083 break;
3084 }
3085 case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
3086 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
3087 {
7966af57 3088 ret_code = (lttng_error_code) cmd_set_consumer_uri(session, uri_count, uris);
b178f53e
JG
3089 break;
3090 }
3091 default:
3092 ret_code = LTTNG_ERR_INVALID;
e32d7f27 3093 goto end;
2f77fc4b 3094 }
b178f53e
JG
3095end:
3096 return ret_code;
3097}
3098
3099static
3100enum lttng_error_code cmd_create_session_from_descriptor(
3101 struct lttng_session_descriptor *descriptor,
3102 const lttng_sock_cred *creds,
3103 const char *home_path)
3104{
3105 int ret;
3106 enum lttng_error_code ret_code;
3107 const char *session_name;
3108 struct ltt_session *new_session = NULL;
3109 enum lttng_session_descriptor_status descriptor_status;
2f77fc4b 3110
e32d7f27 3111 session_lock_list();
b178f53e
JG
3112 if (home_path) {
3113 if (*home_path != '/') {
3114 ERR("Home path provided by client is not absolute");
3115 ret_code = LTTNG_ERR_INVALID;
3116 goto end;
3117 }
3118 }
2f77fc4b 3119
b178f53e
JG
3120 descriptor_status = lttng_session_descriptor_get_session_name(
3121 descriptor, &session_name);
3122 switch (descriptor_status) {
3123 case LTTNG_SESSION_DESCRIPTOR_STATUS_OK:
3124 break;
3125 case LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET:
3126 session_name = NULL;
3127 break;
3128 default:
3129 ret_code = LTTNG_ERR_INVALID;
3130 goto end;
3131 }
e3876bf0 3132
b178f53e 3133 ret_code = session_create(session_name, creds->uid, creds->gid,
e3876bf0 3134 &new_session);
b178f53e 3135 if (ret_code != LTTNG_OK) {
e32d7f27 3136 goto end;
2f77fc4b
DG
3137 }
3138
b178f53e
JG
3139 if (!session_name) {
3140 ret = lttng_session_descriptor_set_session_name(descriptor,
3141 new_session->name);
3142 if (ret) {
3143 ret_code = LTTNG_ERR_SESSION_FAIL;
3144 goto end;
3145 }
3146 }
3147
3148 if (!lttng_session_descriptor_is_output_destination_initialized(
3149 descriptor)) {
3150 /*
3151 * Only include the session's creation time in the output
3152 * destination if the name of the session itself was
3153 * not auto-generated.
3154 */
3155 ret_code = lttng_session_descriptor_set_default_output(
3156 descriptor,
3157 session_name ? &new_session->creation_time : NULL,
3158 home_path);
3159 if (ret_code != LTTNG_OK) {
e32d7f27 3160 goto end;
2bba9e53 3161 }
2bba9e53 3162 } else {
b178f53e
JG
3163 new_session->has_user_specified_directory =
3164 lttng_session_descriptor_has_output_directory(
3165 descriptor);
2f77fc4b
DG
3166 }
3167
b178f53e
JG
3168 switch (lttng_session_descriptor_get_type(descriptor)) {
3169 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
3170 new_session->snapshot_mode = 1;
3171 break;
3172 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
3173 new_session->live_timer =
3174 lttng_session_descriptor_live_get_timer_interval(
3175 descriptor);
3176 break;
3177 default:
3178 break;
3179 }
2f77fc4b 3180
b178f53e
JG
3181 ret_code = set_session_output_from_descriptor(new_session, descriptor);
3182 if (ret_code != LTTNG_OK) {
3183 goto end;
3184 }
3185 new_session->consumer->enabled = 1;
3186 ret_code = LTTNG_OK;
e32d7f27 3187end:
b178f53e
JG
3188 /* Release reference provided by the session_create function. */
3189 session_put(new_session);
3190 if (ret_code != LTTNG_OK && new_session) {
3191 /* Release the global reference on error. */
3192 session_destroy(new_session);
e32d7f27 3193 }
b178f53e
JG
3194 session_unlock_list();
3195 return ret_code;
2f77fc4b
DG
3196}
3197
b178f53e
JG
3198enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
3199 struct lttng_session_descriptor **return_descriptor)
27babd3a
DG
3200{
3201 int ret;
b178f53e
JG
3202 size_t payload_size;
3203 struct lttng_dynamic_buffer payload;
3204 struct lttng_buffer_view home_dir_view;
3205 struct lttng_buffer_view session_descriptor_view;
3206 struct lttng_session_descriptor *session_descriptor = NULL;
3207 enum lttng_error_code ret_code;
3208
3209 lttng_dynamic_buffer_init(&payload);
3a91de3a 3210 if (cmd_ctx->lsm.u.create_session.home_dir_size >=
b178f53e
JG
3211 LTTNG_PATH_MAX) {
3212 ret_code = LTTNG_ERR_INVALID;
3213 goto error;
27babd3a 3214 }
3a91de3a 3215 if (cmd_ctx->lsm.u.create_session.session_descriptor_size >
b178f53e
JG
3216 LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
3217 ret_code = LTTNG_ERR_INVALID;
3218 goto error;
27babd3a
DG
3219 }
3220
3a91de3a
JG
3221 payload_size = cmd_ctx->lsm.u.create_session.home_dir_size +
3222 cmd_ctx->lsm.u.create_session.session_descriptor_size;
b178f53e
JG
3223 ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
3224 if (ret) {
3225 ret_code = LTTNG_ERR_NOMEM;
3226 goto error;
27babd3a
DG
3227 }
3228
b178f53e
JG
3229 ret = lttcomm_recv_unix_sock(sock, payload.data, payload.size);
3230 if (ret <= 0) {
3231 ERR("Reception of session descriptor failed, aborting.");
3232 ret_code = LTTNG_ERR_SESSION_FAIL;
3233 goto error;
27babd3a
DG
3234 }
3235
b178f53e
JG
3236 home_dir_view = lttng_buffer_view_from_dynamic_buffer(
3237 &payload,
3238 0,
3a91de3a 3239 cmd_ctx->lsm.u.create_session.home_dir_size);
3e6e0df2
JG
3240 if (cmd_ctx->lsm.u.create_session.home_dir_size > 0 &&
3241 !lttng_buffer_view_is_valid(&home_dir_view)) {
3242 ERR("Invalid payload in \"create session\" command: buffer too short to contain home directory");
3243 ret_code = LTTNG_ERR_INVALID_PROTOCOL;
3244 goto error;
3245 }
3246
b178f53e
JG
3247 session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
3248 &payload,
3a91de3a
JG
3249 cmd_ctx->lsm.u.create_session.home_dir_size,
3250 cmd_ctx->lsm.u.create_session.session_descriptor_size);
3e6e0df2
JG
3251 if (!lttng_buffer_view_is_valid(&session_descriptor_view)) {
3252 ERR("Invalid payload in \"create session\" command: buffer too short to contain session descriptor");
3253 ret_code = LTTNG_ERR_INVALID_PROTOCOL;
3254 goto error;
3255 }
27babd3a 3256
b178f53e
JG
3257 ret = lttng_session_descriptor_create_from_buffer(
3258 &session_descriptor_view, &session_descriptor);
3259 if (ret < 0) {
3260 ERR("Failed to create session descriptor from payload of \"create session\" command");
3261 ret_code = LTTNG_ERR_INVALID;
3262 goto error;
3263 }
27babd3a 3264
b178f53e
JG
3265 /*
3266 * Sets the descriptor's auto-generated properties (name, output) if
3267 * needed.
3268 */
3269 ret_code = cmd_create_session_from_descriptor(session_descriptor,
3270 &cmd_ctx->creds,
3271 home_dir_view.size ? home_dir_view.data : NULL);
3272 if (ret_code != LTTNG_OK) {
3273 goto error;
e32d7f27 3274 }
b178f53e
JG
3275
3276 ret_code = LTTNG_OK;
3277 *return_descriptor = session_descriptor;
3278 session_descriptor = NULL;
3279error:
3280 lttng_dynamic_buffer_reset(&payload);
3281 lttng_session_descriptor_destroy(session_descriptor);
3282 return ret_code;
27babd3a
DG
3283}
3284
3e3665b8
JG
3285static
3286void cmd_destroy_session_reply(const struct ltt_session *session,
3287 void *_reply_context)
3288{
3289 int ret;
3290 ssize_t comm_ret;
3291 const struct cmd_destroy_session_reply_context *reply_context =
7966af57 3292 (cmd_destroy_session_reply_context *) _reply_context;
3e3665b8
JG
3293 struct lttng_dynamic_buffer payload;
3294 struct lttcomm_session_destroy_command_header cmd_header;
3295 struct lttng_trace_archive_location *location = NULL;
3296 struct lttcomm_lttng_msg llm = {
3297 .cmd_type = LTTNG_DESTROY_SESSION,
3285a971 3298 .ret_code = reply_context->destruction_status,
3e3665b8
JG
3299 .pid = UINT32_MAX,
3300 .cmd_header_size =
3301 sizeof(struct lttcomm_session_destroy_command_header),
3302 .data_size = 0,
1c9a0b0e 3303 .fd_count = 0,
3e3665b8
JG
3304 };
3305 size_t payload_size_before_location;
3306
3307 lttng_dynamic_buffer_init(&payload);
3308
3309 ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm));
0e270a1e 3310 if (ret) {
3e3665b8
JG
3311 ERR("Failed to append session destruction message");
3312 goto error;
0e270a1e 3313 }
3e3665b8
JG
3314
3315 cmd_header.rotation_state =
3316 (int32_t) (reply_context->implicit_rotation_on_destroy ?
3317 session->rotation_state :
3318 LTTNG_ROTATION_STATE_NO_ROTATION);
3319 ret = lttng_dynamic_buffer_append(&payload, &cmd_header,
3320 sizeof(cmd_header));
3321 if (ret) {
3322 ERR("Failed to append session destruction command header");
3323 goto error;
3324 }
3325
3326 if (!reply_context->implicit_rotation_on_destroy) {
3327 DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply",
3328 session->name);
3329 goto send_reply;
3330 }
3331 if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) {
3332 DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply",
3333 session->name);
3334 goto send_reply;
3335 }
3336
3337 location = session_get_trace_archive_location(session);
3338 if (!location) {
3339 ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"",
3340 session->name);
3341 goto error;
3342 }
3343
3344 payload_size_before_location = payload.size;
3345 comm_ret = lttng_trace_archive_location_serialize(location,
3346 &payload);
d3740619 3347 lttng_trace_archive_location_put(location);
3e3665b8
JG
3348 if (comm_ret < 0) {
3349 ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
3350 session->name);
3351 goto error;
3352 }
3353 /* Update the message to indicate the location's length. */
3354 ((struct lttcomm_lttng_msg *) payload.data)->data_size =
3355 payload.size - payload_size_before_location;
3356send_reply:
3357 comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd,
3358 payload.data, payload.size);
3359 if (comm_ret != (ssize_t) payload.size) {
3360 ERR("Failed to send result of the destruction of session \"%s\" to client",
3361 session->name);
3362 }
3363error:
3364 ret = close(reply_context->reply_sock_fd);
3365 if (ret) {
3366 PERROR("Failed to close client socket in deferred session destroy reply");
3367 }
3368 lttng_dynamic_buffer_reset(&payload);
3369 free(_reply_context);
3370}
3371
2f77fc4b
DG
3372/*
3373 * Command LTTNG_DESTROY_SESSION processed by the client thread.
a9ad0c8f
MD
3374 *
3375 * Called with session lock held.
2f77fc4b 3376 */
e32d7f27 3377int cmd_destroy_session(struct ltt_session *session,
3e3665b8
JG
3378 struct notification_thread_handle *notification_thread_handle,
3379 int *sock_fd)
2f77fc4b
DG
3380{
3381 int ret;
3285a971 3382 enum lttng_error_code destruction_last_error = LTTNG_OK;
3e3665b8
JG
3383 struct cmd_destroy_session_reply_context *reply_context = NULL;
3384
3385 if (sock_fd) {
64803277 3386 reply_context = zmalloc<cmd_destroy_session_reply_context>();
3e3665b8
JG
3387 if (!reply_context) {
3388 ret = LTTNG_ERR_NOMEM;
3389 goto end;
3390 }
64803277 3391
3e3665b8
JG
3392 reply_context->reply_sock_fd = *sock_fd;
3393 }
2f77fc4b
DG
3394
3395 /* Safety net */
a0377dfe 3396 LTTNG_ASSERT(session);
2f77fc4b 3397
3e3665b8
JG
3398 DBG("Begin destroy session %s (id %" PRIu64 ")", session->name,
3399 session->id);
3400 if (session->active) {
3401 DBG("Session \"%s\" is active, attempting to stop it before destroying it",
3402 session->name);
3403 ret = cmd_stop_trace(session);
3404 if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) {
3405 /* Carry on with the destruction of the session. */
3406 ERR("Failed to stop session \"%s\" as part of its destruction: %s",
3407 session->name, lttng_strerror(-ret));
7966af57 3408 destruction_last_error = (lttng_error_code) ret;
3e3665b8
JG
3409 }
3410 }
5c408ad8 3411
92816cc3
JG
3412 if (session->rotation_schedule_timer_enabled) {
3413 if (timer_session_rotation_schedule_timer_stop(
3414 session)) {
3415 ERR("Failed to stop the \"rotation schedule\" timer of session %s",
3416 session->name);
3285a971 3417 destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;
92816cc3 3418 }
259c2674
JD
3419 }
3420
90936dcf
JD
3421 if (session->rotate_size) {
3422 unsubscribe_session_consumed_size_rotation(session, notification_thread_handle);
3423 session->rotate_size = 0;
3424 }
3425
a7ceb342 3426 if (session->rotated && session->current_trace_chunk && session->output_traces) {
b5893d8e
JG
3427 /*
3428 * Perform a last rotation on destruction if rotations have
3429 * occurred during the session's lifetime.
3430 */
343defc2
MD
3431 ret = cmd_rotate_session(session, NULL, false,
3432 LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
d2956687
JG
3433 if (ret != LTTNG_OK) {
3434 ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
3435 session->name, lttng_strerror(-ret));
7966af57 3436 destruction_last_error = (lttng_error_code) -ret;
124473a3 3437 }
0e270a1e 3438 if (reply_context) {
3e3665b8 3439 reply_context->implicit_rotation_on_destroy = true;
0e270a1e
JG
3440 }
3441 } else if (session->has_been_started && session->current_trace_chunk) {
7fdbed1c
JG
3442 /*
3443 * The user has not triggered a session rotation. However, to
3444 * ensure all data has been consumed, the session is rotated
3445 * to a 'null' trace chunk before it is destroyed.
3446 *
3447 * This is a "quiet" rotation meaning that no notification is
3448 * emitted and no renaming of the current trace chunk takes
3449 * place.
3450 */
343defc2
MD
3451 ret = cmd_rotate_session(session, NULL, true,
3452 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
53fb6336
JG
3453 /*
3454 * Rotation operations may not be supported by the kernel
3455 * tracer. Hence, do not consider this implicit rotation as
3456 * a session destruction error. The library has already stopped
3457 * the session and waited for pending data; there is nothing
3458 * left to do but complete the destruction of the session.
3459 */
3460 if (ret != LTTNG_OK &&
3461 ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) {
7fdbed1c 3462 ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
53fb6336 3463 session->name, lttng_strerror(ret));
7966af57 3464 destruction_last_error = (lttng_error_code) -ret;
7fdbed1c
JG
3465 }
3466 }
5c408ad8 3467
a503e1ef
JG
3468 if (session->shm_path[0]) {
3469 /*
3470 * When a session is created with an explicit shm_path,
3471 * the consumer daemon will create its shared memory files
3472 * at that location and will *not* unlink them. This is normal
3473 * as the intention of that feature is to make it possible
3474 * to retrieve the content of those files should a crash occur.
3475 *
3476 * To ensure the content of those files can be used, the
3477 * sessiond daemon will replicate the content of the metadata
3478 * cache in a metadata file.
3479 *
3480 * On clean-up, it is expected that the consumer daemon will
3481 * unlink the shared memory files and that the session daemon
3482 * will unlink the metadata file. Then, the session's directory
3483 * in the shm path can be removed.
3484 *
3485 * Unfortunately, a flaw in the design of the sessiond's and
3486 * consumerd's tear down of channels makes it impossible to
3487 * determine when the sessiond _and_ the consumerd have both
3488 * destroyed their representation of a channel. For one, the
3489 * unlinking, close, and rmdir happen in deferred 'call_rcu'
3490 * callbacks in both daemons.
3491 *
3492 * However, it is also impossible for the sessiond to know when
3493 * the consumer daemon is done destroying its channel(s) since
3494 * it occurs as a reaction to the closing of the channel's file
3495 * descriptor. There is no resulting communication initiated
3496 * from the consumerd to the sessiond to confirm that the
3497 * operation is completed (and was successful).
3498 *
3499 * Until this is all fixed, the session daemon checks for the
3500 * removal of the session's shm path which makes it possible
3501 * to safely advertise a session as having been destroyed.
3502 *
3503 * Prior to this fix, it was not possible to reliably save
3504 * a session making use of the --shm-path option, destroy it,
3505 * and load it again. This is because the creation of the
3506 * session would fail upon seeing the session's shm path
3507 * already in existence.
3508 *
3509 * Note that none of the error paths in the check for the
3510 * directory's existence return an error. This is normal
3511 * as there isn't much that can be done. The session will
3512 * be destroyed properly, except that we can't offer the
3513 * guarantee that the same session can be re-created.
3514 */
3515 current_completion_handler = &destroy_completion_handler.handler;
3516 ret = lttng_strncpy(destroy_completion_handler.shm_path,
3517 session->shm_path,
3518 sizeof(destroy_completion_handler.shm_path));
a0377dfe 3519 LTTNG_ASSERT(!ret);
a503e1ef 3520 }
e32d7f27
JG
3521
3522 /*
3523 * The session is destroyed. However, note that the command context
3524 * still holds a reference to the session, thus delaying its destruction
3525 * _at least_ up to the point when that reference is released.
3526 */
3527 session_destroy(session);
3e3665b8 3528 if (reply_context) {
3285a971 3529 reply_context->destruction_status = destruction_last_error;
3e3665b8
JG
3530 ret = session_add_destroy_notifier(session,
3531 cmd_destroy_session_reply,
3532 (void *) reply_context);
3533 if (ret) {
3534 ret = LTTNG_ERR_FATAL;
3535 goto end;
3536 } else {
3537 *sock_fd = -1;
3538 }
0e270a1e
JG
3539 }
3540 ret = LTTNG_OK;
3e3665b8 3541end:
2f77fc4b
DG
3542 return ret;
3543}
3544
2f77fc4b
DG
3545/*
3546 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
3547 */
56a37563
JG
3548int cmd_register_consumer(struct ltt_session *session,
3549 enum lttng_domain_type domain, const char *sock_path,
3550 struct consumer_data *cdata)
2f77fc4b
DG
3551{
3552 int ret, sock;
dd81b457 3553 struct consumer_socket *socket = NULL;
2f77fc4b 3554
a0377dfe
FD
3555 LTTNG_ASSERT(session);
3556 LTTNG_ASSERT(cdata);
3557 LTTNG_ASSERT(sock_path);
2f77fc4b
DG
3558
3559 switch (domain) {
3560 case LTTNG_DOMAIN_KERNEL:
3561 {
3562 struct ltt_kernel_session *ksess = session->kernel_session;
3563
a0377dfe 3564 LTTNG_ASSERT(ksess);
2f77fc4b
DG
3565
3566 /* Can't register a consumer if there is already one */
3567 if (ksess->consumer_fds_sent != 0) {
f73fabfd 3568 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
3569 goto error;
3570 }
3571
3572 sock = lttcomm_connect_unix_sock(sock_path);
3573 if (sock < 0) {
f73fabfd 3574 ret = LTTNG_ERR_CONNECT_FAIL;
2f77fc4b
DG
3575 goto error;
3576 }
4ce514c4 3577 cdata->cmd_sock = sock;
2f77fc4b 3578
4ce514c4 3579 socket = consumer_allocate_socket(&cdata->cmd_sock);
2f77fc4b 3580 if (socket == NULL) {
f66c074c
DG
3581 ret = close(sock);
3582 if (ret < 0) {
3583 PERROR("close register consumer");
3584 }
4ce514c4 3585 cdata->cmd_sock = -1;
f73fabfd 3586 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3587 goto error;
3588 }
3589
64803277 3590 socket->lock = zmalloc<pthread_mutex_t>();
2f77fc4b
DG
3591 if (socket->lock == NULL) {
3592 PERROR("zmalloc pthread mutex");
f73fabfd 3593 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3594 goto error;
3595 }
64803277 3596
2f77fc4b
DG
3597 pthread_mutex_init(socket->lock, NULL);
3598 socket->registered = 1;
3599
3600 rcu_read_lock();
3601 consumer_add_socket(socket, ksess->consumer);
3602 rcu_read_unlock();
3603
3604 pthread_mutex_lock(&cdata->pid_mutex);
3605 cdata->pid = -1;
3606 pthread_mutex_unlock(&cdata->pid_mutex);
3607
3608 break;
3609 }
3610 default:
3611 /* TODO: Userspace tracing */
f73fabfd 3612 ret = LTTNG_ERR_UND;
2f77fc4b
DG
3613 goto error;
3614 }
3615
dd81b457 3616 return LTTNG_OK;
2f77fc4b
DG
3617
3618error:
dd81b457
DG
3619 if (socket) {
3620 consumer_destroy_socket(socket);
3621 }
2f77fc4b
DG
3622 return ret;
3623}
3624
3625/*
3626 * Command LTTNG_LIST_DOMAINS processed by the client thread.
3627 */
3628ssize_t cmd_list_domains(struct ltt_session *session,
3629 struct lttng_domain **domains)
3630{
3631 int ret, index = 0;
3632 ssize_t nb_dom = 0;
fefd409b
DG
3633 struct agent *agt;
3634 struct lttng_ht_iter iter;
2f77fc4b
DG
3635
3636 if (session->kernel_session != NULL) {
3637 DBG3("Listing domains found kernel domain");
3638 nb_dom++;
3639 }
3640
3641 if (session->ust_session != NULL) {
3642 DBG3("Listing domains found UST global domain");
3643 nb_dom++;
3c6a091f 3644
e0a74f01 3645 rcu_read_lock();
fefd409b
DG
3646 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3647 agt, node.node) {
3648 if (agt->being_used) {
3649 nb_dom++;
3650 }
3c6a091f 3651 }
e0a74f01 3652 rcu_read_unlock();
2f77fc4b
DG
3653 }
3654
fa64dfb4
JG
3655 if (!nb_dom) {
3656 goto end;
3657 }
3658
64803277 3659 *domains = calloc<lttng_domain>(nb_dom);
2f77fc4b 3660 if (*domains == NULL) {
f73fabfd 3661 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3662 goto error;
3663 }
3664
3665 if (session->kernel_session != NULL) {
3666 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
b5edb9e8
PP
3667
3668 /* Kernel session buffer type is always GLOBAL */
3669 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
3670
2f77fc4b
DG
3671 index++;
3672 }
3673
3674 if (session->ust_session != NULL) {
3675 (*domains)[index].type = LTTNG_DOMAIN_UST;
88c5f0d8 3676 (*domains)[index].buf_type = session->ust_session->buffer_type;
2f77fc4b 3677 index++;
3c6a091f 3678
e0a74f01 3679 rcu_read_lock();
fefd409b
DG
3680 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3681 agt, node.node) {
3682 if (agt->being_used) {
3683 (*domains)[index].type = agt->domain;
3684 (*domains)[index].buf_type = session->ust_session->buffer_type;
3685 index++;
3686 }
3c6a091f 3687 }
e0a74f01 3688 rcu_read_unlock();
2f77fc4b 3689 }
fa64dfb4 3690end:
2f77fc4b
DG
3691 return nb_dom;
3692
3693error:
f73fabfd
DG
3694 /* Return negative value to differentiate return code */
3695 return -ret;
2f77fc4b
DG
3696}
3697
3698
3699/*
3700 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3701 */
999af9c1
JR
3702enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain,
3703 struct ltt_session *session,
3704 struct lttng_payload *payload)
2f77fc4b 3705{
999af9c1
JR
3706 int ret = 0;
3707 unsigned int i = 0;
3708 struct lttcomm_list_command_header cmd_header = {};
3709 size_t cmd_header_offset;
3710 enum lttng_error_code ret_code;
3711
3712 assert(session);
3713 assert(payload);
3714
3715 DBG("Listing channels for session %s", session->name);
3716
3717 cmd_header_offset = payload->buffer.size;
3718
3719 /* Reserve space for command reply header. */
3720 ret = lttng_dynamic_buffer_set_size(&payload->buffer,
3721 cmd_header_offset + sizeof(cmd_header));
3722 if (ret) {
3723 ret_code = LTTNG_ERR_NOMEM;
3724 goto end;
3725 }
2f77fc4b
DG
3726
3727 switch (domain) {
3728 case LTTNG_DOMAIN_KERNEL:
999af9c1
JR
3729 {
3730 /* Kernel channels */
3731 struct ltt_kernel_channel *kchan;
2f77fc4b 3732 if (session->kernel_session != NULL) {
999af9c1
JR
3733 cds_list_for_each_entry(kchan,
3734 &session->kernel_session->channel_list.head, list) {
3735 uint64_t discarded_events, lost_packets;
3736 struct lttng_channel_extended *extended;
3737
3738 extended = (struct lttng_channel_extended *)
3739 kchan->channel->attr.extended.ptr;
3740
3741 ret = get_kernel_runtime_stats(session, kchan,
3742 &discarded_events, &lost_packets);
3743 if (ret < 0) {
3744 ret_code = LTTNG_ERR_UNK;
3745 goto end;
3746 }
3747
3748 /*
3749 * Update the discarded_events and lost_packets
3750 * count for the channel
3751 */
3752 extended->discarded_events = discarded_events;
3753 extended->lost_packets = lost_packets;
3754
3755 ret = lttng_channel_serialize(
3756 kchan->channel, &payload->buffer);
3757 if (ret) {
3758 ERR("Failed to serialize lttng_channel: channel name = '%s'",
3759 kchan->channel->name);
3760 ret_code = LTTNG_ERR_UNK;
3761 goto end;
3762 }
3763
3764 i++;
3765 }
c7d620a2 3766 }
2f77fc4b 3767 break;
999af9c1 3768 }
2f77fc4b 3769 case LTTNG_DOMAIN_UST:
999af9c1
JR
3770 {
3771 struct lttng_ht_iter iter;
3772 struct ltt_ust_channel *uchan;
3773
3774 rcu_read_lock();
3775 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
3776 &iter.iter, uchan, node.node) {
3777 uint64_t discarded_events = 0, lost_packets = 0;
3778 struct lttng_channel *channel = NULL;
3779 struct lttng_channel_extended *extended;
3780
3781 channel = trace_ust_channel_to_lttng_channel(uchan);
3782 if (!channel) {
9402f166
JR
3783 ret_code = LTTNG_ERR_NOMEM;
3784 goto end;
999af9c1
JR
3785 }
3786
3787 extended = (struct lttng_channel_extended *)
3788 channel->attr.extended.ptr;
3789
3790 ret = get_ust_runtime_stats(session, uchan,
3791 &discarded_events, &lost_packets);
3792 if (ret < 0) {
3793 lttng_channel_destroy(channel);
3794 ret_code = LTTNG_ERR_UNK;
9402f166 3795 goto end;
999af9c1
JR
3796 }
3797
3798 extended->discarded_events = discarded_events;
3799 extended->lost_packets = lost_packets;
3800
3801 ret = lttng_channel_serialize(
3802 channel, &payload->buffer);
3803 if (ret) {
3804 ERR("Failed to serialize lttng_channel: channel name = '%s'",
3805 channel->name);
ae2275af 3806 lttng_channel_destroy(channel);
999af9c1 3807 ret_code = LTTNG_ERR_UNK;
9402f166 3808 goto end;
999af9c1
JR
3809 }
3810
ae2275af 3811 lttng_channel_destroy(channel);
999af9c1 3812 i++;
c7d620a2 3813 }
999af9c1 3814 rcu_read_unlock();
2f77fc4b 3815 break;
999af9c1 3816 }
2f77fc4b 3817 default:
999af9c1 3818 break;
2f77fc4b
DG
3819 }
3820
999af9c1
JR
3821 if (i > UINT32_MAX) {
3822 ERR("Channel count would overflow the channel listing command's reply");
3823 ret_code = LTTNG_ERR_OVERFLOW;
3824 goto end;
2f77fc4b
DG
3825 }
3826
999af9c1
JR
3827 /* Update command reply header. */
3828 cmd_header.count = (uint32_t) i;
3829 memcpy(payload->buffer.data + cmd_header_offset, &cmd_header,
3830 sizeof(cmd_header));
3831 ret_code = LTTNG_OK;
3832
53e367f9 3833end:
999af9c1 3834 return ret_code;
2f77fc4b
DG
3835}
3836
3837/*
3838 * Command LTTNG_LIST_EVENTS processed by the client thread.
3839 */
8ddd72ef
JR
3840enum lttng_error_code cmd_list_events(enum lttng_domain_type domain,
3841 struct ltt_session *session,
3842 char *channel_name,
3843 struct lttng_payload *reply_payload)
2f77fc4b 3844{
8ddd72ef
JR
3845 int buffer_resize_ret;
3846 enum lttng_error_code ret_code = LTTNG_OK;
3847 struct lttcomm_list_command_header reply_command_header = {};
3848 size_t reply_command_header_offset;
23831239 3849 unsigned int nb_events = 0;
e368fb43 3850
8ddd72ef
JR
3851 assert(reply_payload);
3852
3853 /* Reserve space for command reply header. */
3854 reply_command_header_offset = reply_payload->buffer.size;
3855 buffer_resize_ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
3856 reply_command_header_offset +
3857 sizeof(struct lttcomm_list_command_header));
3858 if (buffer_resize_ret) {
3859 ret_code = LTTNG_ERR_NOMEM;
3860 goto end;
e368fb43 3861 }
2f77fc4b
DG
3862
3863 switch (domain) {
3864 case LTTNG_DOMAIN_KERNEL:
3865 if (session->kernel_session != NULL) {
8ddd72ef
JR
3866 ret_code = list_lttng_kernel_events(channel_name,
3867 session->kernel_session, reply_payload, &nb_events);
2f77fc4b 3868 }
8ddd72ef 3869
2f77fc4b
DG
3870 break;
3871 case LTTNG_DOMAIN_UST:
3872 {
3873 if (session->ust_session != NULL) {
8ddd72ef 3874 ret_code = list_lttng_ust_global_events(channel_name,
e368fb43 3875 &session->ust_session->domain_global,
8ddd72ef 3876 reply_payload, &nb_events);
2f77fc4b 3877 }
8ddd72ef 3878
2f77fc4b
DG
3879 break;
3880 }
5cdb6027 3881 case LTTNG_DOMAIN_LOG4J:
3c6a091f 3882 case LTTNG_DOMAIN_JUL:
0e115563 3883 case LTTNG_DOMAIN_PYTHON:
3c6a091f 3884 if (session->ust_session) {
fefd409b
DG
3885 struct lttng_ht_iter iter;
3886 struct agent *agt;
3887
b11feea5 3888 rcu_read_lock();
fefd409b
DG
3889 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3890 &iter.iter, agt, node.node) {
1dfd9906 3891 if (agt->domain == domain) {
8ddd72ef
JR
3892 ret_code = list_lttng_agent_events(
3893 agt, reply_payload, &nb_events);
1dfd9906
JG
3894 break;
3895 }
fefd409b 3896 }
8ddd72ef 3897
b11feea5 3898 rcu_read_unlock();
3c6a091f
DG
3899 }
3900 break;
2f77fc4b 3901 default:
8ddd72ef
JR
3902 ret_code = LTTNG_ERR_UND;
3903 break;
2f77fc4b
DG
3904 }
3905
8ddd72ef
JR
3906 if (nb_events > UINT32_MAX) {
3907 ret_code = LTTNG_ERR_OVERFLOW;
3908 goto end;
3909 }
e368fb43 3910
8ddd72ef
JR
3911 /* Update command reply header. */
3912 reply_command_header.count = (uint32_t) nb_events;
3913 memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
3914 sizeof(reply_command_header));
2f77fc4b 3915
8ddd72ef
JR
3916end:
3917 return ret_code;
2f77fc4b
DG
3918}
3919
3920/*
3921 * Using the session list, filled a lttng_session array to send back to the
3922 * client for session listing.
3923 *
3924 * The session list lock MUST be acquired before calling this function. Use
3925 * session_lock_list() and session_unlock_list().
3926 */
b178f53e
JG
3927void cmd_list_lttng_sessions(struct lttng_session *sessions,
3928 size_t session_count, uid_t uid, gid_t gid)
2f77fc4b
DG
3929{
3930 int ret;
3931 unsigned int i = 0;
3932 struct ltt_session *session;
3933 struct ltt_session_list *list = session_get_list();
0e270a1e 3934 struct lttng_session_extended *extended =
b178f53e 3935 (typeof(extended)) (&sessions[session_count]);
2f77fc4b
DG
3936
3937 DBG("Getting all available session for UID %d GID %d",
3938 uid, gid);
3939 /*
3940 * Iterate over session list and append data after the control struct in
3941 * the buffer.
3942 */
3943 cds_list_for_each_entry(session, &list->head, list) {
e32d7f27
JG
3944 if (!session_get(session)) {
3945 continue;
3946 }
2f77fc4b
DG
3947 /*
3948 * Only list the sessions the user can control.
3949 */
d7b377ed 3950 if (!session_access_ok(session, uid) ||
e32d7f27
JG
3951 session->destroyed) {
3952 session_put(session);
2f77fc4b
DG
3953 continue;
3954 }
3955
3956 struct ltt_kernel_session *ksess = session->kernel_session;
3957 struct ltt_ust_session *usess = session->ust_session;
3958
3959 if (session->consumer->type == CONSUMER_DST_NET ||
3960 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3961 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3962 ret = build_network_session_path(sessions[i].path,
dec56f6c 3963 sizeof(sessions[i].path), session);
2f77fc4b 3964 } else {
dec56f6c 3965 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
366a9222 3966 session->consumer->dst.session_root_path);
2f77fc4b
DG
3967 }
3968 if (ret < 0) {
3969 PERROR("snprintf session path");
e32d7f27 3970 session_put(session);
2f77fc4b
DG
3971 continue;
3972 }
3973
3974 strncpy(sessions[i].name, session->name, NAME_MAX);
3975 sessions[i].name[NAME_MAX - 1] = '\0';
8382cf6f 3976 sessions[i].enabled = session->active;
2cbf8fed 3977 sessions[i].snapshot_mode = session->snapshot_mode;
8960e9cd 3978 sessions[i].live_timer_interval = session->live_timer;
b178f53e
JG
3979 extended[i].creation_time.value = (uint64_t) session->creation_time;
3980 extended[i].creation_time.is_set = 1;
2f77fc4b 3981 i++;
e32d7f27 3982 session_put(session);
2f77fc4b
DG
3983 }
3984}
3985
806e2684 3986/*
6d805429 3987 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
d3f14b8a 3988 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
806e2684 3989 */
6d805429 3990int cmd_data_pending(struct ltt_session *session)
806e2684
DG
3991{
3992 int ret;
3993 struct ltt_kernel_session *ksess = session->kernel_session;
3994 struct ltt_ust_session *usess = session->ust_session;
3995
a0377dfe 3996 LTTNG_ASSERT(session);
806e2684 3997
5c408ad8
JD
3998 DBG("Data pending for session %s", session->name);
3999
806e2684 4000 /* Session MUST be stopped to ask for data availability. */
8382cf6f 4001 if (session->active) {
806e2684
DG
4002 ret = LTTNG_ERR_SESSION_STARTED;
4003 goto error;
3a89d11a
DG
4004 } else {
4005 /*
4006 * If stopped, just make sure we've started before else the above call
4007 * will always send that there is data pending.
4008 *
4009 * The consumer assumes that when the data pending command is received,
4010 * the trace has been started before or else no output data is written
4011 * by the streams which is a condition for data pending. So, this is
4012 * *VERY* important that we don't ask the consumer before a start
4013 * trace.
4014 */
8382cf6f 4015 if (!session->has_been_started) {
3a89d11a
DG
4016 ret = 0;
4017 goto error;
4018 }
806e2684
DG
4019 }
4020
92816cc3
JG
4021 /* A rotation is still pending, we have to wait. */
4022 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
5c408ad8
JD
4023 DBG("Rotate still pending for session %s", session->name);
4024 ret = 1;
4025 goto error;
4026 }
4027
806e2684 4028 if (ksess && ksess->consumer) {
6d805429
DG
4029 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
4030 if (ret == 1) {
806e2684
DG
4031 /* Data is still being extracted for the kernel. */
4032 goto error;
4033 }
4034 }
4035
4036 if (usess && usess->consumer) {
6d805429
DG
4037 ret = consumer_is_data_pending(usess->id, usess->consumer);
4038 if (ret == 1) {
806e2684
DG
4039 /* Data is still being extracted for the kernel. */
4040 goto error;
4041 }
4042 }
4043
4044 /* Data is ready to be read by a viewer */
6d805429 4045 ret = 0;
806e2684
DG
4046
4047error:
4048 return ret;
4049}
4050
6dc3064a
DG
4051/*
4052 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
4053 *
4054 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4055 */
4056int cmd_snapshot_add_output(struct ltt_session *session,
df4f5a87 4057 const struct lttng_snapshot_output *output, uint32_t *id)
6dc3064a
DG
4058{
4059 int ret;
4060 struct snapshot_output *new_output;
4061
a0377dfe
FD
4062 LTTNG_ASSERT(session);
4063 LTTNG_ASSERT(output);
6dc3064a
DG
4064
4065 DBG("Cmd snapshot add output for session %s", session->name);
4066
4067 /*
903ef685 4068 * Can't create an output if the session is not set in no-output mode.
6dc3064a
DG
4069 */
4070 if (session->output_traces) {
903ef685 4071 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
4072 goto error;
4073 }
4074
54213acc
JG
4075 if (session->has_non_mmap_channel) {
4076 ret = LTTNG_ERR_SNAPSHOT_UNSUPPORTED;
4077 goto error;
4078 }
4079
6dc3064a
DG
4080 /* Only one output is allowed until we have the "tee" feature. */
4081 if (session->snapshot.nb_output == 1) {
4082 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
4083 goto error;
4084 }
4085
4086 new_output = snapshot_output_alloc();
4087 if (!new_output) {
4088 ret = LTTNG_ERR_NOMEM;
4089 goto error;
4090 }
4091
b178f53e 4092 ret = snapshot_output_init(session, output->max_size, output->name,
6dc3064a
DG
4093 output->ctrl_url, output->data_url, session->consumer, new_output,
4094 &session->snapshot);
4095 if (ret < 0) {
4096 if (ret == -ENOMEM) {
4097 ret = LTTNG_ERR_NOMEM;
4098 } else {
4099 ret = LTTNG_ERR_INVALID;
4100 }
4101 goto free_error;
4102 }
4103
6dc3064a
DG
4104 rcu_read_lock();
4105 snapshot_add_output(&session->snapshot, new_output);
4106 if (id) {
4107 *id = new_output->id;
4108 }
4109 rcu_read_unlock();
4110
4111 return LTTNG_OK;
4112
4113free_error:
4114 snapshot_output_destroy(new_output);
4115error:
4116 return ret;
4117}
4118
4119/*
4120 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
4121 *
4122 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4123 */
4124int cmd_snapshot_del_output(struct ltt_session *session,
df4f5a87 4125 const struct lttng_snapshot_output *output)
6dc3064a
DG
4126{
4127 int ret;
eb240553 4128 struct snapshot_output *sout = NULL;
6dc3064a 4129
a0377dfe
FD
4130 LTTNG_ASSERT(session);
4131 LTTNG_ASSERT(output);
6dc3064a 4132
6dc3064a
DG
4133 rcu_read_lock();
4134
4135 /*
d3f14b8a
MD
4136 * Permission denied to create an output if the session is not
4137 * set in no output mode.
6dc3064a
DG
4138 */
4139 if (session->output_traces) {
903ef685 4140 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
4141 goto error;
4142 }
4143
eb240553
DG
4144 if (output->id) {
4145 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
4146 session->name);
4147 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
4148 } else if (*output->name != '\0') {
4149 DBG("Cmd snapshot del output name %s for session %s", output->name,
4150 session->name);
4151 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
4152 }
6dc3064a
DG
4153 if (!sout) {
4154 ret = LTTNG_ERR_INVALID;
4155 goto error;
4156 }
4157
4158 snapshot_delete_output(&session->snapshot, sout);
4159 snapshot_output_destroy(sout);
4160 ret = LTTNG_OK;
4161
4162error:
4163 rcu_read_unlock();
4164 return ret;
4165}
4166
4167/*
4168 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
4169 *
4170 * If no output is available, outputs is untouched and 0 is returned.
4171 *
4172 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
4173 */
4174ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
4175 struct lttng_snapshot_output **outputs)
4176{
4177 int ret, idx = 0;
b223ca94 4178 struct lttng_snapshot_output *list = NULL;
6dc3064a
DG
4179 struct lttng_ht_iter iter;
4180 struct snapshot_output *output;
4181
a0377dfe
FD
4182 LTTNG_ASSERT(session);
4183 LTTNG_ASSERT(outputs);
6dc3064a
DG
4184
4185 DBG("Cmd snapshot list outputs for session %s", session->name);
4186
4187 /*
d3f14b8a
MD
4188 * Permission denied to create an output if the session is not
4189 * set in no output mode.
6dc3064a
DG
4190 */
4191 if (session->output_traces) {
903ef685
JG
4192 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
4193 goto end;
6dc3064a
DG
4194 }
4195
4196 if (session->snapshot.nb_output == 0) {
4197 ret = 0;
903ef685 4198 goto end;
6dc3064a
DG
4199 }
4200
64803277 4201 list = calloc<lttng_snapshot_output>(session->snapshot.nb_output);
6dc3064a 4202 if (!list) {
b223ca94 4203 ret = -LTTNG_ERR_NOMEM;
903ef685 4204 goto end;
6dc3064a
DG
4205 }
4206
4207 /* Copy list from session to the new list object. */
b223ca94 4208 rcu_read_lock();
6dc3064a
DG
4209 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
4210 output, node.node) {
a0377dfe 4211 LTTNG_ASSERT(output->consumer);
6dc3064a
DG
4212 list[idx].id = output->id;
4213 list[idx].max_size = output->max_size;
6ce22875
MD
4214 if (lttng_strncpy(list[idx].name, output->name,
4215 sizeof(list[idx].name))) {
4216 ret = -LTTNG_ERR_INVALID;
903ef685 4217 goto error;
6ce22875 4218 }
6dc3064a 4219 if (output->consumer->type == CONSUMER_DST_LOCAL) {
6ce22875 4220 if (lttng_strncpy(list[idx].ctrl_url,
366a9222 4221 output->consumer->dst.session_root_path,
6ce22875
MD
4222 sizeof(list[idx].ctrl_url))) {
4223 ret = -LTTNG_ERR_INVALID;
903ef685 4224 goto error;
6ce22875 4225 }
6dc3064a
DG
4226 } else {
4227 /* Control URI. */
4228 ret = uri_to_str_url(&output->consumer->dst.net.control,
4229 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
4230 if (ret < 0) {
b223ca94 4231 ret = -LTTNG_ERR_NOMEM;
903ef685 4232 goto error;
6dc3064a
DG
4233 }
4234
4235 /* Data URI. */
4236 ret = uri_to_str_url(&output->consumer->dst.net.data,
4237 list[idx].data_url, sizeof(list[idx].data_url));
4238 if (ret < 0) {
b223ca94 4239 ret = -LTTNG_ERR_NOMEM;
903ef685 4240 goto error;
6dc3064a
DG
4241 }
4242 }
4243 idx++;
4244 }
4245
4246 *outputs = list;
b223ca94
JG
4247 list = NULL;
4248 ret = session->snapshot.nb_output;
6dc3064a 4249error:
903ef685 4250 rcu_read_unlock();
b223ca94 4251 free(list);
903ef685 4252end:
b223ca94 4253 return ret;
6dc3064a
DG
4254}
4255
93ec662e
JD
4256/*
4257 * Check if we can regenerate the metadata for this session.
4258 * Only kernel, UST per-uid and non-live sessions are supported.
4259 *
4260 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
4261 */
4262static
eded6438 4263int check_regenerate_metadata_support(struct ltt_session *session)
93ec662e
JD
4264{
4265 int ret;
4266
a0377dfe 4267 LTTNG_ASSERT(session);
93ec662e
JD
4268
4269 if (session->live_timer != 0) {
4270 ret = LTTNG_ERR_LIVE_SESSION;
4271 goto end;
4272 }
4273 if (!session->active) {
4274 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4275 goto end;
4276 }
4277 if (session->ust_session) {
4278 switch (session->ust_session->buffer_type) {
4279 case LTTNG_BUFFER_PER_UID:
4280 break;
4281 case LTTNG_BUFFER_PER_PID:
4282 ret = LTTNG_ERR_PER_PID_SESSION;
4283 goto end;
4284 default:
a0377dfe 4285 abort();
93ec662e
JD
4286 ret = LTTNG_ERR_UNK;
4287 goto end;
4288 }
4289 }
4290 if (session->consumer->type == CONSUMER_DST_NET &&
4291 session->consumer->relay_minor_version < 8) {
4292 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
4293 goto end;
4294 }
4295 ret = 0;
4296
4297end:
4298 return ret;
4299}
4300
93ec662e 4301/*
eded6438 4302 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
93ec662e
JD
4303 *
4304 * Ask the consumer to truncate the existing metadata file(s) and
4305 * then regenerate the metadata. Live and per-pid sessions are not
4306 * supported and return an error.
4307 *
1136f41b 4308 * Return LTTNG_OK on success or else a LTTNG_ERR code.
93ec662e 4309 */
eded6438 4310int cmd_regenerate_metadata(struct ltt_session *session)
93ec662e
JD
4311{
4312 int ret;
4313
a0377dfe 4314 LTTNG_ASSERT(session);
93ec662e 4315
eded6438 4316 ret = check_regenerate_metadata_support(session);
93ec662e
JD
4317 if (ret) {
4318 goto end;
4319 }
4320
4321 if (session->kernel_session) {
eded6438 4322 ret = kernctl_session_regenerate_metadata(
93ec662e
JD
4323 session->kernel_session->fd);
4324 if (ret < 0) {
4325 ERR("Failed to regenerate the kernel metadata");
4326 goto end;
4327 }
4328 }
4329
4330 if (session->ust_session) {
d7bfb9b0 4331 ret = trace_ust_regenerate_metadata(session->ust_session);
93ec662e
JD
4332 if (ret < 0) {
4333 ERR("Failed to regenerate the UST metadata");
4334 goto end;
4335 }
4336 }
4337 DBG("Cmd metadata regenerate for session %s", session->name);
4338 ret = LTTNG_OK;
4339
4340end:
4341 return ret;
4342}
4343
c2561365
JD
4344/*
4345 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
4346 *
4347 * Ask the tracer to regenerate a new statedump.
4348 *
1136f41b 4349 * Return LTTNG_OK on success or else a LTTNG_ERR code.
c2561365
JD
4350 */
4351int cmd_regenerate_statedump(struct ltt_session *session)
4352{
4353 int ret;
4354
a0377dfe 4355 LTTNG_ASSERT(session);
c2561365
JD
4356
4357 if (!session->active) {
4358 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4359 goto end;
4360 }
c2561365
JD
4361
4362 if (session->kernel_session) {
4363 ret = kernctl_session_regenerate_statedump(
4364 session->kernel_session->fd);
4365 /*
4366 * Currently, the statedump in kernel can only fail if out
4367 * of memory.
4368 */
4369 if (ret < 0) {
4370 if (ret == -ENOMEM) {
4371 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
4372 } else {
4373 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4374 }
4375 ERR("Failed to regenerate the kernel statedump");
4376 goto end;
4377 }
4378 }
4379
4380 if (session->ust_session) {
4381 ret = ust_app_regenerate_statedump_all(session->ust_session);
4382 /*
4383 * Currently, the statedump in UST always returns 0.
4384 */
4385 if (ret < 0) {
4386 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4387 ERR("Failed to regenerate the UST statedump");
4388 goto end;
4389 }
4390 }
4391 DBG("Cmd regenerate statedump for session %s", session->name);
4392 ret = LTTNG_OK;
4393
4394end:
4395 return ret;
4396}
4397
989a0844
FD
4398static
4399enum lttng_error_code synchronize_tracer_notifier_register(
4400 struct notification_thread_handle *notification_thread,
4401 struct lttng_trigger *trigger, const struct lttng_credentials *cmd_creds)
70670472 4402{
989a0844 4403 enum lttng_error_code ret_code;
7c1f6da2
JG
4404 const struct lttng_condition *condition =
4405 lttng_trigger_get_const_condition(trigger);
989a0844
FD
4406 const char *trigger_name;
4407 uid_t trigger_owner;
4408 enum lttng_trigger_status trigger_status;
4409 const enum lttng_domain_type trigger_domain =
4410 lttng_trigger_get_underlying_domain_type_restriction(
4411 trigger);
70670472 4412
989a0844 4413 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
a0377dfe 4414 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
989a0844 4415
a0377dfe
FD
4416 LTTNG_ASSERT(condition);
4417 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
8dbb86b8 4418 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
989a0844
FD
4419
4420 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
4421 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4422 trigger_name : "(anonymous)";
989a0844
FD
4423
4424 session_lock_list();
4425 switch (trigger_domain) {
4426 case LTTNG_DOMAIN_KERNEL:
4427 {
4428 ret_code = kernel_register_event_notifier(trigger, cmd_creds);
4429 if (ret_code != LTTNG_OK) {
4430 enum lttng_error_code notif_thread_unregister_ret;
4431
4432 notif_thread_unregister_ret =
4433 notification_thread_command_unregister_trigger(
4434 notification_thread, trigger);
4435
4436 if (notif_thread_unregister_ret != LTTNG_OK) {
4437 /* Return the original error code. */
4438 ERR("Failed to unregister trigger from notification thread during error recovery: trigger name = '%s', trigger owner uid = %d, error code = %d",
4439 trigger_name,
4440 (int) trigger_owner,
4441 ret_code);
4442 }
4443 }
4444 break;
70670472 4445 }
989a0844
FD
4446 case LTTNG_DOMAIN_UST:
4447 ust_app_global_update_all_event_notifier_rules();
4448 break;
4449 case LTTNG_DOMAIN_JUL:
4450 case LTTNG_DOMAIN_LOG4J:
4451 case LTTNG_DOMAIN_PYTHON:
4452 {
4453 /* Agent domains. */
4454 struct agent *agt = agent_find_by_event_notifier_domain(
4455 trigger_domain);
70670472 4456
989a0844
FD
4457 if (!agt) {
4458 agt = agent_create(trigger_domain);
4459 if (!agt) {
4460 ret_code = LTTNG_ERR_NOMEM;
4461 goto end_unlock_session_list;
4462 }
4463
412d7227 4464 agent_add(agt, the_trigger_agents_ht_by_domain);
989a0844
FD
4465 }
4466
7966af57 4467 ret_code = (lttng_error_code) trigger_agent_enable(trigger, agt);
989a0844
FD
4468 if (ret_code != LTTNG_OK) {
4469 goto end_unlock_session_list;
4470 }
4471
4472 break;
4473 }
4474 case LTTNG_DOMAIN_NONE:
4475 default:
4476 abort();
4477 }
4478
4479 ret_code = LTTNG_OK;
4480end_unlock_session_list:
4481 session_unlock_list();
70670472
JR
4482 return ret_code;
4483}
4484
4485enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds,
746e08d7 4486 struct lttng_trigger *trigger,
0efb2ad7 4487 bool is_trigger_anonymous,
242388e4
JR
4488 struct notification_thread_handle *notification_thread,
4489 struct lttng_trigger **return_trigger)
b0880ae5 4490{
70670472 4491 enum lttng_error_code ret_code;
70670472
JR
4492 const char *trigger_name;
4493 uid_t trigger_owner;
4494 enum lttng_trigger_status trigger_status;
4495
4496 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
ce0b1d61 4497 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4498 trigger_name : "(anonymous)";
ce0b1d61 4499
70670472
JR
4500 trigger_status = lttng_trigger_get_owner_uid(
4501 trigger, &trigger_owner);
a0377dfe 4502 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
70670472
JR
4503
4504 DBG("Running register trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4505 trigger_name, (int) trigger_owner,
4506 (int) lttng_credentials_get_uid(cmd_creds));
b0880ae5 4507
64eafdf6
JR
4508 /*
4509 * Validate the trigger credentials against the command credentials.
4510 * Only the root user can register a trigger with non-matching
4511 * credentials.
4512 */
4513 if (!lttng_credentials_is_equal_uid(
4514 lttng_trigger_get_credentials(trigger),
746e08d7
JG
4515 cmd_creds)) {
4516 if (lttng_credentials_get_uid(cmd_creds) != 0) {
70670472
JR
4517 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4518 trigger_name, (int) trigger_owner,
4519 (int) lttng_credentials_get_uid(cmd_creds));
4520 ret_code = LTTNG_ERR_INVALID_TRIGGER;
64eafdf6
JR
4521 goto end;
4522 }
4523 }
3da864a9 4524
58daac01
JR
4525 /*
4526 * The bytecode generation also serves as a validation step for the
4527 * bytecode expressions.
4528 */
70670472
JR
4529 ret_code = lttng_trigger_generate_bytecode(trigger, cmd_creds);
4530 if (ret_code != LTTNG_OK) {
4531 ERR("Failed to generate bytecode of trigger: trigger name = '%s', trigger owner uid = %d, error code = %d",
4532 trigger_name, (int) trigger_owner, ret_code);
58daac01
JR
4533 goto end;
4534 }
4535
242388e4
JR
4536 /*
4537 * A reference to the trigger is acquired by the notification thread.
4538 * It is safe to return the same trigger to the caller since it the
4539 * other user holds a reference.
4540 *
4541 * The trigger is modified during the execution of the
4542 * "register trigger" command. However, by the time the command returns,
4543 * it is safe to use without any locking as its properties are
4544 * immutable.
4545 */
0efb2ad7
JG
4546 ret_code = notification_thread_command_register_trigger(
4547 notification_thread, trigger, is_trigger_anonymous);
70670472 4548 if (ret_code != LTTNG_OK) {
ce0b1d61 4549 DBG("Failed to register trigger to notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
70670472 4550 trigger_name, (int) trigger_owner, ret_code);
44760c20 4551 goto end;
70670472
JR
4552 }
4553
ce0b1d61
JG
4554 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
4555 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4556 trigger_name : "(anonymous)";
ce0b1d61 4557
70670472
JR
4558 /*
4559 * Synchronize tracers if the trigger adds an event notifier.
4560 */
989a0844
FD
4561 if (lttng_trigger_needs_tracer_notifier(trigger)) {
4562 ret_code = synchronize_tracer_notifier_register(notification_thread,
4563 trigger, cmd_creds);
4564 if (ret_code != LTTNG_OK) {
4565 ERR("Error registering tracer notifier: %s",
4566 lttng_strerror(-ret_code));
4567 goto end;
70670472
JR
4568 }
4569 }
4570
746e08d7
JG
4571 /*
4572 * Return an updated trigger to the client.
4573 *
4574 * Since a modified version of the same trigger is returned, acquire a
4575 * reference to the trigger so the caller doesn't have to care if those
4576 * are distinct instances or not.
4577 */
39b95a70
JG
4578 if (ret_code == LTTNG_OK) {
4579 lttng_trigger_get(trigger);
4580 *return_trigger = trigger;
4581 /* Ownership of trigger was transferred to caller. */
4582 trigger = NULL;
4583 }
b0880ae5 4584end:
70670472 4585 return ret_code;
989a0844
FD
4586}
4587
4588static
4589enum lttng_error_code synchronize_tracer_notifier_unregister(
4590 const struct lttng_trigger *trigger)
4591{
4592 enum lttng_error_code ret_code;
4593 const struct lttng_condition *condition =
4594 lttng_trigger_get_const_condition(trigger);
4595 const enum lttng_domain_type trigger_domain =
4596 lttng_trigger_get_underlying_domain_type_restriction(
4597 trigger);
4598
a0377dfe
FD
4599 LTTNG_ASSERT(condition);
4600 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
8dbb86b8 4601 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
989a0844
FD
4602
4603 session_lock_list();
4604 switch (trigger_domain) {
4605 case LTTNG_DOMAIN_KERNEL:
4606 ret_code = kernel_unregister_event_notifier(trigger);
e689039f
JG
4607 if (ret_code != LTTNG_OK) {
4608 goto end_unlock_session_list;
4609 }
4610
989a0844
FD
4611 break;
4612 case LTTNG_DOMAIN_UST:
4613 ust_app_global_update_all_event_notifier_rules();
4614 break;
4615 case LTTNG_DOMAIN_JUL:
4616 case LTTNG_DOMAIN_LOG4J:
4617 case LTTNG_DOMAIN_PYTHON:
4618 {
4619 /* Agent domains. */
4620 struct agent *agt = agent_find_by_event_notifier_domain(
4621 trigger_domain);
4622
566190c4
JG
4623 /*
4624 * This trigger was never registered in the first place. Calling
4625 * this function under those circumstances is an internal error.
4626 */
a0377dfe 4627 LTTNG_ASSERT(agt);
7966af57 4628 ret_code = (lttng_error_code) trigger_agent_disable(trigger, agt);
989a0844
FD
4629 if (ret_code != LTTNG_OK) {
4630 goto end_unlock_session_list;
4631 }
4632
4633 break;
4634 }
4635 case LTTNG_DOMAIN_NONE:
4636 default:
4637 abort();
4638 }
4639
4640 ret_code = LTTNG_OK;
4641
9b7cbebd
JG
4642end_unlock_session_list:
4643 session_unlock_list();
4644 return ret_code;
b0880ae5
JG
4645}
4646
70670472 4647enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd_creds,
746e08d7 4648 const struct lttng_trigger *trigger,
b0880ae5
JG
4649 struct notification_thread_handle *notification_thread)
4650{
70670472 4651 enum lttng_error_code ret_code;
70670472
JR
4652 const char *trigger_name;
4653 uid_t trigger_owner;
4654 enum lttng_trigger_status trigger_status;
5c5373c3 4655 struct lttng_trigger *sessiond_trigger = NULL;
70670472
JR
4656
4657 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
0efb2ad7 4658 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
989a0844 4659 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
a0377dfe 4660 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
70670472
JR
4661
4662 DBG("Running unregister trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4663 trigger_name, (int) trigger_owner,
4664 (int) lttng_credentials_get_uid(cmd_creds));
b0880ae5 4665
64eafdf6
JR
4666 /*
4667 * Validate the trigger credentials against the command credentials.
4668 * Only the root user can unregister a trigger with non-matching
4669 * credentials.
4670 */
4671 if (!lttng_credentials_is_equal_uid(
4672 lttng_trigger_get_credentials(trigger),
746e08d7
JG
4673 cmd_creds)) {
4674 if (lttng_credentials_get_uid(cmd_creds) != 0) {
70670472
JR
4675 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4676 trigger_name, (int) trigger_owner,
4677 (int) lttng_credentials_get_uid(cmd_creds));
4678 ret_code = LTTNG_ERR_INVALID_TRIGGER;
64eafdf6
JR
4679 goto end;
4680 }
4681 }
3da864a9 4682
5c5373c3
JR
4683 /* Fetch the sessiond side trigger object. */
4684 ret_code = notification_thread_command_get_trigger(
4685 notification_thread, trigger, &sessiond_trigger);
4686 if (ret_code != LTTNG_OK) {
4687 DBG("Failed to get trigger from notification thread during unregister: trigger name = '%s', trigger owner uid = %d, error code = %d",
4688 trigger_name, (int) trigger_owner, ret_code);
4689 goto end;
4690 }
4691
a0377dfe 4692 LTTNG_ASSERT(sessiond_trigger);
5c5373c3
JR
4693
4694 /*
4695 * From this point on, no matter what, consider the trigger
4696 * unregistered.
4697 *
4698 * We set the unregistered state of the sessiond side trigger object in
4699 * the client thread since we want to minimize the possibility of the
4700 * notification thread being stalled due to a long execution of an
4701 * action that required the trigger lock.
4702 */
4703 lttng_trigger_set_as_unregistered(sessiond_trigger);
4704
70670472
JR
4705 ret_code = notification_thread_command_unregister_trigger(notification_thread,
4706 trigger);
4707 if (ret_code != LTTNG_OK) {
ce0b1d61 4708 DBG("Failed to unregister trigger from notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
70670472 4709 trigger_name, (int) trigger_owner, ret_code);
13839b27 4710 goto end;
70670472
JR
4711 }
4712
4713 /*
4714 * Synchronize tracers if the trigger removes an event notifier.
44760c20
JR
4715 * Do this even if the trigger unregistration failed to at least stop
4716 * the tracers from producing notifications associated with this
4717 * event notifier.
70670472 4718 */
989a0844
FD
4719 if (lttng_trigger_needs_tracer_notifier(trigger)) {
4720 ret_code = synchronize_tracer_notifier_unregister(trigger);
4721 if (ret_code != LTTNG_OK) {
4722 ERR("Error unregistering trigger to tracer.");
4723 goto end;
70670472 4724 }
9b7cbebd 4725
70670472
JR
4726 }
4727
b0880ae5 4728end:
5c5373c3 4729 lttng_trigger_put(sessiond_trigger);
70670472 4730 return ret_code;
989a0844 4731}
b0880ae5 4732
ddd915a3 4733enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx,
fbc9f37d
JR
4734 struct notification_thread_handle *notification_thread,
4735 struct lttng_triggers **return_triggers)
4736{
f2bda80e 4737 int ret;
fbc9f37d
JR
4738 enum lttng_error_code ret_code;
4739 struct lttng_triggers *triggers = NULL;
4740
4741 /* Get the set of triggers from the notification thread. */
4742 ret_code = notification_thread_command_list_triggers(
4743 notification_thread, cmd_ctx->creds.uid, &triggers);
4744 if (ret_code != LTTNG_OK) {
fbc9f37d
JR
4745 goto end;
4746 }
4747
f2bda80e
JG
4748 ret = lttng_triggers_remove_hidden_triggers(triggers);
4749 if (ret) {
4750 ret_code = LTTNG_ERR_UNK;
4751 goto end;
4752 }
4753
fbc9f37d
JR
4754 *return_triggers = triggers;
4755 triggers = NULL;
ddd915a3 4756 ret_code = LTTNG_OK;
fbc9f37d
JR
4757end:
4758 lttng_triggers_destroy(triggers);
ddd915a3 4759 return ret_code;
fbc9f37d 4760}
588c4b0d
JG
4761
4762enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cmd_creds,
4763 const struct lttng_error_query *query,
4764 struct lttng_error_query_results **_results,
4765 struct notification_thread_handle *notification_thread)
4766{
4767 enum lttng_error_code ret_code;
4768 const struct lttng_trigger *query_target_trigger;
63dd3d7b 4769 const struct lttng_action *query_target_action = NULL;
588c4b0d
JG
4770 struct lttng_trigger *matching_trigger = NULL;
4771 const char *trigger_name;
4772 uid_t trigger_owner;
4773 enum lttng_trigger_status trigger_status;
4774 struct lttng_error_query_results *results = NULL;
4775
4776 switch (lttng_error_query_get_target_type(query)) {
4777 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
4778 query_target_trigger = lttng_error_query_trigger_borrow_target(query);
4779 break;
63dd3d7b
JG
4780 case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
4781 query_target_trigger =
4782 lttng_error_query_condition_borrow_target(query);
4783 break;
588c4b0d
JG
4784 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
4785 query_target_trigger = lttng_error_query_action_borrow_trigger_target(
4786 query);
4787 break;
4788 default:
4789 abort();
4790 }
4791
a0377dfe 4792 LTTNG_ASSERT(query_target_trigger);
588c4b0d
JG
4793
4794 ret_code = notification_thread_command_get_trigger(notification_thread,
4795 query_target_trigger, &matching_trigger);
4796 if (ret_code != LTTNG_OK) {
4797 goto end;
4798 }
4799
4800 /* No longer needed. */
4801 query_target_trigger = NULL;
4802
4803 if (lttng_error_query_get_target_type(query) ==
4804 LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION) {
4805 /* Get the sessiond-side version of the target action. */
4806 query_target_action =
4807 lttng_error_query_action_borrow_action_target(
4808 query, matching_trigger);
4809 }
4810
4811 trigger_status = lttng_trigger_get_name(matching_trigger, &trigger_name);
4812 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4813 trigger_name : "(anonymous)";
588c4b0d
JG
4814 trigger_status = lttng_trigger_get_owner_uid(matching_trigger,
4815 &trigger_owner);
a0377dfe 4816 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
588c4b0d
JG
4817
4818 results = lttng_error_query_results_create();
4819 if (!results) {
4820 ret_code = LTTNG_ERR_NOMEM;
4821 goto end;
4822 }
4823
4824 DBG("Running \"execute error query\" command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4825 trigger_name, (int) trigger_owner,
4826 (int) lttng_credentials_get_uid(cmd_creds));
4827
4828 /*
4829 * Validate the trigger credentials against the command credentials.
4830 * Only the root user can target a trigger with non-matching
4831 * credentials.
4832 */
4833 if (!lttng_credentials_is_equal_uid(
4834 lttng_trigger_get_credentials(matching_trigger),
4835 cmd_creds)) {
4836 if (lttng_credentials_get_uid(cmd_creds) != 0) {
4837 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4838 trigger_name, (int) trigger_owner,
4839 (int) lttng_credentials_get_uid(cmd_creds));
4840 ret_code = LTTNG_ERR_INVALID_TRIGGER;
4841 goto end;
4842 }
4843 }
4844
4845 switch (lttng_error_query_get_target_type(query)) {
4846 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
4847 trigger_status = lttng_trigger_add_error_results(
4848 matching_trigger, results);
4849
4850 switch (trigger_status) {
4851 case LTTNG_TRIGGER_STATUS_OK:
4852 break;
4853 default:
4854 ret_code = LTTNG_ERR_UNK;
4855 goto end;
4856 }
4857
4858 break;
63dd3d7b
JG
4859 case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
4860 {
4861 trigger_status = lttng_trigger_condition_add_error_results(
4862 matching_trigger, results);
4863
4864 switch (trigger_status) {
4865 case LTTNG_TRIGGER_STATUS_OK:
4866 break;
4867 default:
4868 ret_code = LTTNG_ERR_UNK;
4869 goto end;
4870 }
4871
4872 break;
4873 }
588c4b0d
JG
4874 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
4875 {
4876 const enum lttng_action_status action_status =
4877 lttng_action_add_error_query_results(
4878 query_target_action, results);
4879
4880 switch (action_status) {
4881 case LTTNG_ACTION_STATUS_OK:
4882 break;
4883 default:
4884 ret_code = LTTNG_ERR_UNK;
4885 goto end;
4886 }
4887
4888 break;
4889 }
4890 default:
ef4cf1d2 4891 abort();
588c4b0d
JG
4892 break;
4893 }
4894
4895 *_results = results;
4896 results = NULL;
4897 ret_code = LTTNG_OK;
4898end:
4899 lttng_trigger_put(matching_trigger);
4900 lttng_error_query_results_destroy(results);
4901 return ret_code;
4902}
4903
6dc3064a
DG
4904/*
4905 * Send relayd sockets from snapshot output to consumer. Ignore request if the
4906 * snapshot output is *not* set with a remote destination.
4907 *
9a654598 4908 * Return LTTNG_OK on success or a LTTNG_ERR code.
6dc3064a 4909 */
9a654598 4910static enum lttng_error_code set_relayd_for_snapshot(
348a81dc 4911 struct consumer_output *output,
fb9a95c4 4912 const struct ltt_session *session)
6dc3064a 4913{
9a654598 4914 enum lttng_error_code status = LTTNG_OK;
6dc3064a
DG
4915 struct lttng_ht_iter iter;
4916 struct consumer_socket *socket;
1e791a74 4917 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
6fa5fe7c 4918 const char *base_path;
6dc3064a 4919
a0377dfe
FD
4920 LTTNG_ASSERT(output);
4921 LTTNG_ASSERT(session);
6dc3064a
DG
4922
4923 DBG2("Set relayd object from snapshot output");
4924
1e791a74 4925 if (session->current_trace_chunk) {
348a81dc
JG
4926 enum lttng_trace_chunk_status chunk_status =
4927 lttng_trace_chunk_get_id(
4928 session->current_trace_chunk,
4929 &current_chunk_id.value);
1e791a74 4930
348a81dc 4931 if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) {
1e791a74
JG
4932 current_chunk_id.is_set = true;
4933 } else {
4934 ERR("Failed to get current trace chunk id");
4935 status = LTTNG_ERR_UNK;
4936 goto error;
4937 }
4938 }
4939
6dc3064a 4940 /* Ignore if snapshot consumer output is not network. */
348a81dc 4941 if (output->type != CONSUMER_DST_NET) {
6dc3064a
DG
4942 goto error;
4943 }
4944
6fa5fe7c
MD
4945 /*
4946 * The snapshot record URI base path overrides the session
4947 * base path.
4948 */
4949 if (output->dst.net.control.subdir[0] != '\0') {
4950 base_path = output->dst.net.control.subdir;
4951 } else {
4952 base_path = session->base_path;
4953 }
4954
6dc3064a
DG
4955 /*
4956 * For each consumer socket, create and send the relayd object of the
4957 * snapshot output.
4958 */
4959 rcu_read_lock();
348a81dc 4960 cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
5eecee74 4961 socket, node.node) {
ecd0f96d 4962 pthread_mutex_lock(socket->lock);
f46376a1 4963 status = send_consumer_relayd_sockets(session->id,
348a81dc 4964 output, socket,
d3e2ba59 4965 session->name, session->hostname,
6fa5fe7c 4966 base_path,
1e791a74 4967 session->live_timer,
db1da059 4968 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
4969 session->creation_time,
4970 session->name_contains_creation_time);
ecd0f96d 4971 pthread_mutex_unlock(socket->lock);
9a654598 4972 if (status != LTTNG_OK) {
6dc3064a
DG
4973 rcu_read_unlock();
4974 goto error;
4975 }
4976 }
4977 rcu_read_unlock();
4978
4979error:
9a654598 4980 return status;
6dc3064a
DG
4981}
4982
4983/*
4984 * Record a kernel snapshot.
4985 *
fac41e72 4986 * Return LTTNG_OK on success or a LTTNG_ERR code.
6dc3064a 4987 */
fb9a95c4
JG
4988static enum lttng_error_code record_kernel_snapshot(
4989 struct ltt_kernel_session *ksess,
348a81dc 4990 const struct consumer_output *output,
fb9a95c4 4991 const struct ltt_session *session,
f46376a1 4992 uint64_t nb_packets_per_stream)
6dc3064a 4993{
9a654598 4994 enum lttng_error_code status;
6dc3064a 4995
a0377dfe
FD
4996 LTTNG_ASSERT(ksess);
4997 LTTNG_ASSERT(output);
4998 LTTNG_ASSERT(session);
6dc3064a 4999
348a81dc 5000 status = kernel_snapshot_record(
f46376a1 5001 ksess, output, nb_packets_per_stream);
9a654598 5002 return status;
6dc3064a
DG
5003}
5004
5005/*
5006 * Record a UST snapshot.
5007 *
9a654598 5008 * Returns LTTNG_OK on success or a LTTNG_ERR error code.
6dc3064a 5009 */
9a654598 5010static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
348a81dc
JG
5011 const struct consumer_output *output,
5012 const struct ltt_session *session,
f46376a1 5013 uint64_t nb_packets_per_stream)
6dc3064a 5014{
9a654598 5015 enum lttng_error_code status;
6dc3064a 5016
a0377dfe
FD
5017 LTTNG_ASSERT(usess);
5018 LTTNG_ASSERT(output);
5019 LTTNG_ASSERT(session);
6dc3064a 5020
348a81dc 5021 status = ust_app_snapshot_record(
f46376a1 5022 usess, output, nb_packets_per_stream);
9a654598 5023 return status;
6dc3064a
DG
5024}
5025
d07ceecd 5026static
fb9a95c4
JG
5027uint64_t get_session_size_one_more_packet_per_stream(
5028 const struct ltt_session *session, uint64_t cur_nr_packets)
68808f4e 5029{
d07ceecd 5030 uint64_t tot_size = 0;
68808f4e
DG
5031
5032 if (session->kernel_session) {
5033 struct ltt_kernel_channel *chan;
fb9a95c4
JG
5034 const struct ltt_kernel_session *ksess =
5035 session->kernel_session;
68808f4e 5036
68808f4e 5037 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
d07ceecd
MD
5038 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
5039 /*
5040 * Don't take channel into account if we
5041 * already grab all its packets.
5042 */
5043 continue;
68808f4e 5044 }
d07ceecd
MD
5045 tot_size += chan->channel->attr.subbuf_size
5046 * chan->stream_count;
68808f4e
DG
5047 }
5048 }
5049
5050 if (session->ust_session) {
fb9a95c4 5051 const struct ltt_ust_session *usess = session->ust_session;
68808f4e 5052
d07ceecd
MD
5053 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
5054 cur_nr_packets);
68808f4e
DG
5055 }
5056
d07ceecd 5057 return tot_size;
68808f4e
DG
5058}
5059
5c786ded 5060/*
d07ceecd
MD
5061 * Calculate the number of packets we can grab from each stream that
5062 * fits within the overall snapshot max size.
5063 *
5064 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
5065 * the number of packets per stream.
5066 *
5067 * TODO: this approach is not perfect: we consider the worse case
5068 * (packet filling the sub-buffers) as an upper bound, but we could do
5069 * better if we do this calculation while we actually grab the packet
5070 * content: we would know how much padding we don't actually store into
5071 * the file.
5072 *
5073 * This algorithm is currently bounded by the number of packets per
5074 * stream.
5075 *
5076 * Since we call this algorithm before actually grabbing the data, it's
5077 * an approximation: for instance, applications could appear/disappear
5078 * in between this call and actually grabbing data.
5c786ded 5079 */
d07ceecd 5080static
fb9a95c4
JG
5081int64_t get_session_nb_packets_per_stream(const struct ltt_session *session,
5082 uint64_t max_size)
5c786ded 5083{
d07ceecd
MD
5084 int64_t size_left;
5085 uint64_t cur_nb_packets = 0;
5c786ded 5086
d07ceecd
MD
5087 if (!max_size) {
5088 return 0; /* Infinite */
5c786ded
JD
5089 }
5090
d07ceecd
MD
5091 size_left = max_size;
5092 for (;;) {
5093 uint64_t one_more_packet_tot_size;
5c786ded 5094
fb9a95c4
JG
5095 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(
5096 session, cur_nb_packets);
d07ceecd
MD
5097 if (!one_more_packet_tot_size) {
5098 /* We are already grabbing all packets. */
5099 break;
5100 }
5101 size_left -= one_more_packet_tot_size;
5102 if (size_left < 0) {
5103 break;
5104 }
5105 cur_nb_packets++;
5c786ded 5106 }
aecf2da5 5107 if (!cur_nb_packets && size_left != max_size) {
d07ceecd
MD
5108 /* Not enough room to grab one packet of each stream, error. */
5109 return -1;
5110 }
5111 return cur_nb_packets;
5c786ded
JD
5112}
5113
fb9a95c4 5114static
d2956687 5115enum lttng_error_code snapshot_record(struct ltt_session *session,
f46376a1 5116 const struct snapshot_output *snapshot_output)
fb9a95c4
JG
5117{
5118 int64_t nb_packets_per_stream;
d2956687 5119 char snapshot_chunk_name[LTTNG_NAME_MAX];
348a81dc
JG
5120 int ret;
5121 enum lttng_error_code ret_code = LTTNG_OK;
d2956687 5122 struct lttng_trace_chunk *snapshot_trace_chunk;
348a81dc
JG
5123 struct consumer_output *original_ust_consumer_output = NULL;
5124 struct consumer_output *original_kernel_consumer_output = NULL;
5125 struct consumer_output *snapshot_ust_consumer_output = NULL;
5126 struct consumer_output *snapshot_kernel_consumer_output = NULL;
d2956687 5127
348a81dc 5128 ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
d2956687
JG
5129 "%s-%s-%" PRIu64,
5130 snapshot_output->name,
5131 snapshot_output->datetime,
5132 snapshot_output->nb_snapshot);
348a81dc 5133 if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) {
d2956687 5134 ERR("Failed to format snapshot name");
348a81dc
JG
5135 ret_code = LTTNG_ERR_INVALID;
5136 goto error;
d2956687
JG
5137 }
5138 DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"",
5139 snapshot_output->name, session->name,
5140 snapshot_chunk_name);
348a81dc
JG
5141 if (!session->kernel_session && !session->ust_session) {
5142 ERR("Failed to record snapshot as no channels exist");
5143 ret_code = LTTNG_ERR_NO_CHANNEL;
5144 goto error;
5145 }
5146
5147 if (session->kernel_session) {
5148 original_kernel_consumer_output =
5149 session->kernel_session->consumer;
5150 snapshot_kernel_consumer_output =
5151 consumer_copy_output(snapshot_output->consumer);
3b967712
MD
5152 strcpy(snapshot_kernel_consumer_output->chunk_path,
5153 snapshot_chunk_name);
bd666153
JR
5154
5155 /* Copy the original domain subdir. */
5156 strcpy(snapshot_kernel_consumer_output->domain_subdir,
5157 original_kernel_consumer_output->domain_subdir);
5158
348a81dc
JG
5159 ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
5160 original_kernel_consumer_output);
5161 if (ret < 0) {
5162 ERR("Failed to copy consumer sockets from snapshot output configuration");
5163 ret_code = LTTNG_ERR_NOMEM;
5164 goto error;
5165 }
5166 ret_code = set_relayd_for_snapshot(
5167 snapshot_kernel_consumer_output, session);
5168 if (ret_code != LTTNG_OK) {
5169 ERR("Failed to setup relay daemon for kernel tracer snapshot");
5170 goto error;
5171 }
5172 session->kernel_session->consumer =
5173 snapshot_kernel_consumer_output;
5174 }
5175 if (session->ust_session) {
5176 original_ust_consumer_output = session->ust_session->consumer;
5177 snapshot_ust_consumer_output =
5178 consumer_copy_output(snapshot_output->consumer);
3b967712
MD
5179 strcpy(snapshot_ust_consumer_output->chunk_path,
5180 snapshot_chunk_name);
bd666153
JR
5181
5182 /* Copy the original domain subdir. */
5183 strcpy(snapshot_ust_consumer_output->domain_subdir,
5184 original_ust_consumer_output->domain_subdir);
5185
348a81dc
JG
5186 ret = consumer_copy_sockets(snapshot_ust_consumer_output,
5187 original_ust_consumer_output);
5188 if (ret < 0) {
5189 ERR("Failed to copy consumer sockets from snapshot output configuration");
5190 ret_code = LTTNG_ERR_NOMEM;
5191 goto error;
5192 }
5193 ret_code = set_relayd_for_snapshot(
5194 snapshot_ust_consumer_output, session);
5195 if (ret_code != LTTNG_OK) {
5196 ERR("Failed to setup relay daemon for userspace tracer snapshot");
5197 goto error;
5198 }
5199 session->ust_session->consumer =
5200 snapshot_ust_consumer_output;
5201 }
5202
d2956687 5203 snapshot_trace_chunk = session_create_new_trace_chunk(session,
348a81dc
JG
5204 snapshot_kernel_consumer_output ?:
5205 snapshot_ust_consumer_output,
5206 consumer_output_get_base_path(
5207 snapshot_output->consumer),
d2956687
JG
5208 snapshot_chunk_name);
5209 if (!snapshot_trace_chunk) {
348a81dc
JG
5210 ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"",
5211 session->name);
5212 ret_code = LTTNG_ERR_CREATE_DIR_FAIL;
5213 goto error;
d2956687 5214 }
a0377dfe 5215 LTTNG_ASSERT(!session->current_trace_chunk);
d2956687
JG
5216 ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL);
5217 lttng_trace_chunk_put(snapshot_trace_chunk);
5218 snapshot_trace_chunk = NULL;
5219 if (ret) {
348a81dc
JG
5220 ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"",
5221 session->name);
5222 ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
5223 goto error;
d2956687 5224 }
fb9a95c4
JG
5225
5226 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
5227 snapshot_output->max_size);
5228 if (nb_packets_per_stream < 0) {
348a81dc 5229 ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
5151d412 5230 goto error_close_trace_chunk;
fb9a95c4
JG
5231 }
5232
5233 if (session->kernel_session) {
348a81dc
JG
5234 ret_code = record_kernel_snapshot(session->kernel_session,
5235 snapshot_kernel_consumer_output, session,
f46376a1 5236 nb_packets_per_stream);
348a81dc 5237 if (ret_code != LTTNG_OK) {
5151d412 5238 goto error_close_trace_chunk;
fb9a95c4
JG
5239 }
5240 }
5241
5242 if (session->ust_session) {
348a81dc
JG
5243 ret_code = record_ust_snapshot(session->ust_session,
5244 snapshot_ust_consumer_output, session,
f46376a1 5245 nb_packets_per_stream);
348a81dc 5246 if (ret_code != LTTNG_OK) {
5151d412 5247 goto error_close_trace_chunk;
fb9a95c4
JG
5248 }
5249 }
d2956687 5250
5151d412 5251error_close_trace_chunk:
dbfee52c
MD
5252 if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) {
5253 ERR("Failed to release the current trace chunk of session \"%s\"",
5254 session->name);
5255 ret_code = LTTNG_ERR_UNK;
5256 }
5257
5258 if (session_close_trace_chunk(session, snapshot_trace_chunk,
343defc2 5259 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION, NULL)) {
d2956687
JG
5260 /*
5261 * Don't goto end; make sure the chunk is closed for the session
5262 * to allow future snapshots.
5263 */
5264 ERR("Failed to close snapshot trace chunk of session \"%s\"",
5265 session->name);
348a81dc 5266 ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
d2956687 5267 }
a49a9216
JG
5268
5269 lttng_trace_chunk_put(snapshot_trace_chunk);
5270 snapshot_trace_chunk = NULL;
348a81dc
JG
5271error:
5272 if (original_ust_consumer_output) {
5273 session->ust_session->consumer = original_ust_consumer_output;
5274 }
5275 if (original_kernel_consumer_output) {
5276 session->kernel_session->consumer =
5277 original_kernel_consumer_output;
5278 }
5279 consumer_output_put(snapshot_ust_consumer_output);
5280 consumer_output_put(snapshot_kernel_consumer_output);
5281 return ret_code;
fb9a95c4
JG
5282}
5283
6dc3064a
DG
5284/*
5285 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
5286 *
5287 * The wait parameter is ignored so this call always wait for the snapshot to
5288 * complete before returning.
5289 *
5290 * Return LTTNG_OK on success or else a LTTNG_ERR code.
5291 */
5292int cmd_snapshot_record(struct ltt_session *session,
f46376a1
MJ
5293 const struct lttng_snapshot_output *output,
5294 int wait __attribute__((unused)))
6dc3064a 5295{
9a654598
JG
5296 enum lttng_error_code cmd_ret = LTTNG_OK;
5297 int ret;
00e1dfc4 5298 unsigned int snapshot_success = 0;
10ba83fe 5299 char datetime[16];
2abe7969 5300 struct snapshot_output *tmp_output = NULL;
6dc3064a 5301
a0377dfe
FD
5302 LTTNG_ASSERT(session);
5303 LTTNG_ASSERT(output);
6dc3064a
DG
5304
5305 DBG("Cmd snapshot record for session %s", session->name);
5306
10ba83fe
JR
5307 /* Get the datetime for the snapshot output directory. */
5308 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
5309 sizeof(datetime));
5310 if (!ret) {
9a654598 5311 cmd_ret = LTTNG_ERR_INVALID;
10ba83fe
JR
5312 goto error;
5313 }
5314
6dc3064a 5315 /*
d3f14b8a
MD
5316 * Permission denied to create an output if the session is not
5317 * set in no output mode.
6dc3064a
DG
5318 */
5319 if (session->output_traces) {
9a654598 5320 cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
5321 goto error;
5322 }
5323
5324 /* The session needs to be started at least once. */
8382cf6f 5325 if (!session->has_been_started) {
9a654598 5326 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
6dc3064a
DG
5327 goto error;
5328 }
5329
5330 /* Use temporary output for the session. */
ba45d9f0 5331 if (*output->ctrl_url != '\0') {
2abe7969
JG
5332 tmp_output = snapshot_output_alloc();
5333 if (!tmp_output) {
5334 cmd_ret = LTTNG_ERR_NOMEM;
5335 goto error;
5336 }
5337
b178f53e
JG
5338 ret = snapshot_output_init(session, output->max_size,
5339 output->name,
5340 output->ctrl_url, output->data_url,
5341 session->consumer,
2abe7969 5342 tmp_output, NULL);
6dc3064a
DG
5343 if (ret < 0) {
5344 if (ret == -ENOMEM) {
9a654598 5345 cmd_ret = LTTNG_ERR_NOMEM;
6dc3064a 5346 } else {
9a654598 5347 cmd_ret = LTTNG_ERR_INVALID;
6dc3064a
DG
5348 }
5349 goto error;
5350 }
1bfe7328 5351 /* Use the global session count for the temporary snapshot. */
2abe7969 5352 tmp_output->nb_snapshot = session->snapshot.nb_snapshot;
10ba83fe
JR
5353
5354 /* Use the global datetime */
2abe7969 5355 memcpy(tmp_output->datetime, datetime, sizeof(datetime));
f46376a1 5356 cmd_ret = snapshot_record(session, tmp_output);
fb9a95c4 5357 if (cmd_ret != LTTNG_OK) {
804c90a8
JR
5358 goto error;
5359 }
804c90a8
JR
5360 snapshot_success = 1;
5361 } else {
5362 struct snapshot_output *sout;
5363 struct lttng_ht_iter iter;
68808f4e 5364
804c90a8
JR
5365 rcu_read_lock();
5366 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
5367 &iter.iter, sout, node.node) {
2abe7969
JG
5368 struct snapshot_output output_copy;
5369
804c90a8 5370 /*
2abe7969
JG
5371 * Make a local copy of the output and override output
5372 * parameters with those provided as part of the
5373 * command.
804c90a8 5374 */
2abe7969 5375 memcpy(&output_copy, sout, sizeof(output_copy));
1bfe7328 5376
804c90a8 5377 if (output->max_size != (uint64_t) -1ULL) {
2abe7969 5378 output_copy.max_size = output->max_size;
6dc3064a 5379 }
d07ceecd 5380
2abe7969
JG
5381 output_copy.nb_snapshot = session->snapshot.nb_snapshot;
5382 memcpy(output_copy.datetime, datetime,
5383 sizeof(datetime));
6dc3064a 5384
804c90a8
JR
5385 /* Use temporary name. */
5386 if (*output->name != '\0') {
2abe7969
JG
5387 if (lttng_strncpy(output_copy.name,
5388 output->name,
5389 sizeof(output_copy.name))) {
9a654598 5390 cmd_ret = LTTNG_ERR_INVALID;
cf3e357d
MD
5391 rcu_read_unlock();
5392 goto error;
5393 }
804c90a8 5394 }
e1986656 5395
f46376a1 5396 cmd_ret = snapshot_record(session, &output_copy);
fb9a95c4
JG
5397 if (cmd_ret != LTTNG_OK) {
5398 rcu_read_unlock();
5399 goto error;
6dc3064a 5400 }
804c90a8 5401 snapshot_success = 1;
6dc3064a 5402 }
804c90a8 5403 rcu_read_unlock();
6dc3064a
DG
5404 }
5405
1bfe7328
DG
5406 if (snapshot_success) {
5407 session->snapshot.nb_snapshot++;
b67578cb 5408 } else {
9a654598 5409 cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL;
1bfe7328
DG
5410 }
5411
6dc3064a 5412error:
2abe7969
JG
5413 if (tmp_output) {
5414 snapshot_output_destroy(tmp_output);
5415 }
9a654598 5416 return cmd_ret;
6dc3064a
DG
5417}
5418
d7ba1388
MD
5419/*
5420 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
5421 */
5422int cmd_set_session_shm_path(struct ltt_session *session,
5423 const char *shm_path)
5424{
5425 /* Safety net */
a0377dfe 5426 LTTNG_ASSERT(session);
d7ba1388
MD
5427
5428 /*
5429 * Can only set shm path before session is started.
5430 */
5431 if (session->has_been_started) {
5432 return LTTNG_ERR_SESSION_STARTED;
5433 }
5434
5435 strncpy(session->shm_path, shm_path,
5436 sizeof(session->shm_path));
5437 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
5438
7e397c55 5439 return LTTNG_OK;
d7ba1388
MD
5440}
5441
5c408ad8
JD
5442/*
5443 * Command LTTNG_ROTATE_SESSION from the lttng-ctl library.
5444 *
5445 * Ask the consumer to rotate the session output directory.
5446 * The session lock must be held.
5447 *
d5a1b7aa 5448 * Returns LTTNG_OK on success or else a negative LTTng error code.
5c408ad8
JD
5449 */
5450int cmd_rotate_session(struct ltt_session *session,
7fdbed1c 5451 struct lttng_rotate_session_return *rotate_return,
343defc2
MD
5452 bool quiet_rotation,
5453 enum lttng_trace_chunk_command_type command)
5c408ad8
JD
5454{
5455 int ret;
d2956687 5456 uint64_t ongoing_rotation_chunk_id;
d5a1b7aa 5457 enum lttng_error_code cmd_ret = LTTNG_OK;
d2956687
JG
5458 struct lttng_trace_chunk *chunk_being_archived = NULL;
5459 struct lttng_trace_chunk *new_trace_chunk = NULL;
5460 enum lttng_trace_chunk_status chunk_status;
3156892b
JG
5461 bool failed_to_rotate = false;
5462 enum lttng_error_code rotation_fail_code = LTTNG_OK;
5c408ad8 5463
a0377dfe 5464 LTTNG_ASSERT(session);
5c408ad8
JD
5465
5466 if (!session->has_been_started) {
d5a1b7aa 5467 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
d68c9a04 5468 goto end;
5c408ad8
JD
5469 }
5470
d48d65e1
MD
5471 /*
5472 * Explicit rotation is not supported for live sessions.
5473 * However, live sessions can perform a quiet rotation on
5474 * destroy.
5475 * Rotation is not supported for snapshot traces (no output).
5476 */
5477 if ((!quiet_rotation && session->live_timer) ||
5478 !session->output_traces) {
d5a1b7aa 5479 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
d68c9a04 5480 goto end;
5c408ad8
JD
5481 }
5482
d2956687 5483 /* Unsupported feature in lttng-relayd before 2.11. */
070b6a86 5484 if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET &&
5c408ad8
JD
5485 (session->consumer->relay_major_version == 2 &&
5486 session->consumer->relay_minor_version < 11)) {
d5a1b7aa 5487 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
d68c9a04 5488 goto end;
5c408ad8
JD
5489 }
5490
a40a503f
MD
5491 /* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */
5492 if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) {
5493 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL;
5494 goto end;
5495 }
5496
92816cc3 5497 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
92816cc3
JG
5498 DBG("Refusing to launch a rotation; a rotation is already in progress for session %s",
5499 session->name);
d5a1b7aa 5500 cmd_ret = LTTNG_ERR_ROTATION_PENDING;
d68c9a04 5501 goto end;
5c408ad8
JD
5502 }
5503
5504 /*
5505 * After a stop, we only allow one rotation to occur, the other ones are
5506 * useless until a new start.
5507 */
5508 if (session->rotated_after_last_stop) {
5509 DBG("Session \"%s\" was already rotated after stop, refusing rotation",
5510 session->name);
d5a1b7aa 5511 cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
d68c9a04 5512 goto end;
5c408ad8 5513 }
b02f5986
MD
5514
5515 /*
5516 * After a stop followed by a clear, disallow following rotations a they would
5517 * generate empty chunks.
5518 */
5519 if (session->cleared_after_last_stop) {
5520 DBG("Session \"%s\" was already cleared after stop, refusing rotation",
5521 session->name);
5522 cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR;
5523 goto end;
5524 }
5525
d2956687 5526 if (session->active) {
348a81dc 5527 new_trace_chunk = session_create_new_trace_chunk(session, NULL,
d2956687
JG
5528 NULL, NULL);
5529 if (!new_trace_chunk) {
5530 cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
5531 goto error;
5c408ad8 5532 }
0e270a1e 5533 }
2961f09e 5534
3156892b
JG
5535 /*
5536 * The current trace chunk becomes the chunk being archived.
5537 *
5538 * After this point, "chunk_being_archived" must absolutely
5539 * be closed on the consumer(s), otherwise it will never be
5540 * cleaned-up, which will result in a leak.
5541 */
d2956687
JG
5542 ret = session_set_trace_chunk(session, new_trace_chunk,
5543 &chunk_being_archived);
5544 if (ret) {
5545 cmd_ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
b178f53e
JG
5546 goto error;
5547 }
5548
5c408ad8 5549 if (session->kernel_session) {
d5a1b7aa
JG
5550 cmd_ret = kernel_rotate_session(session);
5551 if (cmd_ret != LTTNG_OK) {
3156892b
JG
5552 failed_to_rotate = true;
5553 rotation_fail_code = cmd_ret;
5c408ad8
JD
5554 }
5555 }
5556 if (session->ust_session) {
d5a1b7aa
JG
5557 cmd_ret = ust_app_rotate_session(session);
5558 if (cmd_ret != LTTNG_OK) {
3156892b
JG
5559 failed_to_rotate = true;
5560 rotation_fail_code = cmd_ret;
5c408ad8 5561 }
92816cc3 5562 }
17dd1232 5563
3b61d9ee
JG
5564 if (!session->active) {
5565 session->rotated_after_last_stop = true;
5566 }
5567
5568 if (!chunk_being_archived) {
5569 DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check",
5570 session->name);
5571 if (failed_to_rotate) {
5572 cmd_ret = rotation_fail_code;
5573 goto error;
5574 }
5575 cmd_ret = LTTNG_OK;
5576 goto end;
5577 }
5578
5579 session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
5580 chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
5581 &ongoing_rotation_chunk_id);
a0377dfe 5582 LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
3b61d9ee 5583
bbc4768c 5584 ret = session_close_trace_chunk(session, chunk_being_archived,
343defc2 5585 command, session->last_chunk_path);
d2956687
JG
5586 if (ret) {
5587 cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
5588 goto error;
5589 }
5590
3156892b
JG
5591 if (failed_to_rotate) {
5592 cmd_ret = rotation_fail_code;
5593 goto error;
5594 }
5595
7fdbed1c 5596 session->quiet_rotation = quiet_rotation;
92816cc3
JG
5597 ret = timer_session_rotation_pending_check_start(session,
5598 DEFAULT_ROTATE_PENDING_TIMER);
5599 if (ret) {
d5a1b7aa 5600 cmd_ret = LTTNG_ERR_UNK;
2961f09e 5601 goto error;
5c408ad8
JD
5602 }
5603
5c408ad8 5604 if (rotate_return) {
d2956687 5605 rotate_return->rotation_id = ongoing_rotation_chunk_id;
5c408ad8
JD
5606 }
5607
d2956687
JG
5608 session->chunk_being_archived = chunk_being_archived;
5609 chunk_being_archived = NULL;
7fdbed1c
JG
5610 if (!quiet_rotation) {
5611 ret = notification_thread_command_session_rotation_ongoing(
412d7227
SM
5612 the_notification_thread_handle, session->name,
5613 session->uid, session->gid,
7fdbed1c
JG
5614 ongoing_rotation_chunk_id);
5615 if (ret != LTTNG_OK) {
5616 ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
5617 session->name);
7966af57 5618 cmd_ret = (lttng_error_code) ret;
7fdbed1c 5619 }
2961f09e
JG
5620 }
5621
92816cc3 5622 DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent",
d2956687 5623 session->name, ongoing_rotation_chunk_id);
5c408ad8 5624end:
d2956687
JG
5625 lttng_trace_chunk_put(new_trace_chunk);
5626 lttng_trace_chunk_put(chunk_being_archived);
d5a1b7aa 5627 ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret);
5c408ad8 5628 return ret;
2961f09e 5629error:
2961f09e 5630 if (session_reset_rotation_state(session,
d2956687 5631 LTTNG_ROTATION_STATE_ERROR)) {
2961f09e
JG
5632 ERR("Failed to reset rotation state of session \"%s\"",
5633 session->name);
5634 }
5635 goto end;
5c408ad8
JD
5636}
5637
5638/*
d68c9a04 5639 * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library.
5c408ad8
JD
5640 *
5641 * Check if the session has finished its rotation.
5642 *
d2956687 5643 * Return LTTNG_OK on success or else an LTTNG_ERR code.
5c408ad8 5644 */
d68c9a04
JD
5645int cmd_rotate_get_info(struct ltt_session *session,
5646 struct lttng_rotation_get_info_return *info_return,
5647 uint64_t rotation_id)
5c408ad8 5648{
d2956687
JG
5649 enum lttng_error_code cmd_ret = LTTNG_OK;
5650 enum lttng_rotation_state rotation_state;
5c408ad8 5651
d68c9a04 5652 DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
d2956687 5653 session->most_recent_chunk_id.value);
5c408ad8 5654
d2956687
JG
5655 if (session->chunk_being_archived) {
5656 enum lttng_trace_chunk_status chunk_status;
5657 uint64_t chunk_id;
5658
5659 chunk_status = lttng_trace_chunk_get_id(
5660 session->chunk_being_archived,
5661 &chunk_id);
a0377dfe 5662 LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
d2956687
JG
5663
5664 rotation_state = rotation_id == chunk_id ?
5665 LTTNG_ROTATION_STATE_ONGOING :
5666 LTTNG_ROTATION_STATE_EXPIRED;
5667 } else {
5668 if (session->last_archived_chunk_id.is_set &&
5669 rotation_id != session->last_archived_chunk_id.value) {
5670 rotation_state = LTTNG_ROTATION_STATE_EXPIRED;
5671 } else {
5672 rotation_state = session->rotation_state;
5673 }
5c408ad8
JD
5674 }
5675
d2956687
JG
5676 switch (rotation_state) {
5677 case LTTNG_ROTATION_STATE_NO_ROTATION:
83ed9e90 5678 DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"",
d2956687
JG
5679 session->name);
5680 goto end;
5681 case LTTNG_ROTATION_STATE_EXPIRED:
5682 DBG("Reporting that the rotation state of rotation id %" PRIu64 " of session \"%s\" has expired",
5683 rotation_id, session->name);
5684 break;
d68c9a04 5685 case LTTNG_ROTATION_STATE_ONGOING:
d2956687 5686 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending",
d68c9a04
JD
5687 rotation_id, session->name);
5688 break;
5689 case LTTNG_ROTATION_STATE_COMPLETED:
dd73d57b 5690 {
d2956687
JG
5691 int fmt_ret;
5692 char *chunk_path;
dd73d57b
JG
5693 char *current_tracing_path_reply;
5694 size_t current_tracing_path_reply_len;
5695
d2956687
JG
5696 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed",
5697 rotation_id, session->name);
5698
dd73d57b
JG
5699 switch (session_get_consumer_destination_type(session)) {
5700 case CONSUMER_DST_LOCAL:
5701 current_tracing_path_reply =
5702 info_return->location.local.absolute_path;
5703 current_tracing_path_reply_len =
5704 sizeof(info_return->location.local.absolute_path);
5705 info_return->location_type =
05f8afa9 5706 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
ecd1a12f
MD
5707 fmt_ret = asprintf(&chunk_path,
5708 "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
5709 session_get_base_path(session),
5710 session->last_archived_chunk_name);
5711 if (fmt_ret == -1) {
5712 PERROR("Failed to format the path of the last archived trace chunk");
5713 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5714 cmd_ret = LTTNG_ERR_UNK;
5715 goto end;
5716 }
dd73d57b
JG
5717 break;
5718 case CONSUMER_DST_NET:
09cfbe47
JG
5719 {
5720 uint16_t ctrl_port, data_port;
5721
dd73d57b
JG
5722 current_tracing_path_reply =
5723 info_return->location.relay.relative_path;
5724 current_tracing_path_reply_len =
5725 sizeof(info_return->location.relay.relative_path);
5726 /* Currently the only supported relay protocol. */
5727 info_return->location.relay.protocol =
05f8afa9 5728 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
dd73d57b 5729
d2956687 5730 fmt_ret = lttng_strncpy(info_return->location.relay.host,
dd73d57b
JG
5731 session_get_net_consumer_hostname(session),
5732 sizeof(info_return->location.relay.host));
d2956687
JG
5733 if (fmt_ret) {
5734 ERR("Failed to copy host name to rotate_get_info reply");
dd73d57b 5735 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
d2956687 5736 cmd_ret = LTTNG_ERR_SET_URL;
dd73d57b
JG
5737 goto end;
5738 }
5739
09cfbe47
JG
5740 session_get_net_consumer_ports(session, &ctrl_port, &data_port);
5741 info_return->location.relay.ports.control = ctrl_port;
5742 info_return->location.relay.ports.data = data_port;
dd73d57b 5743 info_return->location_type =
05f8afa9 5744 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
ecd1a12f
MD
5745 chunk_path = strdup(session->last_chunk_path);
5746 if (!chunk_path) {
5747 ERR("Failed to allocate the path of the last archived trace chunk");
5748 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5749 cmd_ret = LTTNG_ERR_UNK;
5750 goto end;
5751 }
dd73d57b 5752 break;
09cfbe47 5753 }
dd73d57b
JG
5754 default:
5755 abort();
5756 }
d2956687
JG
5757
5758 fmt_ret = lttng_strncpy(current_tracing_path_reply,
5759 chunk_path, current_tracing_path_reply_len);
5760 free(chunk_path);
5761 if (fmt_ret) {
5762 ERR("Failed to copy path of the last archived trace chunk to rotate_get_info reply");
d68c9a04 5763 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
d2956687 5764 cmd_ret = LTTNG_ERR_UNK;
5c408ad8
JD
5765 goto end;
5766 }
dd73d57b 5767
d68c9a04 5768 break;
dd73d57b 5769 }
d68c9a04 5770 case LTTNG_ROTATION_STATE_ERROR:
d2956687 5771 DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"",
d68c9a04
JD
5772 rotation_id, session->name);
5773 break;
5774 default:
5775 abort();
5c408ad8
JD
5776 }
5777
d2956687 5778 cmd_ret = LTTNG_OK;
5c408ad8 5779end:
d2956687
JG
5780 info_return->status = (int32_t) rotation_state;
5781 return cmd_ret;
5c408ad8
JD
5782}
5783
259c2674
JD
5784/*
5785 * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library.
5786 *
5787 * Configure the automatic rotation parameters.
66ea93b1
JG
5788 * 'activate' to true means activate the rotation schedule type with 'new_value'.
5789 * 'activate' to false means deactivate the rotation schedule and validate that
5790 * 'new_value' has the same value as the currently active value.
259c2674 5791 *
1136f41b 5792 * Return LTTNG_OK on success or else a positive LTTNG_ERR code.
259c2674
JD
5793 */
5794int cmd_rotation_set_schedule(struct ltt_session *session,
66ea93b1
JG
5795 bool activate, enum lttng_rotation_schedule_type schedule_type,
5796 uint64_t new_value,
90936dcf 5797 struct notification_thread_handle *notification_thread_handle)
259c2674
JD
5798{
5799 int ret;
66ea93b1 5800 uint64_t *parameter_value;
259c2674 5801
a0377dfe 5802 LTTNG_ASSERT(session);
259c2674
JD
5803
5804 DBG("Cmd rotate set schedule session %s", session->name);
5805
92fe5ca1 5806 if (session->live_timer || !session->output_traces) {
66ea93b1 5807 DBG("Failing ROTATION_SET_SCHEDULE command as the rotation feature is not available for this session");
259c2674
JD
5808 ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
5809 goto end;
5810 }
5811
66ea93b1
JG
5812 switch (schedule_type) {
5813 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5814 parameter_value = &session->rotate_size;
5815 break;
5816 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5817 parameter_value = &session->rotate_timer_period;
5818 if (new_value >= UINT_MAX) {
5819 DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)",
5820 new_value, UINT_MAX);
5821 ret = LTTNG_ERR_INVALID;
5822 goto end;
5823 }
5824 break;
5825 default:
5826 WARN("Failing ROTATION_SET_SCHEDULE command on unknown schedule type");
5827 ret = LTTNG_ERR_INVALID;
259c2674 5828 goto end;
66ea93b1
JG
5829 }
5830
5831 /* Improper use of the API. */
5832 if (new_value == -1ULL) {
5833 WARN("Failing ROTATION_SET_SCHEDULE command as the value requested is -1");
5834 ret = LTTNG_ERR_INVALID;
259c2674
JD
5835 goto end;
5836 }
5837
66ea93b1
JG
5838 /*
5839 * As indicated in struct ltt_session's comments, a value of == 0 means
5840 * this schedule rotation type is not in use.
5841 *
5842 * Reject the command if we were asked to activate a schedule that was
5843 * already active.
5844 */
5845 if (activate && *parameter_value != 0) {
5846 DBG("Failing ROTATION_SET_SCHEDULE (activate) command as the schedule is already active");
5847 ret = LTTNG_ERR_ROTATION_SCHEDULE_SET;
90936dcf 5848 goto end;
66ea93b1
JG
5849 }
5850
5851 /*
5852 * Reject the command if we were asked to deactivate a schedule that was
5853 * not active.
5854 */
5855 if (!activate && *parameter_value == 0) {
5856 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as the schedule is already inactive");
5857 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
90936dcf
JD
5858 goto end;
5859 }
5860
66ea93b1
JG
5861 /*
5862 * Reject the command if we were asked to deactivate a schedule that
5863 * doesn't exist.
5864 */
5865 if (!activate && *parameter_value != new_value) {
5866 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as an inexistant schedule was provided");
5867 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
5868 goto end;
5869 }
259c2674 5870
66ea93b1
JG
5871 *parameter_value = activate ? new_value : 0;
5872
5873 switch (schedule_type) {
5874 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5875 if (activate && session->active) {
5876 /*
5877 * Only start the timer if the session is active,
5878 * otherwise it will be started when the session starts.
5879 */
92816cc3
JG
5880 ret = timer_session_rotation_schedule_timer_start(
5881 session, new_value);
259c2674 5882 if (ret) {
66ea93b1 5883 ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command");
259c2674
JD
5884 ret = LTTNG_ERR_UNK;
5885 goto end;
5886 }
66ea93b1 5887 } else {
92816cc3
JG
5888 ret = timer_session_rotation_schedule_timer_stop(
5889 session);
66ea93b1
JG
5890 if (ret) {
5891 ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command");
5892 ret = LTTNG_ERR_UNK;
f3ce6946 5893 goto end;
66ea93b1 5894 }
259c2674 5895 }
66ea93b1
JG
5896 break;
5897 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5898 if (activate) {
5899 ret = subscribe_session_consumed_size_rotation(session,
5900 new_value, notification_thread_handle);
90936dcf 5901 if (ret) {
66ea93b1 5902 ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command");
90936dcf
JD
5903 ret = LTTNG_ERR_UNK;
5904 goto end;
5905 }
90936dcf 5906 } else {
66ea93b1
JG
5907 ret = unsubscribe_session_consumed_size_rotation(session,
5908 notification_thread_handle);
90936dcf 5909 if (ret) {
66ea93b1 5910 ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command");
90936dcf
JD
5911 ret = LTTNG_ERR_UNK;
5912 goto end;
5913 }
66ea93b1 5914
90936dcf 5915 }
66ea93b1
JG
5916 break;
5917 default:
5918 /* Would have been caught before. */
5919 abort();
90936dcf
JD
5920 }
5921
259c2674
JD
5922 ret = LTTNG_OK;
5923
5924 goto end;
5925
5926end:
5927 return ret;
5928}
5929
a503e1ef
JG
5930/* Wait for a given path to be removed before continuing. */
5931static enum lttng_error_code wait_on_path(void *path_data)
5932{
7966af57 5933 const char *shm_path = (const char *) path_data;
a503e1ef
JG
5934
5935 DBG("Waiting for the shm path at %s to be removed before completing session destruction",
5936 shm_path);
5937 while (true) {
5938 int ret;
5939 struct stat st;
5940
5941 ret = stat(shm_path, &st);
5942 if (ret) {
5943 if (errno != ENOENT) {
5944 PERROR("stat() returned an error while checking for the existence of the shm path");
5945 } else {
5946 DBG("shm path no longer exists, completing the destruction of session");
5947 }
5948 break;
5949 } else {
5950 if (!S_ISDIR(st.st_mode)) {
5951 ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal",
5952 shm_path);
5953 break;
5954 }
5955 }
5956 usleep(SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US);
5957 }
5958 return LTTNG_OK;
5959}
5960
5961/*
5962 * Returns a pointer to a handler to run on completion of a command.
5963 * Returns NULL if no handler has to be run for the last command executed.
5964 */
5965const struct cmd_completion_handler *cmd_pop_completion_handler(void)
5966{
5967 struct cmd_completion_handler *handler = current_completion_handler;
5968
5969 current_completion_handler = NULL;
5970 return handler;
5971}
5972
2f77fc4b
DG
5973/*
5974 * Init command subsystem.
5975 */
5976void cmd_init(void)
5977{
5978 /*
d88aee68
DG
5979 * Set network sequence index to 1 for streams to match a relayd
5980 * socket on the consumer side.
2f77fc4b 5981 */
d88aee68
DG
5982 pthread_mutex_lock(&relayd_net_seq_idx_lock);
5983 relayd_net_seq_idx = 1;
5984 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
5985
5986 DBG("Command subsystem initialized");
5987}
This page took 0.501866 seconds and 4 git commands to generate.