Fix: sessiond: null pointer dereference on initial evaluation of session
[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
139a8d25
JG
3139 ret_code = notification_thread_command_add_session(the_notification_thread_handle,
3140 new_session->id, new_session->name, new_session->uid, new_session->gid);
3141 if (ret_code != LTTNG_OK) {
3142 goto end;
3143 }
3144
3145 /* Announce the session's destruction to the notification thread when it is destroyed. */
3146 ret = session_add_destroy_notifier(
3147 new_session,
3148 [](const struct ltt_session *session,
3149 void *user_data __attribute__((unused))) {
3150 (void) notification_thread_command_remove_session(
3151 the_notification_thread_handle, session->id);
3152 },
3153 NULL);
3154 if (ret) {
3155 PERROR("Failed to add notification thread command to session's destroy notifiers: session name = %s",
3156 new_session->name);
3157 ret = LTTNG_ERR_NOMEM;
3158 goto end;
3159 }
3160
b178f53e
JG
3161 if (!session_name) {
3162 ret = lttng_session_descriptor_set_session_name(descriptor,
3163 new_session->name);
3164 if (ret) {
3165 ret_code = LTTNG_ERR_SESSION_FAIL;
3166 goto end;
3167 }
3168 }
3169
3170 if (!lttng_session_descriptor_is_output_destination_initialized(
3171 descriptor)) {
3172 /*
3173 * Only include the session's creation time in the output
3174 * destination if the name of the session itself was
3175 * not auto-generated.
3176 */
3177 ret_code = lttng_session_descriptor_set_default_output(
3178 descriptor,
3179 session_name ? &new_session->creation_time : NULL,
3180 home_path);
3181 if (ret_code != LTTNG_OK) {
e32d7f27 3182 goto end;
2bba9e53 3183 }
2bba9e53 3184 } else {
b178f53e
JG
3185 new_session->has_user_specified_directory =
3186 lttng_session_descriptor_has_output_directory(
3187 descriptor);
2f77fc4b
DG
3188 }
3189
b178f53e
JG
3190 switch (lttng_session_descriptor_get_type(descriptor)) {
3191 case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
3192 new_session->snapshot_mode = 1;
3193 break;
3194 case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
3195 new_session->live_timer =
3196 lttng_session_descriptor_live_get_timer_interval(
3197 descriptor);
3198 break;
3199 default:
3200 break;
3201 }
2f77fc4b 3202
b178f53e
JG
3203 ret_code = set_session_output_from_descriptor(new_session, descriptor);
3204 if (ret_code != LTTNG_OK) {
3205 goto end;
3206 }
3207 new_session->consumer->enabled = 1;
3208 ret_code = LTTNG_OK;
e32d7f27 3209end:
b178f53e
JG
3210 /* Release reference provided by the session_create function. */
3211 session_put(new_session);
3212 if (ret_code != LTTNG_OK && new_session) {
3213 /* Release the global reference on error. */
3214 session_destroy(new_session);
e32d7f27 3215 }
b178f53e
JG
3216 session_unlock_list();
3217 return ret_code;
2f77fc4b
DG
3218}
3219
b178f53e
JG
3220enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
3221 struct lttng_session_descriptor **return_descriptor)
27babd3a
DG
3222{
3223 int ret;
b178f53e
JG
3224 size_t payload_size;
3225 struct lttng_dynamic_buffer payload;
3226 struct lttng_buffer_view home_dir_view;
3227 struct lttng_buffer_view session_descriptor_view;
3228 struct lttng_session_descriptor *session_descriptor = NULL;
3229 enum lttng_error_code ret_code;
3230
3231 lttng_dynamic_buffer_init(&payload);
3a91de3a 3232 if (cmd_ctx->lsm.u.create_session.home_dir_size >=
b178f53e
JG
3233 LTTNG_PATH_MAX) {
3234 ret_code = LTTNG_ERR_INVALID;
3235 goto error;
27babd3a 3236 }
3a91de3a 3237 if (cmd_ctx->lsm.u.create_session.session_descriptor_size >
b178f53e
JG
3238 LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
3239 ret_code = LTTNG_ERR_INVALID;
3240 goto error;
27babd3a
DG
3241 }
3242
3a91de3a
JG
3243 payload_size = cmd_ctx->lsm.u.create_session.home_dir_size +
3244 cmd_ctx->lsm.u.create_session.session_descriptor_size;
b178f53e
JG
3245 ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
3246 if (ret) {
3247 ret_code = LTTNG_ERR_NOMEM;
3248 goto error;
27babd3a
DG
3249 }
3250
b178f53e
JG
3251 ret = lttcomm_recv_unix_sock(sock, payload.data, payload.size);
3252 if (ret <= 0) {
3253 ERR("Reception of session descriptor failed, aborting.");
3254 ret_code = LTTNG_ERR_SESSION_FAIL;
3255 goto error;
27babd3a
DG
3256 }
3257
b178f53e
JG
3258 home_dir_view = lttng_buffer_view_from_dynamic_buffer(
3259 &payload,
3260 0,
3a91de3a 3261 cmd_ctx->lsm.u.create_session.home_dir_size);
3e6e0df2
JG
3262 if (cmd_ctx->lsm.u.create_session.home_dir_size > 0 &&
3263 !lttng_buffer_view_is_valid(&home_dir_view)) {
3264 ERR("Invalid payload in \"create session\" command: buffer too short to contain home directory");
3265 ret_code = LTTNG_ERR_INVALID_PROTOCOL;
3266 goto error;
3267 }
3268
b178f53e
JG
3269 session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
3270 &payload,
3a91de3a
JG
3271 cmd_ctx->lsm.u.create_session.home_dir_size,
3272 cmd_ctx->lsm.u.create_session.session_descriptor_size);
3e6e0df2
JG
3273 if (!lttng_buffer_view_is_valid(&session_descriptor_view)) {
3274 ERR("Invalid payload in \"create session\" command: buffer too short to contain session descriptor");
3275 ret_code = LTTNG_ERR_INVALID_PROTOCOL;
3276 goto error;
3277 }
27babd3a 3278
b178f53e
JG
3279 ret = lttng_session_descriptor_create_from_buffer(
3280 &session_descriptor_view, &session_descriptor);
3281 if (ret < 0) {
3282 ERR("Failed to create session descriptor from payload of \"create session\" command");
3283 ret_code = LTTNG_ERR_INVALID;
3284 goto error;
3285 }
27babd3a 3286
b178f53e
JG
3287 /*
3288 * Sets the descriptor's auto-generated properties (name, output) if
3289 * needed.
3290 */
3291 ret_code = cmd_create_session_from_descriptor(session_descriptor,
3292 &cmd_ctx->creds,
3293 home_dir_view.size ? home_dir_view.data : NULL);
3294 if (ret_code != LTTNG_OK) {
3295 goto error;
e32d7f27 3296 }
b178f53e
JG
3297
3298 ret_code = LTTNG_OK;
3299 *return_descriptor = session_descriptor;
3300 session_descriptor = NULL;
3301error:
3302 lttng_dynamic_buffer_reset(&payload);
3303 lttng_session_descriptor_destroy(session_descriptor);
3304 return ret_code;
27babd3a
DG
3305}
3306
3e3665b8
JG
3307static
3308void cmd_destroy_session_reply(const struct ltt_session *session,
3309 void *_reply_context)
3310{
3311 int ret;
3312 ssize_t comm_ret;
3313 const struct cmd_destroy_session_reply_context *reply_context =
7966af57 3314 (cmd_destroy_session_reply_context *) _reply_context;
3e3665b8
JG
3315 struct lttng_dynamic_buffer payload;
3316 struct lttcomm_session_destroy_command_header cmd_header;
3317 struct lttng_trace_archive_location *location = NULL;
3318 struct lttcomm_lttng_msg llm = {
3319 .cmd_type = LTTNG_DESTROY_SESSION,
3285a971 3320 .ret_code = reply_context->destruction_status,
3e3665b8
JG
3321 .pid = UINT32_MAX,
3322 .cmd_header_size =
3323 sizeof(struct lttcomm_session_destroy_command_header),
3324 .data_size = 0,
1c9a0b0e 3325 .fd_count = 0,
3e3665b8
JG
3326 };
3327 size_t payload_size_before_location;
3328
3329 lttng_dynamic_buffer_init(&payload);
3330
3331 ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm));
0e270a1e 3332 if (ret) {
3e3665b8
JG
3333 ERR("Failed to append session destruction message");
3334 goto error;
0e270a1e 3335 }
3e3665b8
JG
3336
3337 cmd_header.rotation_state =
3338 (int32_t) (reply_context->implicit_rotation_on_destroy ?
3339 session->rotation_state :
3340 LTTNG_ROTATION_STATE_NO_ROTATION);
3341 ret = lttng_dynamic_buffer_append(&payload, &cmd_header,
3342 sizeof(cmd_header));
3343 if (ret) {
3344 ERR("Failed to append session destruction command header");
3345 goto error;
3346 }
3347
3348 if (!reply_context->implicit_rotation_on_destroy) {
3349 DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply",
3350 session->name);
3351 goto send_reply;
3352 }
3353 if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) {
3354 DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply",
3355 session->name);
3356 goto send_reply;
3357 }
3358
3359 location = session_get_trace_archive_location(session);
3360 if (!location) {
3361 ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"",
3362 session->name);
3363 goto error;
3364 }
3365
3366 payload_size_before_location = payload.size;
3367 comm_ret = lttng_trace_archive_location_serialize(location,
3368 &payload);
d3740619 3369 lttng_trace_archive_location_put(location);
3e3665b8
JG
3370 if (comm_ret < 0) {
3371 ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
3372 session->name);
3373 goto error;
3374 }
3375 /* Update the message to indicate the location's length. */
3376 ((struct lttcomm_lttng_msg *) payload.data)->data_size =
3377 payload.size - payload_size_before_location;
3378send_reply:
3379 comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd,
3380 payload.data, payload.size);
3381 if (comm_ret != (ssize_t) payload.size) {
3382 ERR("Failed to send result of the destruction of session \"%s\" to client",
3383 session->name);
3384 }
3385error:
3386 ret = close(reply_context->reply_sock_fd);
3387 if (ret) {
3388 PERROR("Failed to close client socket in deferred session destroy reply");
3389 }
3390 lttng_dynamic_buffer_reset(&payload);
3391 free(_reply_context);
3392}
3393
2f77fc4b
DG
3394/*
3395 * Command LTTNG_DESTROY_SESSION processed by the client thread.
a9ad0c8f
MD
3396 *
3397 * Called with session lock held.
2f77fc4b 3398 */
e32d7f27 3399int cmd_destroy_session(struct ltt_session *session,
3e3665b8
JG
3400 struct notification_thread_handle *notification_thread_handle,
3401 int *sock_fd)
2f77fc4b
DG
3402{
3403 int ret;
3285a971 3404 enum lttng_error_code destruction_last_error = LTTNG_OK;
3e3665b8
JG
3405 struct cmd_destroy_session_reply_context *reply_context = NULL;
3406
3407 if (sock_fd) {
64803277 3408 reply_context = zmalloc<cmd_destroy_session_reply_context>();
3e3665b8
JG
3409 if (!reply_context) {
3410 ret = LTTNG_ERR_NOMEM;
3411 goto end;
3412 }
64803277 3413
3e3665b8
JG
3414 reply_context->reply_sock_fd = *sock_fd;
3415 }
2f77fc4b
DG
3416
3417 /* Safety net */
a0377dfe 3418 LTTNG_ASSERT(session);
2f77fc4b 3419
3e3665b8
JG
3420 DBG("Begin destroy session %s (id %" PRIu64 ")", session->name,
3421 session->id);
3422 if (session->active) {
3423 DBG("Session \"%s\" is active, attempting to stop it before destroying it",
3424 session->name);
3425 ret = cmd_stop_trace(session);
3426 if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) {
3427 /* Carry on with the destruction of the session. */
3428 ERR("Failed to stop session \"%s\" as part of its destruction: %s",
3429 session->name, lttng_strerror(-ret));
7966af57 3430 destruction_last_error = (lttng_error_code) ret;
3e3665b8
JG
3431 }
3432 }
5c408ad8 3433
92816cc3
JG
3434 if (session->rotation_schedule_timer_enabled) {
3435 if (timer_session_rotation_schedule_timer_stop(
3436 session)) {
3437 ERR("Failed to stop the \"rotation schedule\" timer of session %s",
3438 session->name);
3285a971 3439 destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;
92816cc3 3440 }
259c2674
JD
3441 }
3442
90936dcf
JD
3443 if (session->rotate_size) {
3444 unsubscribe_session_consumed_size_rotation(session, notification_thread_handle);
3445 session->rotate_size = 0;
3446 }
3447
a7ceb342 3448 if (session->rotated && session->current_trace_chunk && session->output_traces) {
b5893d8e
JG
3449 /*
3450 * Perform a last rotation on destruction if rotations have
3451 * occurred during the session's lifetime.
3452 */
343defc2
MD
3453 ret = cmd_rotate_session(session, NULL, false,
3454 LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
d2956687
JG
3455 if (ret != LTTNG_OK) {
3456 ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
3457 session->name, lttng_strerror(-ret));
7966af57 3458 destruction_last_error = (lttng_error_code) -ret;
124473a3 3459 }
0e270a1e 3460 if (reply_context) {
3e3665b8 3461 reply_context->implicit_rotation_on_destroy = true;
0e270a1e
JG
3462 }
3463 } else if (session->has_been_started && session->current_trace_chunk) {
7fdbed1c
JG
3464 /*
3465 * The user has not triggered a session rotation. However, to
3466 * ensure all data has been consumed, the session is rotated
3467 * to a 'null' trace chunk before it is destroyed.
3468 *
3469 * This is a "quiet" rotation meaning that no notification is
3470 * emitted and no renaming of the current trace chunk takes
3471 * place.
3472 */
343defc2
MD
3473 ret = cmd_rotate_session(session, NULL, true,
3474 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
53fb6336
JG
3475 /*
3476 * Rotation operations may not be supported by the kernel
3477 * tracer. Hence, do not consider this implicit rotation as
3478 * a session destruction error. The library has already stopped
3479 * the session and waited for pending data; there is nothing
3480 * left to do but complete the destruction of the session.
3481 */
3482 if (ret != LTTNG_OK &&
3483 ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) {
7fdbed1c 3484 ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
53fb6336 3485 session->name, lttng_strerror(ret));
7966af57 3486 destruction_last_error = (lttng_error_code) -ret;
7fdbed1c
JG
3487 }
3488 }
5c408ad8 3489
a503e1ef
JG
3490 if (session->shm_path[0]) {
3491 /*
3492 * When a session is created with an explicit shm_path,
3493 * the consumer daemon will create its shared memory files
3494 * at that location and will *not* unlink them. This is normal
3495 * as the intention of that feature is to make it possible
3496 * to retrieve the content of those files should a crash occur.
3497 *
3498 * To ensure the content of those files can be used, the
3499 * sessiond daemon will replicate the content of the metadata
3500 * cache in a metadata file.
3501 *
3502 * On clean-up, it is expected that the consumer daemon will
3503 * unlink the shared memory files and that the session daemon
3504 * will unlink the metadata file. Then, the session's directory
3505 * in the shm path can be removed.
3506 *
3507 * Unfortunately, a flaw in the design of the sessiond's and
3508 * consumerd's tear down of channels makes it impossible to
3509 * determine when the sessiond _and_ the consumerd have both
3510 * destroyed their representation of a channel. For one, the
3511 * unlinking, close, and rmdir happen in deferred 'call_rcu'
3512 * callbacks in both daemons.
3513 *
3514 * However, it is also impossible for the sessiond to know when
3515 * the consumer daemon is done destroying its channel(s) since
3516 * it occurs as a reaction to the closing of the channel's file
3517 * descriptor. There is no resulting communication initiated
3518 * from the consumerd to the sessiond to confirm that the
3519 * operation is completed (and was successful).
3520 *
3521 * Until this is all fixed, the session daemon checks for the
3522 * removal of the session's shm path which makes it possible
3523 * to safely advertise a session as having been destroyed.
3524 *
3525 * Prior to this fix, it was not possible to reliably save
3526 * a session making use of the --shm-path option, destroy it,
3527 * and load it again. This is because the creation of the
3528 * session would fail upon seeing the session's shm path
3529 * already in existence.
3530 *
3531 * Note that none of the error paths in the check for the
3532 * directory's existence return an error. This is normal
3533 * as there isn't much that can be done. The session will
3534 * be destroyed properly, except that we can't offer the
3535 * guarantee that the same session can be re-created.
3536 */
3537 current_completion_handler = &destroy_completion_handler.handler;
3538 ret = lttng_strncpy(destroy_completion_handler.shm_path,
3539 session->shm_path,
3540 sizeof(destroy_completion_handler.shm_path));
a0377dfe 3541 LTTNG_ASSERT(!ret);
a503e1ef 3542 }
e32d7f27
JG
3543
3544 /*
3545 * The session is destroyed. However, note that the command context
3546 * still holds a reference to the session, thus delaying its destruction
3547 * _at least_ up to the point when that reference is released.
3548 */
3549 session_destroy(session);
3e3665b8 3550 if (reply_context) {
3285a971 3551 reply_context->destruction_status = destruction_last_error;
3e3665b8
JG
3552 ret = session_add_destroy_notifier(session,
3553 cmd_destroy_session_reply,
3554 (void *) reply_context);
3555 if (ret) {
3556 ret = LTTNG_ERR_FATAL;
3557 goto end;
3558 } else {
3559 *sock_fd = -1;
3560 }
0e270a1e
JG
3561 }
3562 ret = LTTNG_OK;
3e3665b8 3563end:
2f77fc4b
DG
3564 return ret;
3565}
3566
2f77fc4b
DG
3567/*
3568 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
3569 */
56a37563
JG
3570int cmd_register_consumer(struct ltt_session *session,
3571 enum lttng_domain_type domain, const char *sock_path,
3572 struct consumer_data *cdata)
2f77fc4b
DG
3573{
3574 int ret, sock;
dd81b457 3575 struct consumer_socket *socket = NULL;
2f77fc4b 3576
a0377dfe
FD
3577 LTTNG_ASSERT(session);
3578 LTTNG_ASSERT(cdata);
3579 LTTNG_ASSERT(sock_path);
2f77fc4b
DG
3580
3581 switch (domain) {
3582 case LTTNG_DOMAIN_KERNEL:
3583 {
3584 struct ltt_kernel_session *ksess = session->kernel_session;
3585
a0377dfe 3586 LTTNG_ASSERT(ksess);
2f77fc4b
DG
3587
3588 /* Can't register a consumer if there is already one */
3589 if (ksess->consumer_fds_sent != 0) {
f73fabfd 3590 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2f77fc4b
DG
3591 goto error;
3592 }
3593
3594 sock = lttcomm_connect_unix_sock(sock_path);
3595 if (sock < 0) {
f73fabfd 3596 ret = LTTNG_ERR_CONNECT_FAIL;
2f77fc4b
DG
3597 goto error;
3598 }
4ce514c4 3599 cdata->cmd_sock = sock;
2f77fc4b 3600
4ce514c4 3601 socket = consumer_allocate_socket(&cdata->cmd_sock);
2f77fc4b 3602 if (socket == NULL) {
f66c074c
DG
3603 ret = close(sock);
3604 if (ret < 0) {
3605 PERROR("close register consumer");
3606 }
4ce514c4 3607 cdata->cmd_sock = -1;
f73fabfd 3608 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3609 goto error;
3610 }
3611
64803277 3612 socket->lock = zmalloc<pthread_mutex_t>();
2f77fc4b
DG
3613 if (socket->lock == NULL) {
3614 PERROR("zmalloc pthread mutex");
f73fabfd 3615 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3616 goto error;
3617 }
64803277 3618
2f77fc4b
DG
3619 pthread_mutex_init(socket->lock, NULL);
3620 socket->registered = 1;
3621
3622 rcu_read_lock();
3623 consumer_add_socket(socket, ksess->consumer);
3624 rcu_read_unlock();
3625
3626 pthread_mutex_lock(&cdata->pid_mutex);
3627 cdata->pid = -1;
3628 pthread_mutex_unlock(&cdata->pid_mutex);
3629
3630 break;
3631 }
3632 default:
3633 /* TODO: Userspace tracing */
f73fabfd 3634 ret = LTTNG_ERR_UND;
2f77fc4b
DG
3635 goto error;
3636 }
3637
dd81b457 3638 return LTTNG_OK;
2f77fc4b
DG
3639
3640error:
dd81b457
DG
3641 if (socket) {
3642 consumer_destroy_socket(socket);
3643 }
2f77fc4b
DG
3644 return ret;
3645}
3646
3647/*
3648 * Command LTTNG_LIST_DOMAINS processed by the client thread.
3649 */
3650ssize_t cmd_list_domains(struct ltt_session *session,
3651 struct lttng_domain **domains)
3652{
3653 int ret, index = 0;
3654 ssize_t nb_dom = 0;
fefd409b
DG
3655 struct agent *agt;
3656 struct lttng_ht_iter iter;
2f77fc4b
DG
3657
3658 if (session->kernel_session != NULL) {
3659 DBG3("Listing domains found kernel domain");
3660 nb_dom++;
3661 }
3662
3663 if (session->ust_session != NULL) {
3664 DBG3("Listing domains found UST global domain");
3665 nb_dom++;
3c6a091f 3666
e0a74f01 3667 rcu_read_lock();
fefd409b
DG
3668 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3669 agt, node.node) {
3670 if (agt->being_used) {
3671 nb_dom++;
3672 }
3c6a091f 3673 }
e0a74f01 3674 rcu_read_unlock();
2f77fc4b
DG
3675 }
3676
fa64dfb4
JG
3677 if (!nb_dom) {
3678 goto end;
3679 }
3680
64803277 3681 *domains = calloc<lttng_domain>(nb_dom);
2f77fc4b 3682 if (*domains == NULL) {
f73fabfd 3683 ret = LTTNG_ERR_FATAL;
2f77fc4b
DG
3684 goto error;
3685 }
3686
3687 if (session->kernel_session != NULL) {
3688 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
b5edb9e8
PP
3689
3690 /* Kernel session buffer type is always GLOBAL */
3691 (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
3692
2f77fc4b
DG
3693 index++;
3694 }
3695
3696 if (session->ust_session != NULL) {
3697 (*domains)[index].type = LTTNG_DOMAIN_UST;
88c5f0d8 3698 (*domains)[index].buf_type = session->ust_session->buffer_type;
2f77fc4b 3699 index++;
3c6a091f 3700
e0a74f01 3701 rcu_read_lock();
fefd409b
DG
3702 cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
3703 agt, node.node) {
3704 if (agt->being_used) {
3705 (*domains)[index].type = agt->domain;
3706 (*domains)[index].buf_type = session->ust_session->buffer_type;
3707 index++;
3708 }
3c6a091f 3709 }
e0a74f01 3710 rcu_read_unlock();
2f77fc4b 3711 }
fa64dfb4 3712end:
2f77fc4b
DG
3713 return nb_dom;
3714
3715error:
f73fabfd
DG
3716 /* Return negative value to differentiate return code */
3717 return -ret;
2f77fc4b
DG
3718}
3719
3720
3721/*
3722 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3723 */
999af9c1
JR
3724enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain,
3725 struct ltt_session *session,
3726 struct lttng_payload *payload)
2f77fc4b 3727{
999af9c1
JR
3728 int ret = 0;
3729 unsigned int i = 0;
3730 struct lttcomm_list_command_header cmd_header = {};
3731 size_t cmd_header_offset;
3732 enum lttng_error_code ret_code;
3733
3734 assert(session);
3735 assert(payload);
3736
3737 DBG("Listing channels for session %s", session->name);
3738
3739 cmd_header_offset = payload->buffer.size;
3740
3741 /* Reserve space for command reply header. */
3742 ret = lttng_dynamic_buffer_set_size(&payload->buffer,
3743 cmd_header_offset + sizeof(cmd_header));
3744 if (ret) {
3745 ret_code = LTTNG_ERR_NOMEM;
3746 goto end;
3747 }
2f77fc4b
DG
3748
3749 switch (domain) {
3750 case LTTNG_DOMAIN_KERNEL:
999af9c1
JR
3751 {
3752 /* Kernel channels */
3753 struct ltt_kernel_channel *kchan;
2f77fc4b 3754 if (session->kernel_session != NULL) {
999af9c1
JR
3755 cds_list_for_each_entry(kchan,
3756 &session->kernel_session->channel_list.head, list) {
3757 uint64_t discarded_events, lost_packets;
3758 struct lttng_channel_extended *extended;
3759
3760 extended = (struct lttng_channel_extended *)
3761 kchan->channel->attr.extended.ptr;
3762
3763 ret = get_kernel_runtime_stats(session, kchan,
3764 &discarded_events, &lost_packets);
3765 if (ret < 0) {
3766 ret_code = LTTNG_ERR_UNK;
3767 goto end;
3768 }
3769
3770 /*
3771 * Update the discarded_events and lost_packets
3772 * count for the channel
3773 */
3774 extended->discarded_events = discarded_events;
3775 extended->lost_packets = lost_packets;
3776
3777 ret = lttng_channel_serialize(
3778 kchan->channel, &payload->buffer);
3779 if (ret) {
3780 ERR("Failed to serialize lttng_channel: channel name = '%s'",
3781 kchan->channel->name);
3782 ret_code = LTTNG_ERR_UNK;
3783 goto end;
3784 }
3785
3786 i++;
3787 }
c7d620a2 3788 }
2f77fc4b 3789 break;
999af9c1 3790 }
2f77fc4b 3791 case LTTNG_DOMAIN_UST:
999af9c1
JR
3792 {
3793 struct lttng_ht_iter iter;
3794 struct ltt_ust_channel *uchan;
3795
3796 rcu_read_lock();
3797 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
3798 &iter.iter, uchan, node.node) {
3799 uint64_t discarded_events = 0, lost_packets = 0;
3800 struct lttng_channel *channel = NULL;
3801 struct lttng_channel_extended *extended;
3802
3803 channel = trace_ust_channel_to_lttng_channel(uchan);
3804 if (!channel) {
9402f166
JR
3805 ret_code = LTTNG_ERR_NOMEM;
3806 goto end;
999af9c1
JR
3807 }
3808
3809 extended = (struct lttng_channel_extended *)
3810 channel->attr.extended.ptr;
3811
3812 ret = get_ust_runtime_stats(session, uchan,
3813 &discarded_events, &lost_packets);
3814 if (ret < 0) {
3815 lttng_channel_destroy(channel);
3816 ret_code = LTTNG_ERR_UNK;
9402f166 3817 goto end;
999af9c1
JR
3818 }
3819
3820 extended->discarded_events = discarded_events;
3821 extended->lost_packets = lost_packets;
3822
3823 ret = lttng_channel_serialize(
3824 channel, &payload->buffer);
3825 if (ret) {
3826 ERR("Failed to serialize lttng_channel: channel name = '%s'",
3827 channel->name);
ae2275af 3828 lttng_channel_destroy(channel);
999af9c1 3829 ret_code = LTTNG_ERR_UNK;
9402f166 3830 goto end;
999af9c1
JR
3831 }
3832
ae2275af 3833 lttng_channel_destroy(channel);
999af9c1 3834 i++;
c7d620a2 3835 }
999af9c1 3836 rcu_read_unlock();
2f77fc4b 3837 break;
999af9c1 3838 }
2f77fc4b 3839 default:
999af9c1 3840 break;
2f77fc4b
DG
3841 }
3842
999af9c1
JR
3843 if (i > UINT32_MAX) {
3844 ERR("Channel count would overflow the channel listing command's reply");
3845 ret_code = LTTNG_ERR_OVERFLOW;
3846 goto end;
2f77fc4b
DG
3847 }
3848
999af9c1
JR
3849 /* Update command reply header. */
3850 cmd_header.count = (uint32_t) i;
3851 memcpy(payload->buffer.data + cmd_header_offset, &cmd_header,
3852 sizeof(cmd_header));
3853 ret_code = LTTNG_OK;
3854
53e367f9 3855end:
999af9c1 3856 return ret_code;
2f77fc4b
DG
3857}
3858
3859/*
3860 * Command LTTNG_LIST_EVENTS processed by the client thread.
3861 */
8ddd72ef
JR
3862enum lttng_error_code cmd_list_events(enum lttng_domain_type domain,
3863 struct ltt_session *session,
3864 char *channel_name,
3865 struct lttng_payload *reply_payload)
2f77fc4b 3866{
8ddd72ef
JR
3867 int buffer_resize_ret;
3868 enum lttng_error_code ret_code = LTTNG_OK;
3869 struct lttcomm_list_command_header reply_command_header = {};
3870 size_t reply_command_header_offset;
23831239 3871 unsigned int nb_events = 0;
e368fb43 3872
8ddd72ef
JR
3873 assert(reply_payload);
3874
3875 /* Reserve space for command reply header. */
3876 reply_command_header_offset = reply_payload->buffer.size;
3877 buffer_resize_ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
3878 reply_command_header_offset +
3879 sizeof(struct lttcomm_list_command_header));
3880 if (buffer_resize_ret) {
3881 ret_code = LTTNG_ERR_NOMEM;
3882 goto end;
e368fb43 3883 }
2f77fc4b
DG
3884
3885 switch (domain) {
3886 case LTTNG_DOMAIN_KERNEL:
3887 if (session->kernel_session != NULL) {
8ddd72ef
JR
3888 ret_code = list_lttng_kernel_events(channel_name,
3889 session->kernel_session, reply_payload, &nb_events);
2f77fc4b 3890 }
8ddd72ef 3891
2f77fc4b
DG
3892 break;
3893 case LTTNG_DOMAIN_UST:
3894 {
3895 if (session->ust_session != NULL) {
8ddd72ef 3896 ret_code = list_lttng_ust_global_events(channel_name,
e368fb43 3897 &session->ust_session->domain_global,
8ddd72ef 3898 reply_payload, &nb_events);
2f77fc4b 3899 }
8ddd72ef 3900
2f77fc4b
DG
3901 break;
3902 }
5cdb6027 3903 case LTTNG_DOMAIN_LOG4J:
3c6a091f 3904 case LTTNG_DOMAIN_JUL:
0e115563 3905 case LTTNG_DOMAIN_PYTHON:
3c6a091f 3906 if (session->ust_session) {
fefd409b
DG
3907 struct lttng_ht_iter iter;
3908 struct agent *agt;
3909
b11feea5 3910 rcu_read_lock();
fefd409b
DG
3911 cds_lfht_for_each_entry(session->ust_session->agents->ht,
3912 &iter.iter, agt, node.node) {
1dfd9906 3913 if (agt->domain == domain) {
8ddd72ef
JR
3914 ret_code = list_lttng_agent_events(
3915 agt, reply_payload, &nb_events);
1dfd9906
JG
3916 break;
3917 }
fefd409b 3918 }
8ddd72ef 3919
b11feea5 3920 rcu_read_unlock();
3c6a091f
DG
3921 }
3922 break;
2f77fc4b 3923 default:
8ddd72ef
JR
3924 ret_code = LTTNG_ERR_UND;
3925 break;
2f77fc4b
DG
3926 }
3927
8ddd72ef
JR
3928 if (nb_events > UINT32_MAX) {
3929 ret_code = LTTNG_ERR_OVERFLOW;
3930 goto end;
3931 }
e368fb43 3932
8ddd72ef
JR
3933 /* Update command reply header. */
3934 reply_command_header.count = (uint32_t) nb_events;
3935 memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
3936 sizeof(reply_command_header));
2f77fc4b 3937
8ddd72ef
JR
3938end:
3939 return ret_code;
2f77fc4b
DG
3940}
3941
3942/*
3943 * Using the session list, filled a lttng_session array to send back to the
3944 * client for session listing.
3945 *
3946 * The session list lock MUST be acquired before calling this function. Use
3947 * session_lock_list() and session_unlock_list().
3948 */
b178f53e
JG
3949void cmd_list_lttng_sessions(struct lttng_session *sessions,
3950 size_t session_count, uid_t uid, gid_t gid)
2f77fc4b
DG
3951{
3952 int ret;
3953 unsigned int i = 0;
3954 struct ltt_session *session;
3955 struct ltt_session_list *list = session_get_list();
0e270a1e 3956 struct lttng_session_extended *extended =
b178f53e 3957 (typeof(extended)) (&sessions[session_count]);
2f77fc4b
DG
3958
3959 DBG("Getting all available session for UID %d GID %d",
3960 uid, gid);
3961 /*
3962 * Iterate over session list and append data after the control struct in
3963 * the buffer.
3964 */
3965 cds_list_for_each_entry(session, &list->head, list) {
e32d7f27
JG
3966 if (!session_get(session)) {
3967 continue;
3968 }
2f77fc4b
DG
3969 /*
3970 * Only list the sessions the user can control.
3971 */
d7b377ed 3972 if (!session_access_ok(session, uid) ||
e32d7f27
JG
3973 session->destroyed) {
3974 session_put(session);
2f77fc4b
DG
3975 continue;
3976 }
3977
3978 struct ltt_kernel_session *ksess = session->kernel_session;
3979 struct ltt_ust_session *usess = session->ust_session;
3980
3981 if (session->consumer->type == CONSUMER_DST_NET ||
3982 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
3983 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
3984 ret = build_network_session_path(sessions[i].path,
dec56f6c 3985 sizeof(sessions[i].path), session);
2f77fc4b 3986 } else {
dec56f6c 3987 ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
366a9222 3988 session->consumer->dst.session_root_path);
2f77fc4b
DG
3989 }
3990 if (ret < 0) {
3991 PERROR("snprintf session path");
e32d7f27 3992 session_put(session);
2f77fc4b
DG
3993 continue;
3994 }
3995
3996 strncpy(sessions[i].name, session->name, NAME_MAX);
3997 sessions[i].name[NAME_MAX - 1] = '\0';
8382cf6f 3998 sessions[i].enabled = session->active;
2cbf8fed 3999 sessions[i].snapshot_mode = session->snapshot_mode;
8960e9cd 4000 sessions[i].live_timer_interval = session->live_timer;
b178f53e
JG
4001 extended[i].creation_time.value = (uint64_t) session->creation_time;
4002 extended[i].creation_time.is_set = 1;
2f77fc4b 4003 i++;
e32d7f27 4004 session_put(session);
2f77fc4b
DG
4005 }
4006}
4007
806e2684 4008/*
6d805429 4009 * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
d3f14b8a 4010 * ready for trace analysis (or any kind of reader) or else 1 for pending data.
806e2684 4011 */
6d805429 4012int cmd_data_pending(struct ltt_session *session)
806e2684
DG
4013{
4014 int ret;
4015 struct ltt_kernel_session *ksess = session->kernel_session;
4016 struct ltt_ust_session *usess = session->ust_session;
4017
a0377dfe 4018 LTTNG_ASSERT(session);
806e2684 4019
5c408ad8
JD
4020 DBG("Data pending for session %s", session->name);
4021
806e2684 4022 /* Session MUST be stopped to ask for data availability. */
8382cf6f 4023 if (session->active) {
806e2684
DG
4024 ret = LTTNG_ERR_SESSION_STARTED;
4025 goto error;
3a89d11a
DG
4026 } else {
4027 /*
4028 * If stopped, just make sure we've started before else the above call
4029 * will always send that there is data pending.
4030 *
4031 * The consumer assumes that when the data pending command is received,
4032 * the trace has been started before or else no output data is written
4033 * by the streams which is a condition for data pending. So, this is
4034 * *VERY* important that we don't ask the consumer before a start
4035 * trace.
4036 */
8382cf6f 4037 if (!session->has_been_started) {
3a89d11a
DG
4038 ret = 0;
4039 goto error;
4040 }
806e2684
DG
4041 }
4042
92816cc3
JG
4043 /* A rotation is still pending, we have to wait. */
4044 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
5c408ad8
JD
4045 DBG("Rotate still pending for session %s", session->name);
4046 ret = 1;
4047 goto error;
4048 }
4049
806e2684 4050 if (ksess && ksess->consumer) {
6d805429
DG
4051 ret = consumer_is_data_pending(ksess->id, ksess->consumer);
4052 if (ret == 1) {
806e2684
DG
4053 /* Data is still being extracted for the kernel. */
4054 goto error;
4055 }
4056 }
4057
4058 if (usess && usess->consumer) {
6d805429
DG
4059 ret = consumer_is_data_pending(usess->id, usess->consumer);
4060 if (ret == 1) {
806e2684
DG
4061 /* Data is still being extracted for the kernel. */
4062 goto error;
4063 }
4064 }
4065
4066 /* Data is ready to be read by a viewer */
6d805429 4067 ret = 0;
806e2684
DG
4068
4069error:
4070 return ret;
4071}
4072
6dc3064a
DG
4073/*
4074 * Command LTTNG_SNAPSHOT_ADD_OUTPUT from the lttng ctl library.
4075 *
4076 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4077 */
4078int cmd_snapshot_add_output(struct ltt_session *session,
df4f5a87 4079 const struct lttng_snapshot_output *output, uint32_t *id)
6dc3064a
DG
4080{
4081 int ret;
4082 struct snapshot_output *new_output;
4083
a0377dfe
FD
4084 LTTNG_ASSERT(session);
4085 LTTNG_ASSERT(output);
6dc3064a
DG
4086
4087 DBG("Cmd snapshot add output for session %s", session->name);
4088
4089 /*
903ef685 4090 * Can't create an output if the session is not set in no-output mode.
6dc3064a
DG
4091 */
4092 if (session->output_traces) {
903ef685 4093 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
4094 goto error;
4095 }
4096
54213acc
JG
4097 if (session->has_non_mmap_channel) {
4098 ret = LTTNG_ERR_SNAPSHOT_UNSUPPORTED;
4099 goto error;
4100 }
4101
6dc3064a
DG
4102 /* Only one output is allowed until we have the "tee" feature. */
4103 if (session->snapshot.nb_output == 1) {
4104 ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST;
4105 goto error;
4106 }
4107
4108 new_output = snapshot_output_alloc();
4109 if (!new_output) {
4110 ret = LTTNG_ERR_NOMEM;
4111 goto error;
4112 }
4113
b178f53e 4114 ret = snapshot_output_init(session, output->max_size, output->name,
6dc3064a
DG
4115 output->ctrl_url, output->data_url, session->consumer, new_output,
4116 &session->snapshot);
4117 if (ret < 0) {
4118 if (ret == -ENOMEM) {
4119 ret = LTTNG_ERR_NOMEM;
4120 } else {
4121 ret = LTTNG_ERR_INVALID;
4122 }
4123 goto free_error;
4124 }
4125
6dc3064a
DG
4126 rcu_read_lock();
4127 snapshot_add_output(&session->snapshot, new_output);
4128 if (id) {
4129 *id = new_output->id;
4130 }
4131 rcu_read_unlock();
4132
4133 return LTTNG_OK;
4134
4135free_error:
4136 snapshot_output_destroy(new_output);
4137error:
4138 return ret;
4139}
4140
4141/*
4142 * Command LTTNG_SNAPSHOT_DEL_OUTPUT from lib lttng ctl.
4143 *
4144 * Return LTTNG_OK on success or else a LTTNG_ERR code.
4145 */
4146int cmd_snapshot_del_output(struct ltt_session *session,
df4f5a87 4147 const struct lttng_snapshot_output *output)
6dc3064a
DG
4148{
4149 int ret;
eb240553 4150 struct snapshot_output *sout = NULL;
6dc3064a 4151
a0377dfe
FD
4152 LTTNG_ASSERT(session);
4153 LTTNG_ASSERT(output);
6dc3064a 4154
6dc3064a
DG
4155 rcu_read_lock();
4156
4157 /*
d3f14b8a
MD
4158 * Permission denied to create an output if the session is not
4159 * set in no output mode.
6dc3064a
DG
4160 */
4161 if (session->output_traces) {
903ef685 4162 ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
4163 goto error;
4164 }
4165
eb240553
DG
4166 if (output->id) {
4167 DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
4168 session->name);
4169 sout = snapshot_find_output_by_id(output->id, &session->snapshot);
4170 } else if (*output->name != '\0') {
4171 DBG("Cmd snapshot del output name %s for session %s", output->name,
4172 session->name);
4173 sout = snapshot_find_output_by_name(output->name, &session->snapshot);
4174 }
6dc3064a
DG
4175 if (!sout) {
4176 ret = LTTNG_ERR_INVALID;
4177 goto error;
4178 }
4179
4180 snapshot_delete_output(&session->snapshot, sout);
4181 snapshot_output_destroy(sout);
4182 ret = LTTNG_OK;
4183
4184error:
4185 rcu_read_unlock();
4186 return ret;
4187}
4188
4189/*
4190 * Command LTTNG_SNAPSHOT_LIST_OUTPUT from lib lttng ctl.
4191 *
4192 * If no output is available, outputs is untouched and 0 is returned.
4193 *
4194 * Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
4195 */
4196ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
4197 struct lttng_snapshot_output **outputs)
4198{
4199 int ret, idx = 0;
b223ca94 4200 struct lttng_snapshot_output *list = NULL;
6dc3064a
DG
4201 struct lttng_ht_iter iter;
4202 struct snapshot_output *output;
4203
a0377dfe
FD
4204 LTTNG_ASSERT(session);
4205 LTTNG_ASSERT(outputs);
6dc3064a
DG
4206
4207 DBG("Cmd snapshot list outputs for session %s", session->name);
4208
4209 /*
d3f14b8a
MD
4210 * Permission denied to create an output if the session is not
4211 * set in no output mode.
6dc3064a
DG
4212 */
4213 if (session->output_traces) {
903ef685
JG
4214 ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
4215 goto end;
6dc3064a
DG
4216 }
4217
4218 if (session->snapshot.nb_output == 0) {
4219 ret = 0;
903ef685 4220 goto end;
6dc3064a
DG
4221 }
4222
64803277 4223 list = calloc<lttng_snapshot_output>(session->snapshot.nb_output);
6dc3064a 4224 if (!list) {
b223ca94 4225 ret = -LTTNG_ERR_NOMEM;
903ef685 4226 goto end;
6dc3064a
DG
4227 }
4228
4229 /* Copy list from session to the new list object. */
b223ca94 4230 rcu_read_lock();
6dc3064a
DG
4231 cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
4232 output, node.node) {
a0377dfe 4233 LTTNG_ASSERT(output->consumer);
6dc3064a
DG
4234 list[idx].id = output->id;
4235 list[idx].max_size = output->max_size;
6ce22875
MD
4236 if (lttng_strncpy(list[idx].name, output->name,
4237 sizeof(list[idx].name))) {
4238 ret = -LTTNG_ERR_INVALID;
903ef685 4239 goto error;
6ce22875 4240 }
6dc3064a 4241 if (output->consumer->type == CONSUMER_DST_LOCAL) {
6ce22875 4242 if (lttng_strncpy(list[idx].ctrl_url,
366a9222 4243 output->consumer->dst.session_root_path,
6ce22875
MD
4244 sizeof(list[idx].ctrl_url))) {
4245 ret = -LTTNG_ERR_INVALID;
903ef685 4246 goto error;
6ce22875 4247 }
6dc3064a
DG
4248 } else {
4249 /* Control URI. */
4250 ret = uri_to_str_url(&output->consumer->dst.net.control,
4251 list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
4252 if (ret < 0) {
b223ca94 4253 ret = -LTTNG_ERR_NOMEM;
903ef685 4254 goto error;
6dc3064a
DG
4255 }
4256
4257 /* Data URI. */
4258 ret = uri_to_str_url(&output->consumer->dst.net.data,
4259 list[idx].data_url, sizeof(list[idx].data_url));
4260 if (ret < 0) {
b223ca94 4261 ret = -LTTNG_ERR_NOMEM;
903ef685 4262 goto error;
6dc3064a
DG
4263 }
4264 }
4265 idx++;
4266 }
4267
4268 *outputs = list;
b223ca94
JG
4269 list = NULL;
4270 ret = session->snapshot.nb_output;
6dc3064a 4271error:
903ef685 4272 rcu_read_unlock();
b223ca94 4273 free(list);
903ef685 4274end:
b223ca94 4275 return ret;
6dc3064a
DG
4276}
4277
93ec662e
JD
4278/*
4279 * Check if we can regenerate the metadata for this session.
4280 * Only kernel, UST per-uid and non-live sessions are supported.
4281 *
4282 * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
4283 */
4284static
eded6438 4285int check_regenerate_metadata_support(struct ltt_session *session)
93ec662e
JD
4286{
4287 int ret;
4288
a0377dfe 4289 LTTNG_ASSERT(session);
93ec662e
JD
4290
4291 if (session->live_timer != 0) {
4292 ret = LTTNG_ERR_LIVE_SESSION;
4293 goto end;
4294 }
4295 if (!session->active) {
4296 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4297 goto end;
4298 }
4299 if (session->ust_session) {
4300 switch (session->ust_session->buffer_type) {
4301 case LTTNG_BUFFER_PER_UID:
4302 break;
4303 case LTTNG_BUFFER_PER_PID:
4304 ret = LTTNG_ERR_PER_PID_SESSION;
4305 goto end;
4306 default:
a0377dfe 4307 abort();
93ec662e
JD
4308 ret = LTTNG_ERR_UNK;
4309 goto end;
4310 }
4311 }
4312 if (session->consumer->type == CONSUMER_DST_NET &&
4313 session->consumer->relay_minor_version < 8) {
4314 ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
4315 goto end;
4316 }
4317 ret = 0;
4318
4319end:
4320 return ret;
4321}
4322
93ec662e 4323/*
eded6438 4324 * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
93ec662e
JD
4325 *
4326 * Ask the consumer to truncate the existing metadata file(s) and
4327 * then regenerate the metadata. Live and per-pid sessions are not
4328 * supported and return an error.
4329 *
1136f41b 4330 * Return LTTNG_OK on success or else a LTTNG_ERR code.
93ec662e 4331 */
eded6438 4332int cmd_regenerate_metadata(struct ltt_session *session)
93ec662e
JD
4333{
4334 int ret;
4335
a0377dfe 4336 LTTNG_ASSERT(session);
93ec662e 4337
eded6438 4338 ret = check_regenerate_metadata_support(session);
93ec662e
JD
4339 if (ret) {
4340 goto end;
4341 }
4342
4343 if (session->kernel_session) {
eded6438 4344 ret = kernctl_session_regenerate_metadata(
93ec662e
JD
4345 session->kernel_session->fd);
4346 if (ret < 0) {
4347 ERR("Failed to regenerate the kernel metadata");
4348 goto end;
4349 }
4350 }
4351
4352 if (session->ust_session) {
d7bfb9b0 4353 ret = trace_ust_regenerate_metadata(session->ust_session);
93ec662e
JD
4354 if (ret < 0) {
4355 ERR("Failed to regenerate the UST metadata");
4356 goto end;
4357 }
4358 }
4359 DBG("Cmd metadata regenerate for session %s", session->name);
4360 ret = LTTNG_OK;
4361
4362end:
4363 return ret;
4364}
4365
c2561365
JD
4366/*
4367 * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
4368 *
4369 * Ask the tracer to regenerate a new statedump.
4370 *
1136f41b 4371 * Return LTTNG_OK on success or else a LTTNG_ERR code.
c2561365
JD
4372 */
4373int cmd_regenerate_statedump(struct ltt_session *session)
4374{
4375 int ret;
4376
a0377dfe 4377 LTTNG_ASSERT(session);
c2561365
JD
4378
4379 if (!session->active) {
4380 ret = LTTNG_ERR_SESSION_NOT_STARTED;
4381 goto end;
4382 }
c2561365
JD
4383
4384 if (session->kernel_session) {
4385 ret = kernctl_session_regenerate_statedump(
4386 session->kernel_session->fd);
4387 /*
4388 * Currently, the statedump in kernel can only fail if out
4389 * of memory.
4390 */
4391 if (ret < 0) {
4392 if (ret == -ENOMEM) {
4393 ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
4394 } else {
4395 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4396 }
4397 ERR("Failed to regenerate the kernel statedump");
4398 goto end;
4399 }
4400 }
4401
4402 if (session->ust_session) {
4403 ret = ust_app_regenerate_statedump_all(session->ust_session);
4404 /*
4405 * Currently, the statedump in UST always returns 0.
4406 */
4407 if (ret < 0) {
4408 ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
4409 ERR("Failed to regenerate the UST statedump");
4410 goto end;
4411 }
4412 }
4413 DBG("Cmd regenerate statedump for session %s", session->name);
4414 ret = LTTNG_OK;
4415
4416end:
4417 return ret;
4418}
4419
989a0844
FD
4420static
4421enum lttng_error_code synchronize_tracer_notifier_register(
4422 struct notification_thread_handle *notification_thread,
4423 struct lttng_trigger *trigger, const struct lttng_credentials *cmd_creds)
70670472 4424{
989a0844 4425 enum lttng_error_code ret_code;
7c1f6da2
JG
4426 const struct lttng_condition *condition =
4427 lttng_trigger_get_const_condition(trigger);
989a0844
FD
4428 const char *trigger_name;
4429 uid_t trigger_owner;
4430 enum lttng_trigger_status trigger_status;
4431 const enum lttng_domain_type trigger_domain =
4432 lttng_trigger_get_underlying_domain_type_restriction(
4433 trigger);
70670472 4434
989a0844 4435 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
a0377dfe 4436 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
989a0844 4437
a0377dfe
FD
4438 LTTNG_ASSERT(condition);
4439 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
8dbb86b8 4440 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
989a0844
FD
4441
4442 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
4443 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4444 trigger_name : "(anonymous)";
989a0844
FD
4445
4446 session_lock_list();
4447 switch (trigger_domain) {
4448 case LTTNG_DOMAIN_KERNEL:
4449 {
4450 ret_code = kernel_register_event_notifier(trigger, cmd_creds);
4451 if (ret_code != LTTNG_OK) {
4452 enum lttng_error_code notif_thread_unregister_ret;
4453
4454 notif_thread_unregister_ret =
4455 notification_thread_command_unregister_trigger(
4456 notification_thread, trigger);
4457
4458 if (notif_thread_unregister_ret != LTTNG_OK) {
4459 /* Return the original error code. */
4460 ERR("Failed to unregister trigger from notification thread during error recovery: trigger name = '%s', trigger owner uid = %d, error code = %d",
4461 trigger_name,
4462 (int) trigger_owner,
4463 ret_code);
4464 }
4465 }
4466 break;
70670472 4467 }
989a0844
FD
4468 case LTTNG_DOMAIN_UST:
4469 ust_app_global_update_all_event_notifier_rules();
4470 break;
4471 case LTTNG_DOMAIN_JUL:
4472 case LTTNG_DOMAIN_LOG4J:
4473 case LTTNG_DOMAIN_PYTHON:
4474 {
4475 /* Agent domains. */
4476 struct agent *agt = agent_find_by_event_notifier_domain(
4477 trigger_domain);
70670472 4478
989a0844
FD
4479 if (!agt) {
4480 agt = agent_create(trigger_domain);
4481 if (!agt) {
4482 ret_code = LTTNG_ERR_NOMEM;
4483 goto end_unlock_session_list;
4484 }
4485
412d7227 4486 agent_add(agt, the_trigger_agents_ht_by_domain);
989a0844
FD
4487 }
4488
7966af57 4489 ret_code = (lttng_error_code) trigger_agent_enable(trigger, agt);
989a0844
FD
4490 if (ret_code != LTTNG_OK) {
4491 goto end_unlock_session_list;
4492 }
4493
4494 break;
4495 }
4496 case LTTNG_DOMAIN_NONE:
4497 default:
4498 abort();
4499 }
4500
4501 ret_code = LTTNG_OK;
4502end_unlock_session_list:
4503 session_unlock_list();
70670472
JR
4504 return ret_code;
4505}
4506
4507enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds,
746e08d7 4508 struct lttng_trigger *trigger,
0efb2ad7 4509 bool is_trigger_anonymous,
242388e4
JR
4510 struct notification_thread_handle *notification_thread,
4511 struct lttng_trigger **return_trigger)
b0880ae5 4512{
70670472 4513 enum lttng_error_code ret_code;
70670472
JR
4514 const char *trigger_name;
4515 uid_t trigger_owner;
4516 enum lttng_trigger_status trigger_status;
4517
4518 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
ce0b1d61 4519 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4520 trigger_name : "(anonymous)";
ce0b1d61 4521
70670472
JR
4522 trigger_status = lttng_trigger_get_owner_uid(
4523 trigger, &trigger_owner);
a0377dfe 4524 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
70670472
JR
4525
4526 DBG("Running register trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4527 trigger_name, (int) trigger_owner,
4528 (int) lttng_credentials_get_uid(cmd_creds));
b0880ae5 4529
64eafdf6
JR
4530 /*
4531 * Validate the trigger credentials against the command credentials.
4532 * Only the root user can register a trigger with non-matching
4533 * credentials.
4534 */
4535 if (!lttng_credentials_is_equal_uid(
4536 lttng_trigger_get_credentials(trigger),
746e08d7
JG
4537 cmd_creds)) {
4538 if (lttng_credentials_get_uid(cmd_creds) != 0) {
70670472
JR
4539 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4540 trigger_name, (int) trigger_owner,
4541 (int) lttng_credentials_get_uid(cmd_creds));
4542 ret_code = LTTNG_ERR_INVALID_TRIGGER;
64eafdf6
JR
4543 goto end;
4544 }
4545 }
3da864a9 4546
58daac01
JR
4547 /*
4548 * The bytecode generation also serves as a validation step for the
4549 * bytecode expressions.
4550 */
70670472
JR
4551 ret_code = lttng_trigger_generate_bytecode(trigger, cmd_creds);
4552 if (ret_code != LTTNG_OK) {
4553 ERR("Failed to generate bytecode of trigger: trigger name = '%s', trigger owner uid = %d, error code = %d",
4554 trigger_name, (int) trigger_owner, ret_code);
58daac01
JR
4555 goto end;
4556 }
4557
242388e4
JR
4558 /*
4559 * A reference to the trigger is acquired by the notification thread.
4560 * It is safe to return the same trigger to the caller since it the
4561 * other user holds a reference.
4562 *
4563 * The trigger is modified during the execution of the
4564 * "register trigger" command. However, by the time the command returns,
4565 * it is safe to use without any locking as its properties are
4566 * immutable.
4567 */
0efb2ad7
JG
4568 ret_code = notification_thread_command_register_trigger(
4569 notification_thread, trigger, is_trigger_anonymous);
70670472 4570 if (ret_code != LTTNG_OK) {
ce0b1d61 4571 DBG("Failed to register trigger to notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
70670472 4572 trigger_name, (int) trigger_owner, ret_code);
44760c20 4573 goto end;
70670472
JR
4574 }
4575
ce0b1d61
JG
4576 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
4577 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4578 trigger_name : "(anonymous)";
ce0b1d61 4579
70670472
JR
4580 /*
4581 * Synchronize tracers if the trigger adds an event notifier.
4582 */
989a0844
FD
4583 if (lttng_trigger_needs_tracer_notifier(trigger)) {
4584 ret_code = synchronize_tracer_notifier_register(notification_thread,
4585 trigger, cmd_creds);
4586 if (ret_code != LTTNG_OK) {
4587 ERR("Error registering tracer notifier: %s",
4588 lttng_strerror(-ret_code));
4589 goto end;
70670472
JR
4590 }
4591 }
4592
746e08d7
JG
4593 /*
4594 * Return an updated trigger to the client.
4595 *
4596 * Since a modified version of the same trigger is returned, acquire a
4597 * reference to the trigger so the caller doesn't have to care if those
4598 * are distinct instances or not.
4599 */
39b95a70
JG
4600 if (ret_code == LTTNG_OK) {
4601 lttng_trigger_get(trigger);
4602 *return_trigger = trigger;
4603 /* Ownership of trigger was transferred to caller. */
4604 trigger = NULL;
4605 }
b0880ae5 4606end:
70670472 4607 return ret_code;
989a0844
FD
4608}
4609
4610static
4611enum lttng_error_code synchronize_tracer_notifier_unregister(
4612 const struct lttng_trigger *trigger)
4613{
4614 enum lttng_error_code ret_code;
4615 const struct lttng_condition *condition =
4616 lttng_trigger_get_const_condition(trigger);
4617 const enum lttng_domain_type trigger_domain =
4618 lttng_trigger_get_underlying_domain_type_restriction(
4619 trigger);
4620
a0377dfe
FD
4621 LTTNG_ASSERT(condition);
4622 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
8dbb86b8 4623 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
989a0844
FD
4624
4625 session_lock_list();
4626 switch (trigger_domain) {
4627 case LTTNG_DOMAIN_KERNEL:
4628 ret_code = kernel_unregister_event_notifier(trigger);
e689039f
JG
4629 if (ret_code != LTTNG_OK) {
4630 goto end_unlock_session_list;
4631 }
4632
989a0844
FD
4633 break;
4634 case LTTNG_DOMAIN_UST:
4635 ust_app_global_update_all_event_notifier_rules();
4636 break;
4637 case LTTNG_DOMAIN_JUL:
4638 case LTTNG_DOMAIN_LOG4J:
4639 case LTTNG_DOMAIN_PYTHON:
4640 {
4641 /* Agent domains. */
4642 struct agent *agt = agent_find_by_event_notifier_domain(
4643 trigger_domain);
4644
566190c4
JG
4645 /*
4646 * This trigger was never registered in the first place. Calling
4647 * this function under those circumstances is an internal error.
4648 */
a0377dfe 4649 LTTNG_ASSERT(agt);
7966af57 4650 ret_code = (lttng_error_code) trigger_agent_disable(trigger, agt);
989a0844
FD
4651 if (ret_code != LTTNG_OK) {
4652 goto end_unlock_session_list;
4653 }
4654
4655 break;
4656 }
4657 case LTTNG_DOMAIN_NONE:
4658 default:
4659 abort();
4660 }
4661
4662 ret_code = LTTNG_OK;
4663
9b7cbebd
JG
4664end_unlock_session_list:
4665 session_unlock_list();
4666 return ret_code;
b0880ae5
JG
4667}
4668
70670472 4669enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd_creds,
746e08d7 4670 const struct lttng_trigger *trigger,
b0880ae5
JG
4671 struct notification_thread_handle *notification_thread)
4672{
70670472 4673 enum lttng_error_code ret_code;
70670472
JR
4674 const char *trigger_name;
4675 uid_t trigger_owner;
4676 enum lttng_trigger_status trigger_status;
5c5373c3 4677 struct lttng_trigger *sessiond_trigger = NULL;
70670472
JR
4678
4679 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
0efb2ad7 4680 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
989a0844 4681 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
a0377dfe 4682 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
70670472
JR
4683
4684 DBG("Running unregister trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4685 trigger_name, (int) trigger_owner,
4686 (int) lttng_credentials_get_uid(cmd_creds));
b0880ae5 4687
64eafdf6
JR
4688 /*
4689 * Validate the trigger credentials against the command credentials.
4690 * Only the root user can unregister a trigger with non-matching
4691 * credentials.
4692 */
4693 if (!lttng_credentials_is_equal_uid(
4694 lttng_trigger_get_credentials(trigger),
746e08d7
JG
4695 cmd_creds)) {
4696 if (lttng_credentials_get_uid(cmd_creds) != 0) {
70670472
JR
4697 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4698 trigger_name, (int) trigger_owner,
4699 (int) lttng_credentials_get_uid(cmd_creds));
4700 ret_code = LTTNG_ERR_INVALID_TRIGGER;
64eafdf6
JR
4701 goto end;
4702 }
4703 }
3da864a9 4704
5c5373c3
JR
4705 /* Fetch the sessiond side trigger object. */
4706 ret_code = notification_thread_command_get_trigger(
4707 notification_thread, trigger, &sessiond_trigger);
4708 if (ret_code != LTTNG_OK) {
4709 DBG("Failed to get trigger from notification thread during unregister: trigger name = '%s', trigger owner uid = %d, error code = %d",
4710 trigger_name, (int) trigger_owner, ret_code);
4711 goto end;
4712 }
4713
a0377dfe 4714 LTTNG_ASSERT(sessiond_trigger);
5c5373c3
JR
4715
4716 /*
4717 * From this point on, no matter what, consider the trigger
4718 * unregistered.
4719 *
4720 * We set the unregistered state of the sessiond side trigger object in
4721 * the client thread since we want to minimize the possibility of the
4722 * notification thread being stalled due to a long execution of an
4723 * action that required the trigger lock.
4724 */
4725 lttng_trigger_set_as_unregistered(sessiond_trigger);
4726
70670472
JR
4727 ret_code = notification_thread_command_unregister_trigger(notification_thread,
4728 trigger);
4729 if (ret_code != LTTNG_OK) {
ce0b1d61 4730 DBG("Failed to unregister trigger from notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
70670472 4731 trigger_name, (int) trigger_owner, ret_code);
13839b27 4732 goto end;
70670472
JR
4733 }
4734
4735 /*
4736 * Synchronize tracers if the trigger removes an event notifier.
44760c20
JR
4737 * Do this even if the trigger unregistration failed to at least stop
4738 * the tracers from producing notifications associated with this
4739 * event notifier.
70670472 4740 */
989a0844
FD
4741 if (lttng_trigger_needs_tracer_notifier(trigger)) {
4742 ret_code = synchronize_tracer_notifier_unregister(trigger);
4743 if (ret_code != LTTNG_OK) {
4744 ERR("Error unregistering trigger to tracer.");
4745 goto end;
70670472 4746 }
9b7cbebd 4747
70670472
JR
4748 }
4749
b0880ae5 4750end:
5c5373c3 4751 lttng_trigger_put(sessiond_trigger);
70670472 4752 return ret_code;
989a0844 4753}
b0880ae5 4754
ddd915a3 4755enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx,
fbc9f37d
JR
4756 struct notification_thread_handle *notification_thread,
4757 struct lttng_triggers **return_triggers)
4758{
f2bda80e 4759 int ret;
fbc9f37d
JR
4760 enum lttng_error_code ret_code;
4761 struct lttng_triggers *triggers = NULL;
4762
4763 /* Get the set of triggers from the notification thread. */
4764 ret_code = notification_thread_command_list_triggers(
4765 notification_thread, cmd_ctx->creds.uid, &triggers);
4766 if (ret_code != LTTNG_OK) {
fbc9f37d
JR
4767 goto end;
4768 }
4769
f2bda80e
JG
4770 ret = lttng_triggers_remove_hidden_triggers(triggers);
4771 if (ret) {
4772 ret_code = LTTNG_ERR_UNK;
4773 goto end;
4774 }
4775
fbc9f37d
JR
4776 *return_triggers = triggers;
4777 triggers = NULL;
ddd915a3 4778 ret_code = LTTNG_OK;
fbc9f37d
JR
4779end:
4780 lttng_triggers_destroy(triggers);
ddd915a3 4781 return ret_code;
fbc9f37d 4782}
588c4b0d
JG
4783
4784enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cmd_creds,
4785 const struct lttng_error_query *query,
4786 struct lttng_error_query_results **_results,
4787 struct notification_thread_handle *notification_thread)
4788{
4789 enum lttng_error_code ret_code;
4790 const struct lttng_trigger *query_target_trigger;
63dd3d7b 4791 const struct lttng_action *query_target_action = NULL;
588c4b0d
JG
4792 struct lttng_trigger *matching_trigger = NULL;
4793 const char *trigger_name;
4794 uid_t trigger_owner;
4795 enum lttng_trigger_status trigger_status;
4796 struct lttng_error_query_results *results = NULL;
4797
4798 switch (lttng_error_query_get_target_type(query)) {
4799 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
4800 query_target_trigger = lttng_error_query_trigger_borrow_target(query);
4801 break;
63dd3d7b
JG
4802 case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
4803 query_target_trigger =
4804 lttng_error_query_condition_borrow_target(query);
4805 break;
588c4b0d
JG
4806 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
4807 query_target_trigger = lttng_error_query_action_borrow_trigger_target(
4808 query);
4809 break;
4810 default:
4811 abort();
4812 }
4813
a0377dfe 4814 LTTNG_ASSERT(query_target_trigger);
588c4b0d
JG
4815
4816 ret_code = notification_thread_command_get_trigger(notification_thread,
4817 query_target_trigger, &matching_trigger);
4818 if (ret_code != LTTNG_OK) {
4819 goto end;
4820 }
4821
4822 /* No longer needed. */
4823 query_target_trigger = NULL;
4824
4825 if (lttng_error_query_get_target_type(query) ==
4826 LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION) {
4827 /* Get the sessiond-side version of the target action. */
4828 query_target_action =
4829 lttng_error_query_action_borrow_action_target(
4830 query, matching_trigger);
4831 }
4832
4833 trigger_status = lttng_trigger_get_name(matching_trigger, &trigger_name);
4834 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
0efb2ad7 4835 trigger_name : "(anonymous)";
588c4b0d
JG
4836 trigger_status = lttng_trigger_get_owner_uid(matching_trigger,
4837 &trigger_owner);
a0377dfe 4838 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
588c4b0d
JG
4839
4840 results = lttng_error_query_results_create();
4841 if (!results) {
4842 ret_code = LTTNG_ERR_NOMEM;
4843 goto end;
4844 }
4845
4846 DBG("Running \"execute error query\" command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4847 trigger_name, (int) trigger_owner,
4848 (int) lttng_credentials_get_uid(cmd_creds));
4849
4850 /*
4851 * Validate the trigger credentials against the command credentials.
4852 * Only the root user can target a trigger with non-matching
4853 * credentials.
4854 */
4855 if (!lttng_credentials_is_equal_uid(
4856 lttng_trigger_get_credentials(matching_trigger),
4857 cmd_creds)) {
4858 if (lttng_credentials_get_uid(cmd_creds) != 0) {
4859 ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
4860 trigger_name, (int) trigger_owner,
4861 (int) lttng_credentials_get_uid(cmd_creds));
4862 ret_code = LTTNG_ERR_INVALID_TRIGGER;
4863 goto end;
4864 }
4865 }
4866
4867 switch (lttng_error_query_get_target_type(query)) {
4868 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
4869 trigger_status = lttng_trigger_add_error_results(
4870 matching_trigger, results);
4871
4872 switch (trigger_status) {
4873 case LTTNG_TRIGGER_STATUS_OK:
4874 break;
4875 default:
4876 ret_code = LTTNG_ERR_UNK;
4877 goto end;
4878 }
4879
4880 break;
63dd3d7b
JG
4881 case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
4882 {
4883 trigger_status = lttng_trigger_condition_add_error_results(
4884 matching_trigger, results);
4885
4886 switch (trigger_status) {
4887 case LTTNG_TRIGGER_STATUS_OK:
4888 break;
4889 default:
4890 ret_code = LTTNG_ERR_UNK;
4891 goto end;
4892 }
4893
4894 break;
4895 }
588c4b0d
JG
4896 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
4897 {
4898 const enum lttng_action_status action_status =
4899 lttng_action_add_error_query_results(
4900 query_target_action, results);
4901
4902 switch (action_status) {
4903 case LTTNG_ACTION_STATUS_OK:
4904 break;
4905 default:
4906 ret_code = LTTNG_ERR_UNK;
4907 goto end;
4908 }
4909
4910 break;
4911 }
4912 default:
ef4cf1d2 4913 abort();
588c4b0d
JG
4914 break;
4915 }
4916
4917 *_results = results;
4918 results = NULL;
4919 ret_code = LTTNG_OK;
4920end:
4921 lttng_trigger_put(matching_trigger);
4922 lttng_error_query_results_destroy(results);
4923 return ret_code;
4924}
4925
6dc3064a
DG
4926/*
4927 * Send relayd sockets from snapshot output to consumer. Ignore request if the
4928 * snapshot output is *not* set with a remote destination.
4929 *
9a654598 4930 * Return LTTNG_OK on success or a LTTNG_ERR code.
6dc3064a 4931 */
9a654598 4932static enum lttng_error_code set_relayd_for_snapshot(
348a81dc 4933 struct consumer_output *output,
fb9a95c4 4934 const struct ltt_session *session)
6dc3064a 4935{
9a654598 4936 enum lttng_error_code status = LTTNG_OK;
6dc3064a
DG
4937 struct lttng_ht_iter iter;
4938 struct consumer_socket *socket;
1e791a74 4939 LTTNG_OPTIONAL(uint64_t) current_chunk_id = {};
6fa5fe7c 4940 const char *base_path;
6dc3064a 4941
a0377dfe
FD
4942 LTTNG_ASSERT(output);
4943 LTTNG_ASSERT(session);
6dc3064a
DG
4944
4945 DBG2("Set relayd object from snapshot output");
4946
1e791a74 4947 if (session->current_trace_chunk) {
348a81dc
JG
4948 enum lttng_trace_chunk_status chunk_status =
4949 lttng_trace_chunk_get_id(
4950 session->current_trace_chunk,
4951 &current_chunk_id.value);
1e791a74 4952
348a81dc 4953 if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) {
1e791a74
JG
4954 current_chunk_id.is_set = true;
4955 } else {
4956 ERR("Failed to get current trace chunk id");
4957 status = LTTNG_ERR_UNK;
4958 goto error;
4959 }
4960 }
4961
6dc3064a 4962 /* Ignore if snapshot consumer output is not network. */
348a81dc 4963 if (output->type != CONSUMER_DST_NET) {
6dc3064a
DG
4964 goto error;
4965 }
4966
6fa5fe7c
MD
4967 /*
4968 * The snapshot record URI base path overrides the session
4969 * base path.
4970 */
4971 if (output->dst.net.control.subdir[0] != '\0') {
4972 base_path = output->dst.net.control.subdir;
4973 } else {
4974 base_path = session->base_path;
4975 }
4976
6dc3064a
DG
4977 /*
4978 * For each consumer socket, create and send the relayd object of the
4979 * snapshot output.
4980 */
4981 rcu_read_lock();
348a81dc 4982 cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
5eecee74 4983 socket, node.node) {
ecd0f96d 4984 pthread_mutex_lock(socket->lock);
f46376a1 4985 status = send_consumer_relayd_sockets(session->id,
348a81dc 4986 output, socket,
d3e2ba59 4987 session->name, session->hostname,
6fa5fe7c 4988 base_path,
1e791a74 4989 session->live_timer,
db1da059 4990 current_chunk_id.is_set ? &current_chunk_id.value : NULL,
46ef2188
MD
4991 session->creation_time,
4992 session->name_contains_creation_time);
ecd0f96d 4993 pthread_mutex_unlock(socket->lock);
9a654598 4994 if (status != LTTNG_OK) {
6dc3064a
DG
4995 rcu_read_unlock();
4996 goto error;
4997 }
4998 }
4999 rcu_read_unlock();
5000
5001error:
9a654598 5002 return status;
6dc3064a
DG
5003}
5004
5005/*
5006 * Record a kernel snapshot.
5007 *
fac41e72 5008 * Return LTTNG_OK on success or a LTTNG_ERR code.
6dc3064a 5009 */
fb9a95c4
JG
5010static enum lttng_error_code record_kernel_snapshot(
5011 struct ltt_kernel_session *ksess,
348a81dc 5012 const struct consumer_output *output,
fb9a95c4 5013 const struct ltt_session *session,
f46376a1 5014 uint64_t nb_packets_per_stream)
6dc3064a 5015{
9a654598 5016 enum lttng_error_code status;
6dc3064a 5017
a0377dfe
FD
5018 LTTNG_ASSERT(ksess);
5019 LTTNG_ASSERT(output);
5020 LTTNG_ASSERT(session);
6dc3064a 5021
348a81dc 5022 status = kernel_snapshot_record(
f46376a1 5023 ksess, output, nb_packets_per_stream);
9a654598 5024 return status;
6dc3064a
DG
5025}
5026
5027/*
5028 * Record a UST snapshot.
5029 *
9a654598 5030 * Returns LTTNG_OK on success or a LTTNG_ERR error code.
6dc3064a 5031 */
9a654598 5032static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
348a81dc
JG
5033 const struct consumer_output *output,
5034 const struct ltt_session *session,
f46376a1 5035 uint64_t nb_packets_per_stream)
6dc3064a 5036{
9a654598 5037 enum lttng_error_code status;
6dc3064a 5038
a0377dfe
FD
5039 LTTNG_ASSERT(usess);
5040 LTTNG_ASSERT(output);
5041 LTTNG_ASSERT(session);
6dc3064a 5042
348a81dc 5043 status = ust_app_snapshot_record(
f46376a1 5044 usess, output, nb_packets_per_stream);
9a654598 5045 return status;
6dc3064a
DG
5046}
5047
d07ceecd 5048static
fb9a95c4
JG
5049uint64_t get_session_size_one_more_packet_per_stream(
5050 const struct ltt_session *session, uint64_t cur_nr_packets)
68808f4e 5051{
d07ceecd 5052 uint64_t tot_size = 0;
68808f4e
DG
5053
5054 if (session->kernel_session) {
5055 struct ltt_kernel_channel *chan;
fb9a95c4
JG
5056 const struct ltt_kernel_session *ksess =
5057 session->kernel_session;
68808f4e 5058
68808f4e 5059 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
d07ceecd
MD
5060 if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
5061 /*
5062 * Don't take channel into account if we
5063 * already grab all its packets.
5064 */
5065 continue;
68808f4e 5066 }
d07ceecd
MD
5067 tot_size += chan->channel->attr.subbuf_size
5068 * chan->stream_count;
68808f4e
DG
5069 }
5070 }
5071
5072 if (session->ust_session) {
fb9a95c4 5073 const struct ltt_ust_session *usess = session->ust_session;
68808f4e 5074
d07ceecd
MD
5075 tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
5076 cur_nr_packets);
68808f4e
DG
5077 }
5078
d07ceecd 5079 return tot_size;
68808f4e
DG
5080}
5081
5c786ded 5082/*
d07ceecd
MD
5083 * Calculate the number of packets we can grab from each stream that
5084 * fits within the overall snapshot max size.
5085 *
5086 * Returns -1 on error, 0 means infinite number of packets, else > 0 is
5087 * the number of packets per stream.
5088 *
5089 * TODO: this approach is not perfect: we consider the worse case
5090 * (packet filling the sub-buffers) as an upper bound, but we could do
5091 * better if we do this calculation while we actually grab the packet
5092 * content: we would know how much padding we don't actually store into
5093 * the file.
5094 *
5095 * This algorithm is currently bounded by the number of packets per
5096 * stream.
5097 *
5098 * Since we call this algorithm before actually grabbing the data, it's
5099 * an approximation: for instance, applications could appear/disappear
5100 * in between this call and actually grabbing data.
5c786ded 5101 */
d07ceecd 5102static
fb9a95c4
JG
5103int64_t get_session_nb_packets_per_stream(const struct ltt_session *session,
5104 uint64_t max_size)
5c786ded 5105{
d07ceecd
MD
5106 int64_t size_left;
5107 uint64_t cur_nb_packets = 0;
5c786ded 5108
d07ceecd
MD
5109 if (!max_size) {
5110 return 0; /* Infinite */
5c786ded
JD
5111 }
5112
d07ceecd
MD
5113 size_left = max_size;
5114 for (;;) {
5115 uint64_t one_more_packet_tot_size;
5c786ded 5116
fb9a95c4
JG
5117 one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(
5118 session, cur_nb_packets);
d07ceecd
MD
5119 if (!one_more_packet_tot_size) {
5120 /* We are already grabbing all packets. */
5121 break;
5122 }
5123 size_left -= one_more_packet_tot_size;
5124 if (size_left < 0) {
5125 break;
5126 }
5127 cur_nb_packets++;
5c786ded 5128 }
aecf2da5 5129 if (!cur_nb_packets && size_left != max_size) {
d07ceecd
MD
5130 /* Not enough room to grab one packet of each stream, error. */
5131 return -1;
5132 }
5133 return cur_nb_packets;
5c786ded
JD
5134}
5135
fb9a95c4 5136static
d2956687 5137enum lttng_error_code snapshot_record(struct ltt_session *session,
f46376a1 5138 const struct snapshot_output *snapshot_output)
fb9a95c4
JG
5139{
5140 int64_t nb_packets_per_stream;
d2956687 5141 char snapshot_chunk_name[LTTNG_NAME_MAX];
348a81dc
JG
5142 int ret;
5143 enum lttng_error_code ret_code = LTTNG_OK;
d2956687 5144 struct lttng_trace_chunk *snapshot_trace_chunk;
348a81dc
JG
5145 struct consumer_output *original_ust_consumer_output = NULL;
5146 struct consumer_output *original_kernel_consumer_output = NULL;
5147 struct consumer_output *snapshot_ust_consumer_output = NULL;
5148 struct consumer_output *snapshot_kernel_consumer_output = NULL;
d2956687 5149
348a81dc 5150 ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
d2956687
JG
5151 "%s-%s-%" PRIu64,
5152 snapshot_output->name,
5153 snapshot_output->datetime,
5154 snapshot_output->nb_snapshot);
348a81dc 5155 if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) {
d2956687 5156 ERR("Failed to format snapshot name");
348a81dc
JG
5157 ret_code = LTTNG_ERR_INVALID;
5158 goto error;
d2956687
JG
5159 }
5160 DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"",
5161 snapshot_output->name, session->name,
5162 snapshot_chunk_name);
348a81dc
JG
5163 if (!session->kernel_session && !session->ust_session) {
5164 ERR("Failed to record snapshot as no channels exist");
5165 ret_code = LTTNG_ERR_NO_CHANNEL;
5166 goto error;
5167 }
5168
5169 if (session->kernel_session) {
5170 original_kernel_consumer_output =
5171 session->kernel_session->consumer;
5172 snapshot_kernel_consumer_output =
5173 consumer_copy_output(snapshot_output->consumer);
3b967712
MD
5174 strcpy(snapshot_kernel_consumer_output->chunk_path,
5175 snapshot_chunk_name);
bd666153
JR
5176
5177 /* Copy the original domain subdir. */
5178 strcpy(snapshot_kernel_consumer_output->domain_subdir,
5179 original_kernel_consumer_output->domain_subdir);
5180
348a81dc
JG
5181 ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
5182 original_kernel_consumer_output);
5183 if (ret < 0) {
5184 ERR("Failed to copy consumer sockets from snapshot output configuration");
5185 ret_code = LTTNG_ERR_NOMEM;
5186 goto error;
5187 }
5188 ret_code = set_relayd_for_snapshot(
5189 snapshot_kernel_consumer_output, session);
5190 if (ret_code != LTTNG_OK) {
5191 ERR("Failed to setup relay daemon for kernel tracer snapshot");
5192 goto error;
5193 }
5194 session->kernel_session->consumer =
5195 snapshot_kernel_consumer_output;
5196 }
5197 if (session->ust_session) {
5198 original_ust_consumer_output = session->ust_session->consumer;
5199 snapshot_ust_consumer_output =
5200 consumer_copy_output(snapshot_output->consumer);
3b967712
MD
5201 strcpy(snapshot_ust_consumer_output->chunk_path,
5202 snapshot_chunk_name);
bd666153
JR
5203
5204 /* Copy the original domain subdir. */
5205 strcpy(snapshot_ust_consumer_output->domain_subdir,
5206 original_ust_consumer_output->domain_subdir);
5207
348a81dc
JG
5208 ret = consumer_copy_sockets(snapshot_ust_consumer_output,
5209 original_ust_consumer_output);
5210 if (ret < 0) {
5211 ERR("Failed to copy consumer sockets from snapshot output configuration");
5212 ret_code = LTTNG_ERR_NOMEM;
5213 goto error;
5214 }
5215 ret_code = set_relayd_for_snapshot(
5216 snapshot_ust_consumer_output, session);
5217 if (ret_code != LTTNG_OK) {
5218 ERR("Failed to setup relay daemon for userspace tracer snapshot");
5219 goto error;
5220 }
5221 session->ust_session->consumer =
5222 snapshot_ust_consumer_output;
5223 }
5224
d2956687 5225 snapshot_trace_chunk = session_create_new_trace_chunk(session,
348a81dc
JG
5226 snapshot_kernel_consumer_output ?:
5227 snapshot_ust_consumer_output,
5228 consumer_output_get_base_path(
5229 snapshot_output->consumer),
d2956687
JG
5230 snapshot_chunk_name);
5231 if (!snapshot_trace_chunk) {
348a81dc
JG
5232 ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"",
5233 session->name);
5234 ret_code = LTTNG_ERR_CREATE_DIR_FAIL;
5235 goto error;
d2956687 5236 }
a0377dfe 5237 LTTNG_ASSERT(!session->current_trace_chunk);
d2956687
JG
5238 ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL);
5239 lttng_trace_chunk_put(snapshot_trace_chunk);
5240 snapshot_trace_chunk = NULL;
5241 if (ret) {
348a81dc
JG
5242 ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"",
5243 session->name);
5244 ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
5245 goto error;
d2956687 5246 }
fb9a95c4
JG
5247
5248 nb_packets_per_stream = get_session_nb_packets_per_stream(session,
5249 snapshot_output->max_size);
5250 if (nb_packets_per_stream < 0) {
348a81dc 5251 ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
5151d412 5252 goto error_close_trace_chunk;
fb9a95c4
JG
5253 }
5254
5255 if (session->kernel_session) {
348a81dc
JG
5256 ret_code = record_kernel_snapshot(session->kernel_session,
5257 snapshot_kernel_consumer_output, session,
f46376a1 5258 nb_packets_per_stream);
348a81dc 5259 if (ret_code != LTTNG_OK) {
5151d412 5260 goto error_close_trace_chunk;
fb9a95c4
JG
5261 }
5262 }
5263
5264 if (session->ust_session) {
348a81dc
JG
5265 ret_code = record_ust_snapshot(session->ust_session,
5266 snapshot_ust_consumer_output, session,
f46376a1 5267 nb_packets_per_stream);
348a81dc 5268 if (ret_code != LTTNG_OK) {
5151d412 5269 goto error_close_trace_chunk;
fb9a95c4
JG
5270 }
5271 }
d2956687 5272
5151d412 5273error_close_trace_chunk:
dbfee52c
MD
5274 if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) {
5275 ERR("Failed to release the current trace chunk of session \"%s\"",
5276 session->name);
5277 ret_code = LTTNG_ERR_UNK;
5278 }
5279
5280 if (session_close_trace_chunk(session, snapshot_trace_chunk,
343defc2 5281 LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION, NULL)) {
d2956687
JG
5282 /*
5283 * Don't goto end; make sure the chunk is closed for the session
5284 * to allow future snapshots.
5285 */
5286 ERR("Failed to close snapshot trace chunk of session \"%s\"",
5287 session->name);
348a81dc 5288 ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
d2956687 5289 }
a49a9216
JG
5290
5291 lttng_trace_chunk_put(snapshot_trace_chunk);
5292 snapshot_trace_chunk = NULL;
348a81dc
JG
5293error:
5294 if (original_ust_consumer_output) {
5295 session->ust_session->consumer = original_ust_consumer_output;
5296 }
5297 if (original_kernel_consumer_output) {
5298 session->kernel_session->consumer =
5299 original_kernel_consumer_output;
5300 }
5301 consumer_output_put(snapshot_ust_consumer_output);
5302 consumer_output_put(snapshot_kernel_consumer_output);
5303 return ret_code;
fb9a95c4
JG
5304}
5305
6dc3064a
DG
5306/*
5307 * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl.
5308 *
5309 * The wait parameter is ignored so this call always wait for the snapshot to
5310 * complete before returning.
5311 *
5312 * Return LTTNG_OK on success or else a LTTNG_ERR code.
5313 */
5314int cmd_snapshot_record(struct ltt_session *session,
f46376a1
MJ
5315 const struct lttng_snapshot_output *output,
5316 int wait __attribute__((unused)))
6dc3064a 5317{
9a654598
JG
5318 enum lttng_error_code cmd_ret = LTTNG_OK;
5319 int ret;
00e1dfc4 5320 unsigned int snapshot_success = 0;
10ba83fe 5321 char datetime[16];
2abe7969 5322 struct snapshot_output *tmp_output = NULL;
6dc3064a 5323
a0377dfe
FD
5324 LTTNG_ASSERT(session);
5325 LTTNG_ASSERT(output);
6dc3064a
DG
5326
5327 DBG("Cmd snapshot record for session %s", session->name);
5328
10ba83fe
JR
5329 /* Get the datetime for the snapshot output directory. */
5330 ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
5331 sizeof(datetime));
5332 if (!ret) {
9a654598 5333 cmd_ret = LTTNG_ERR_INVALID;
10ba83fe
JR
5334 goto error;
5335 }
5336
6dc3064a 5337 /*
d3f14b8a
MD
5338 * Permission denied to create an output if the session is not
5339 * set in no output mode.
6dc3064a
DG
5340 */
5341 if (session->output_traces) {
9a654598 5342 cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
6dc3064a
DG
5343 goto error;
5344 }
5345
5346 /* The session needs to be started at least once. */
8382cf6f 5347 if (!session->has_been_started) {
9a654598 5348 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
6dc3064a
DG
5349 goto error;
5350 }
5351
5352 /* Use temporary output for the session. */
ba45d9f0 5353 if (*output->ctrl_url != '\0') {
2abe7969
JG
5354 tmp_output = snapshot_output_alloc();
5355 if (!tmp_output) {
5356 cmd_ret = LTTNG_ERR_NOMEM;
5357 goto error;
5358 }
5359
b178f53e
JG
5360 ret = snapshot_output_init(session, output->max_size,
5361 output->name,
5362 output->ctrl_url, output->data_url,
5363 session->consumer,
2abe7969 5364 tmp_output, NULL);
6dc3064a
DG
5365 if (ret < 0) {
5366 if (ret == -ENOMEM) {
9a654598 5367 cmd_ret = LTTNG_ERR_NOMEM;
6dc3064a 5368 } else {
9a654598 5369 cmd_ret = LTTNG_ERR_INVALID;
6dc3064a
DG
5370 }
5371 goto error;
5372 }
1bfe7328 5373 /* Use the global session count for the temporary snapshot. */
2abe7969 5374 tmp_output->nb_snapshot = session->snapshot.nb_snapshot;
10ba83fe
JR
5375
5376 /* Use the global datetime */
2abe7969 5377 memcpy(tmp_output->datetime, datetime, sizeof(datetime));
f46376a1 5378 cmd_ret = snapshot_record(session, tmp_output);
fb9a95c4 5379 if (cmd_ret != LTTNG_OK) {
804c90a8
JR
5380 goto error;
5381 }
804c90a8
JR
5382 snapshot_success = 1;
5383 } else {
5384 struct snapshot_output *sout;
5385 struct lttng_ht_iter iter;
68808f4e 5386
804c90a8
JR
5387 rcu_read_lock();
5388 cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
5389 &iter.iter, sout, node.node) {
2abe7969
JG
5390 struct snapshot_output output_copy;
5391
804c90a8 5392 /*
2abe7969
JG
5393 * Make a local copy of the output and override output
5394 * parameters with those provided as part of the
5395 * command.
804c90a8 5396 */
2abe7969 5397 memcpy(&output_copy, sout, sizeof(output_copy));
1bfe7328 5398
804c90a8 5399 if (output->max_size != (uint64_t) -1ULL) {
2abe7969 5400 output_copy.max_size = output->max_size;
6dc3064a 5401 }
d07ceecd 5402
2abe7969
JG
5403 output_copy.nb_snapshot = session->snapshot.nb_snapshot;
5404 memcpy(output_copy.datetime, datetime,
5405 sizeof(datetime));
6dc3064a 5406
804c90a8
JR
5407 /* Use temporary name. */
5408 if (*output->name != '\0') {
2abe7969
JG
5409 if (lttng_strncpy(output_copy.name,
5410 output->name,
5411 sizeof(output_copy.name))) {
9a654598 5412 cmd_ret = LTTNG_ERR_INVALID;
cf3e357d
MD
5413 rcu_read_unlock();
5414 goto error;
5415 }
804c90a8 5416 }
e1986656 5417
f46376a1 5418 cmd_ret = snapshot_record(session, &output_copy);
fb9a95c4
JG
5419 if (cmd_ret != LTTNG_OK) {
5420 rcu_read_unlock();
5421 goto error;
6dc3064a 5422 }
804c90a8 5423 snapshot_success = 1;
6dc3064a 5424 }
804c90a8 5425 rcu_read_unlock();
6dc3064a
DG
5426 }
5427
1bfe7328
DG
5428 if (snapshot_success) {
5429 session->snapshot.nb_snapshot++;
b67578cb 5430 } else {
9a654598 5431 cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL;
1bfe7328
DG
5432 }
5433
6dc3064a 5434error:
2abe7969
JG
5435 if (tmp_output) {
5436 snapshot_output_destroy(tmp_output);
5437 }
9a654598 5438 return cmd_ret;
6dc3064a
DG
5439}
5440
d7ba1388
MD
5441/*
5442 * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
5443 */
5444int cmd_set_session_shm_path(struct ltt_session *session,
5445 const char *shm_path)
5446{
5447 /* Safety net */
a0377dfe 5448 LTTNG_ASSERT(session);
d7ba1388
MD
5449
5450 /*
5451 * Can only set shm path before session is started.
5452 */
5453 if (session->has_been_started) {
5454 return LTTNG_ERR_SESSION_STARTED;
5455 }
5456
5457 strncpy(session->shm_path, shm_path,
5458 sizeof(session->shm_path));
5459 session->shm_path[sizeof(session->shm_path) - 1] = '\0';
5460
7e397c55 5461 return LTTNG_OK;
d7ba1388
MD
5462}
5463
5c408ad8
JD
5464/*
5465 * Command LTTNG_ROTATE_SESSION from the lttng-ctl library.
5466 *
5467 * Ask the consumer to rotate the session output directory.
5468 * The session lock must be held.
5469 *
d5a1b7aa 5470 * Returns LTTNG_OK on success or else a negative LTTng error code.
5c408ad8
JD
5471 */
5472int cmd_rotate_session(struct ltt_session *session,
7fdbed1c 5473 struct lttng_rotate_session_return *rotate_return,
343defc2
MD
5474 bool quiet_rotation,
5475 enum lttng_trace_chunk_command_type command)
5c408ad8
JD
5476{
5477 int ret;
d2956687 5478 uint64_t ongoing_rotation_chunk_id;
d5a1b7aa 5479 enum lttng_error_code cmd_ret = LTTNG_OK;
d2956687
JG
5480 struct lttng_trace_chunk *chunk_being_archived = NULL;
5481 struct lttng_trace_chunk *new_trace_chunk = NULL;
5482 enum lttng_trace_chunk_status chunk_status;
3156892b
JG
5483 bool failed_to_rotate = false;
5484 enum lttng_error_code rotation_fail_code = LTTNG_OK;
5c408ad8 5485
a0377dfe 5486 LTTNG_ASSERT(session);
5c408ad8
JD
5487
5488 if (!session->has_been_started) {
d5a1b7aa 5489 cmd_ret = LTTNG_ERR_START_SESSION_ONCE;
d68c9a04 5490 goto end;
5c408ad8
JD
5491 }
5492
d48d65e1
MD
5493 /*
5494 * Explicit rotation is not supported for live sessions.
5495 * However, live sessions can perform a quiet rotation on
5496 * destroy.
5497 * Rotation is not supported for snapshot traces (no output).
5498 */
5499 if ((!quiet_rotation && session->live_timer) ||
5500 !session->output_traces) {
d5a1b7aa 5501 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
d68c9a04 5502 goto end;
5c408ad8
JD
5503 }
5504
d2956687 5505 /* Unsupported feature in lttng-relayd before 2.11. */
070b6a86 5506 if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET &&
5c408ad8
JD
5507 (session->consumer->relay_major_version == 2 &&
5508 session->consumer->relay_minor_version < 11)) {
d5a1b7aa 5509 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
d68c9a04 5510 goto end;
5c408ad8
JD
5511 }
5512
a40a503f
MD
5513 /* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */
5514 if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) {
5515 cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL;
5516 goto end;
5517 }
5518
92816cc3 5519 if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
92816cc3
JG
5520 DBG("Refusing to launch a rotation; a rotation is already in progress for session %s",
5521 session->name);
d5a1b7aa 5522 cmd_ret = LTTNG_ERR_ROTATION_PENDING;
d68c9a04 5523 goto end;
5c408ad8
JD
5524 }
5525
5526 /*
5527 * After a stop, we only allow one rotation to occur, the other ones are
5528 * useless until a new start.
5529 */
5530 if (session->rotated_after_last_stop) {
5531 DBG("Session \"%s\" was already rotated after stop, refusing rotation",
5532 session->name);
d5a1b7aa 5533 cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
d68c9a04 5534 goto end;
5c408ad8 5535 }
b02f5986
MD
5536
5537 /*
5538 * After a stop followed by a clear, disallow following rotations a they would
5539 * generate empty chunks.
5540 */
5541 if (session->cleared_after_last_stop) {
5542 DBG("Session \"%s\" was already cleared after stop, refusing rotation",
5543 session->name);
5544 cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR;
5545 goto end;
5546 }
5547
d2956687 5548 if (session->active) {
348a81dc 5549 new_trace_chunk = session_create_new_trace_chunk(session, NULL,
d2956687
JG
5550 NULL, NULL);
5551 if (!new_trace_chunk) {
5552 cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
5553 goto error;
5c408ad8 5554 }
0e270a1e 5555 }
2961f09e 5556
3156892b
JG
5557 /*
5558 * The current trace chunk becomes the chunk being archived.
5559 *
5560 * After this point, "chunk_being_archived" must absolutely
5561 * be closed on the consumer(s), otherwise it will never be
5562 * cleaned-up, which will result in a leak.
5563 */
d2956687
JG
5564 ret = session_set_trace_chunk(session, new_trace_chunk,
5565 &chunk_being_archived);
5566 if (ret) {
5567 cmd_ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
b178f53e
JG
5568 goto error;
5569 }
5570
5c408ad8 5571 if (session->kernel_session) {
d5a1b7aa
JG
5572 cmd_ret = kernel_rotate_session(session);
5573 if (cmd_ret != LTTNG_OK) {
3156892b
JG
5574 failed_to_rotate = true;
5575 rotation_fail_code = cmd_ret;
5c408ad8
JD
5576 }
5577 }
5578 if (session->ust_session) {
d5a1b7aa
JG
5579 cmd_ret = ust_app_rotate_session(session);
5580 if (cmd_ret != LTTNG_OK) {
3156892b
JG
5581 failed_to_rotate = true;
5582 rotation_fail_code = cmd_ret;
5c408ad8 5583 }
92816cc3 5584 }
17dd1232 5585
3b61d9ee
JG
5586 if (!session->active) {
5587 session->rotated_after_last_stop = true;
5588 }
5589
5590 if (!chunk_being_archived) {
5591 DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check",
5592 session->name);
5593 if (failed_to_rotate) {
5594 cmd_ret = rotation_fail_code;
5595 goto error;
5596 }
5597 cmd_ret = LTTNG_OK;
5598 goto end;
5599 }
5600
5601 session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
5602 chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
5603 &ongoing_rotation_chunk_id);
a0377dfe 5604 LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
3b61d9ee 5605
bbc4768c 5606 ret = session_close_trace_chunk(session, chunk_being_archived,
343defc2 5607 command, session->last_chunk_path);
d2956687
JG
5608 if (ret) {
5609 cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
5610 goto error;
5611 }
5612
3156892b
JG
5613 if (failed_to_rotate) {
5614 cmd_ret = rotation_fail_code;
5615 goto error;
5616 }
5617
7fdbed1c 5618 session->quiet_rotation = quiet_rotation;
92816cc3
JG
5619 ret = timer_session_rotation_pending_check_start(session,
5620 DEFAULT_ROTATE_PENDING_TIMER);
5621 if (ret) {
d5a1b7aa 5622 cmd_ret = LTTNG_ERR_UNK;
2961f09e 5623 goto error;
5c408ad8
JD
5624 }
5625
5c408ad8 5626 if (rotate_return) {
d2956687 5627 rotate_return->rotation_id = ongoing_rotation_chunk_id;
5c408ad8
JD
5628 }
5629
d2956687
JG
5630 session->chunk_being_archived = chunk_being_archived;
5631 chunk_being_archived = NULL;
7fdbed1c
JG
5632 if (!quiet_rotation) {
5633 ret = notification_thread_command_session_rotation_ongoing(
139a8d25 5634 the_notification_thread_handle, session->id,
7fdbed1c
JG
5635 ongoing_rotation_chunk_id);
5636 if (ret != LTTNG_OK) {
5637 ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",
5638 session->name);
7966af57 5639 cmd_ret = (lttng_error_code) ret;
7fdbed1c 5640 }
2961f09e
JG
5641 }
5642
92816cc3 5643 DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent",
d2956687 5644 session->name, ongoing_rotation_chunk_id);
5c408ad8 5645end:
d2956687
JG
5646 lttng_trace_chunk_put(new_trace_chunk);
5647 lttng_trace_chunk_put(chunk_being_archived);
d5a1b7aa 5648 ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret);
5c408ad8 5649 return ret;
2961f09e 5650error:
2961f09e 5651 if (session_reset_rotation_state(session,
d2956687 5652 LTTNG_ROTATION_STATE_ERROR)) {
2961f09e
JG
5653 ERR("Failed to reset rotation state of session \"%s\"",
5654 session->name);
5655 }
5656 goto end;
5c408ad8
JD
5657}
5658
5659/*
d68c9a04 5660 * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library.
5c408ad8
JD
5661 *
5662 * Check if the session has finished its rotation.
5663 *
d2956687 5664 * Return LTTNG_OK on success or else an LTTNG_ERR code.
5c408ad8 5665 */
d68c9a04
JD
5666int cmd_rotate_get_info(struct ltt_session *session,
5667 struct lttng_rotation_get_info_return *info_return,
5668 uint64_t rotation_id)
5c408ad8 5669{
d2956687
JG
5670 enum lttng_error_code cmd_ret = LTTNG_OK;
5671 enum lttng_rotation_state rotation_state;
5c408ad8 5672
d68c9a04 5673 DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
d2956687 5674 session->most_recent_chunk_id.value);
5c408ad8 5675
d2956687
JG
5676 if (session->chunk_being_archived) {
5677 enum lttng_trace_chunk_status chunk_status;
5678 uint64_t chunk_id;
5679
5680 chunk_status = lttng_trace_chunk_get_id(
5681 session->chunk_being_archived,
5682 &chunk_id);
a0377dfe 5683 LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
d2956687
JG
5684
5685 rotation_state = rotation_id == chunk_id ?
5686 LTTNG_ROTATION_STATE_ONGOING :
5687 LTTNG_ROTATION_STATE_EXPIRED;
5688 } else {
5689 if (session->last_archived_chunk_id.is_set &&
5690 rotation_id != session->last_archived_chunk_id.value) {
5691 rotation_state = LTTNG_ROTATION_STATE_EXPIRED;
5692 } else {
5693 rotation_state = session->rotation_state;
5694 }
5c408ad8
JD
5695 }
5696
d2956687
JG
5697 switch (rotation_state) {
5698 case LTTNG_ROTATION_STATE_NO_ROTATION:
83ed9e90 5699 DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"",
d2956687
JG
5700 session->name);
5701 goto end;
5702 case LTTNG_ROTATION_STATE_EXPIRED:
5703 DBG("Reporting that the rotation state of rotation id %" PRIu64 " of session \"%s\" has expired",
5704 rotation_id, session->name);
5705 break;
d68c9a04 5706 case LTTNG_ROTATION_STATE_ONGOING:
d2956687 5707 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending",
d68c9a04
JD
5708 rotation_id, session->name);
5709 break;
5710 case LTTNG_ROTATION_STATE_COMPLETED:
dd73d57b 5711 {
d2956687
JG
5712 int fmt_ret;
5713 char *chunk_path;
dd73d57b
JG
5714 char *current_tracing_path_reply;
5715 size_t current_tracing_path_reply_len;
5716
d2956687
JG
5717 DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed",
5718 rotation_id, session->name);
5719
dd73d57b
JG
5720 switch (session_get_consumer_destination_type(session)) {
5721 case CONSUMER_DST_LOCAL:
5722 current_tracing_path_reply =
5723 info_return->location.local.absolute_path;
5724 current_tracing_path_reply_len =
5725 sizeof(info_return->location.local.absolute_path);
5726 info_return->location_type =
05f8afa9 5727 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
ecd1a12f
MD
5728 fmt_ret = asprintf(&chunk_path,
5729 "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
5730 session_get_base_path(session),
5731 session->last_archived_chunk_name);
5732 if (fmt_ret == -1) {
5733 PERROR("Failed to format the path of the last archived trace chunk");
5734 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5735 cmd_ret = LTTNG_ERR_UNK;
5736 goto end;
5737 }
dd73d57b
JG
5738 break;
5739 case CONSUMER_DST_NET:
09cfbe47
JG
5740 {
5741 uint16_t ctrl_port, data_port;
5742
dd73d57b
JG
5743 current_tracing_path_reply =
5744 info_return->location.relay.relative_path;
5745 current_tracing_path_reply_len =
5746 sizeof(info_return->location.relay.relative_path);
5747 /* Currently the only supported relay protocol. */
5748 info_return->location.relay.protocol =
05f8afa9 5749 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
dd73d57b 5750
d2956687 5751 fmt_ret = lttng_strncpy(info_return->location.relay.host,
dd73d57b
JG
5752 session_get_net_consumer_hostname(session),
5753 sizeof(info_return->location.relay.host));
d2956687
JG
5754 if (fmt_ret) {
5755 ERR("Failed to copy host name to rotate_get_info reply");
dd73d57b 5756 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
d2956687 5757 cmd_ret = LTTNG_ERR_SET_URL;
dd73d57b
JG
5758 goto end;
5759 }
5760
09cfbe47
JG
5761 session_get_net_consumer_ports(session, &ctrl_port, &data_port);
5762 info_return->location.relay.ports.control = ctrl_port;
5763 info_return->location.relay.ports.data = data_port;
dd73d57b 5764 info_return->location_type =
05f8afa9 5765 (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
ecd1a12f
MD
5766 chunk_path = strdup(session->last_chunk_path);
5767 if (!chunk_path) {
5768 ERR("Failed to allocate the path of the last archived trace chunk");
5769 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
5770 cmd_ret = LTTNG_ERR_UNK;
5771 goto end;
5772 }
dd73d57b 5773 break;
09cfbe47 5774 }
dd73d57b
JG
5775 default:
5776 abort();
5777 }
d2956687
JG
5778
5779 fmt_ret = lttng_strncpy(current_tracing_path_reply,
5780 chunk_path, current_tracing_path_reply_len);
5781 free(chunk_path);
5782 if (fmt_ret) {
5783 ERR("Failed to copy path of the last archived trace chunk to rotate_get_info reply");
d68c9a04 5784 info_return->status = LTTNG_ROTATION_STATUS_ERROR;
d2956687 5785 cmd_ret = LTTNG_ERR_UNK;
5c408ad8
JD
5786 goto end;
5787 }
dd73d57b 5788
d68c9a04 5789 break;
dd73d57b 5790 }
d68c9a04 5791 case LTTNG_ROTATION_STATE_ERROR:
d2956687 5792 DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"",
d68c9a04
JD
5793 rotation_id, session->name);
5794 break;
5795 default:
5796 abort();
5c408ad8
JD
5797 }
5798
d2956687 5799 cmd_ret = LTTNG_OK;
5c408ad8 5800end:
d2956687
JG
5801 info_return->status = (int32_t) rotation_state;
5802 return cmd_ret;
5c408ad8
JD
5803}
5804
259c2674
JD
5805/*
5806 * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library.
5807 *
5808 * Configure the automatic rotation parameters.
66ea93b1
JG
5809 * 'activate' to true means activate the rotation schedule type with 'new_value'.
5810 * 'activate' to false means deactivate the rotation schedule and validate that
5811 * 'new_value' has the same value as the currently active value.
259c2674 5812 *
1136f41b 5813 * Return LTTNG_OK on success or else a positive LTTNG_ERR code.
259c2674
JD
5814 */
5815int cmd_rotation_set_schedule(struct ltt_session *session,
66ea93b1
JG
5816 bool activate, enum lttng_rotation_schedule_type schedule_type,
5817 uint64_t new_value,
90936dcf 5818 struct notification_thread_handle *notification_thread_handle)
259c2674
JD
5819{
5820 int ret;
66ea93b1 5821 uint64_t *parameter_value;
259c2674 5822
a0377dfe 5823 LTTNG_ASSERT(session);
259c2674
JD
5824
5825 DBG("Cmd rotate set schedule session %s", session->name);
5826
92fe5ca1 5827 if (session->live_timer || !session->output_traces) {
66ea93b1 5828 DBG("Failing ROTATION_SET_SCHEDULE command as the rotation feature is not available for this session");
259c2674
JD
5829 ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
5830 goto end;
5831 }
5832
66ea93b1
JG
5833 switch (schedule_type) {
5834 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5835 parameter_value = &session->rotate_size;
5836 break;
5837 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5838 parameter_value = &session->rotate_timer_period;
5839 if (new_value >= UINT_MAX) {
5840 DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)",
5841 new_value, UINT_MAX);
5842 ret = LTTNG_ERR_INVALID;
5843 goto end;
5844 }
5845 break;
5846 default:
5847 WARN("Failing ROTATION_SET_SCHEDULE command on unknown schedule type");
5848 ret = LTTNG_ERR_INVALID;
259c2674 5849 goto end;
66ea93b1
JG
5850 }
5851
5852 /* Improper use of the API. */
5853 if (new_value == -1ULL) {
5854 WARN("Failing ROTATION_SET_SCHEDULE command as the value requested is -1");
5855 ret = LTTNG_ERR_INVALID;
259c2674
JD
5856 goto end;
5857 }
5858
66ea93b1
JG
5859 /*
5860 * As indicated in struct ltt_session's comments, a value of == 0 means
5861 * this schedule rotation type is not in use.
5862 *
5863 * Reject the command if we were asked to activate a schedule that was
5864 * already active.
5865 */
5866 if (activate && *parameter_value != 0) {
5867 DBG("Failing ROTATION_SET_SCHEDULE (activate) command as the schedule is already active");
5868 ret = LTTNG_ERR_ROTATION_SCHEDULE_SET;
90936dcf 5869 goto end;
66ea93b1
JG
5870 }
5871
5872 /*
5873 * Reject the command if we were asked to deactivate a schedule that was
5874 * not active.
5875 */
5876 if (!activate && *parameter_value == 0) {
5877 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as the schedule is already inactive");
5878 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
90936dcf
JD
5879 goto end;
5880 }
5881
66ea93b1
JG
5882 /*
5883 * Reject the command if we were asked to deactivate a schedule that
5884 * doesn't exist.
5885 */
5886 if (!activate && *parameter_value != new_value) {
5887 DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as an inexistant schedule was provided");
5888 ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET;
5889 goto end;
5890 }
259c2674 5891
66ea93b1
JG
5892 *parameter_value = activate ? new_value : 0;
5893
5894 switch (schedule_type) {
5895 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
5896 if (activate && session->active) {
5897 /*
5898 * Only start the timer if the session is active,
5899 * otherwise it will be started when the session starts.
5900 */
92816cc3
JG
5901 ret = timer_session_rotation_schedule_timer_start(
5902 session, new_value);
259c2674 5903 if (ret) {
66ea93b1 5904 ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command");
259c2674
JD
5905 ret = LTTNG_ERR_UNK;
5906 goto end;
5907 }
66ea93b1 5908 } else {
92816cc3
JG
5909 ret = timer_session_rotation_schedule_timer_stop(
5910 session);
66ea93b1
JG
5911 if (ret) {
5912 ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command");
5913 ret = LTTNG_ERR_UNK;
f3ce6946 5914 goto end;
66ea93b1 5915 }
259c2674 5916 }
66ea93b1
JG
5917 break;
5918 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
5919 if (activate) {
5920 ret = subscribe_session_consumed_size_rotation(session,
5921 new_value, notification_thread_handle);
90936dcf 5922 if (ret) {
66ea93b1 5923 ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command");
90936dcf
JD
5924 ret = LTTNG_ERR_UNK;
5925 goto end;
5926 }
90936dcf 5927 } else {
66ea93b1
JG
5928 ret = unsubscribe_session_consumed_size_rotation(session,
5929 notification_thread_handle);
90936dcf 5930 if (ret) {
66ea93b1 5931 ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command");
90936dcf
JD
5932 ret = LTTNG_ERR_UNK;
5933 goto end;
5934 }
66ea93b1 5935
90936dcf 5936 }
66ea93b1
JG
5937 break;
5938 default:
5939 /* Would have been caught before. */
5940 abort();
90936dcf
JD
5941 }
5942
259c2674
JD
5943 ret = LTTNG_OK;
5944
5945 goto end;
5946
5947end:
5948 return ret;
5949}
5950
a503e1ef
JG
5951/* Wait for a given path to be removed before continuing. */
5952static enum lttng_error_code wait_on_path(void *path_data)
5953{
7966af57 5954 const char *shm_path = (const char *) path_data;
a503e1ef
JG
5955
5956 DBG("Waiting for the shm path at %s to be removed before completing session destruction",
5957 shm_path);
5958 while (true) {
5959 int ret;
5960 struct stat st;
5961
5962 ret = stat(shm_path, &st);
5963 if (ret) {
5964 if (errno != ENOENT) {
5965 PERROR("stat() returned an error while checking for the existence of the shm path");
5966 } else {
5967 DBG("shm path no longer exists, completing the destruction of session");
5968 }
5969 break;
5970 } else {
5971 if (!S_ISDIR(st.st_mode)) {
5972 ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal",
5973 shm_path);
5974 break;
5975 }
5976 }
5977 usleep(SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US);
5978 }
5979 return LTTNG_OK;
5980}
5981
5982/*
5983 * Returns a pointer to a handler to run on completion of a command.
5984 * Returns NULL if no handler has to be run for the last command executed.
5985 */
5986const struct cmd_completion_handler *cmd_pop_completion_handler(void)
5987{
5988 struct cmd_completion_handler *handler = current_completion_handler;
5989
5990 current_completion_handler = NULL;
5991 return handler;
5992}
5993
2f77fc4b
DG
5994/*
5995 * Init command subsystem.
5996 */
5997void cmd_init(void)
5998{
5999 /*
d88aee68
DG
6000 * Set network sequence index to 1 for streams to match a relayd
6001 * socket on the consumer side.
2f77fc4b 6002 */
d88aee68
DG
6003 pthread_mutex_lock(&relayd_net_seq_idx_lock);
6004 relayd_net_seq_idx = 1;
6005 pthread_mutex_unlock(&relayd_net_seq_idx_lock);
2f77fc4b
DG
6006
6007 DBG("Command subsystem initialized");
6008}
This page took 0.516225 seconds and 4 git commands to generate.