X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=cf6764d6171b51446ffa62dec330bd386013500a;hb=bf0a5e5d3ee71a4f9fc87208d9a4f2cf1510d0de;hp=a295059fbf487ef237e97d31ffccbd9fb248fdd1;hpb=0f3d405741c89373f9eb51969f5cf9fccc5ce10d;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index a295059fb..cf6764d61 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1,58 +1,101 @@ /* - * Copyright (C) 2012 - David Goulet - * Copyright (C) 2016 - Jérémie Galarneau + * Copyright (C) 2012 David Goulet + * Copyright (C) 2016 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License, version 2 only, as - * published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along with - * this program; if not, write to the Free Software Foundation, Inc., 51 - * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + #define _LGPL_SOURCE #include #include +#include +#include #include #include -#include +#include #include -#include -#include -#include #include -#include +#include #include -#include -#include -#include +#include +#include +#include +#include +#include +#include + #include -#include +#include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "agent-thread.h" +#include "agent.h" +#include "buffer-registry.h" #include "channel.h" +#include "cmd.h" #include "consumer.h" +#include "event-notifier-error-accounting.h" #include "event.h" #include "health-sessiond.h" -#include "kernel.h" #include "kernel-consumer.h" +#include "kernel.h" #include "lttng-sessiond.h" -#include "utils.h" -#include "syscall.h" -#include "agent.h" -#include "buffer-registry.h" -#include "notification-thread.h" +#include "lttng-syscall.h" #include "notification-thread-commands.h" +#include "notification-thread.h" +#include "rotate.h" +#include "rotation-thread.h" +#include "session.h" +#include "timer.h" +#include "tracker.h" +#include "utils.h" -#include "cmd.h" +/* Sleep for 100ms between each check for the shm path's deletion. */ +#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000 + +struct cmd_destroy_session_reply_context { + int reply_sock_fd; + bool implicit_rotation_on_destroy; + /* + * Indicates whether or not an error occurred while launching the + * destruction of a session. + */ + enum lttng_error_code destruction_status; +}; + +static enum lttng_error_code wait_on_path(void *path); + +/* + * Command completion handler that is used by the destroy command + * when a session that has a non-default shm_path is being destroyed. + * + * See comment in cmd_destroy_session() for the rationale. + */ +static struct destroy_completion_handler { + struct cmd_completion_handler handler; + char shm_path[member_sizeof(struct ltt_session, shm_path)]; +} destroy_completion_handler = { + .handler = { + .run = wait_on_path, + .data = destroy_completion_handler.shm_path + }, + .shm_path = { 0 }, +}; + +static struct cmd_completion_handler *current_completion_handler; /* * Used to keep a unique index for each relayd socket created where this value @@ -65,12 +108,16 @@ static uint64_t relayd_net_seq_idx; static int validate_ust_event_name(const char *); static int cmd_enable_event_internal(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, + struct lttng_bytecode *filter, struct lttng_event_exclusion *exclusion, int wpipe); +static int cmd_enable_channel_internal(struct ltt_session *session, + const struct lttng_domain *domain, + const struct lttng_channel *_attr, + int wpipe); /* * Create a session path used by list_lttng_sessions for the case that the @@ -167,14 +214,14 @@ static int get_kernel_runtime_stats(struct ltt_session *session, goto end; } - ret = consumer_get_discarded_events(session->id, kchan->fd, + ret = consumer_get_discarded_events(session->id, kchan->key, session->kernel_session->consumer, discarded_events); if (ret < 0) { goto end; } - ret = consumer_get_lost_packets(session->id, kchan->fd, + ret = consumer_get_lost_packets(session->id, kchan->key, session->kernel_session->consumer, lost_packets); if (ret < 0) { @@ -241,496 +288,372 @@ end: return ret; } -/* - * Fill lttng_channel array of all channels. - */ -static ssize_t list_lttng_channels(enum lttng_domain_type domain, - struct ltt_session *session, struct lttng_channel *channels, - struct lttng_channel_extended *chan_exts) -{ - int i = 0, ret = 0; - struct ltt_kernel_channel *kchan; - - DBG("Listing channels for session %s", session->name); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - /* Kernel channels */ - if (session->kernel_session != NULL) { - cds_list_for_each_entry(kchan, - &session->kernel_session->channel_list.head, list) { - uint64_t discarded_events, lost_packets; - struct lttng_channel_extended *extended; - - extended = (struct lttng_channel_extended *) - kchan->channel->attr.extended.ptr; - - ret = get_kernel_runtime_stats(session, kchan, - &discarded_events, &lost_packets); - if (ret < 0) { - goto end; - } - /* Copy lttng_channel struct to array */ - memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); - channels[i].enabled = kchan->enabled; - chan_exts[i].discarded_events = - discarded_events; - chan_exts[i].lost_packets = lost_packets; - chan_exts[i].monitor_timer_interval = - extended->monitor_timer_interval; - chan_exts[i].blocking_timeout = 0; - i++; - } - } - break; - case LTTNG_DOMAIN_UST: - { - struct lttng_ht_iter iter; - struct ltt_ust_channel *uchan; - - rcu_read_lock(); - cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht, - &iter.iter, uchan, node.node) { - uint64_t discarded_events = 0, lost_packets = 0; - - if (lttng_strncpy(channels[i].name, uchan->name, - LTTNG_SYMBOL_NAME_LEN)) { - break; - } - channels[i].attr.overwrite = uchan->attr.overwrite; - channels[i].attr.subbuf_size = uchan->attr.subbuf_size; - channels[i].attr.num_subbuf = uchan->attr.num_subbuf; - channels[i].attr.switch_timer_interval = - uchan->attr.switch_timer_interval; - channels[i].attr.read_timer_interval = - uchan->attr.read_timer_interval; - channels[i].enabled = uchan->enabled; - channels[i].attr.tracefile_size = uchan->tracefile_size; - channels[i].attr.tracefile_count = uchan->tracefile_count; - - /* - * Map enum lttng_ust_output to enum lttng_event_output. - */ - switch (uchan->attr.output) { - case LTTNG_UST_MMAP: - channels[i].attr.output = LTTNG_EVENT_MMAP; - break; - default: - /* - * LTTNG_UST_MMAP is the only supported UST - * output mode. - */ - assert(0); - break; - } - - chan_exts[i].monitor_timer_interval = - uchan->monitor_timer_interval; - chan_exts[i].blocking_timeout = - uchan->attr.u.s.blocking_timeout; - - ret = get_ust_runtime_stats(session, uchan, - &discarded_events, &lost_packets); - if (ret < 0) { - break; - } - chan_exts[i].discarded_events = discarded_events; - chan_exts[i].lost_packets = lost_packets; - i++; - } - rcu_read_unlock(); - break; - } - default: - break; - } - -end: - if (ret < 0) { - return -LTTNG_ERR_FATAL; - } else { - return LTTNG_OK; - } -} - -static void increment_extended_len(const char *filter_expression, - struct lttng_event_exclusion *exclusion, size_t *extended_len) -{ - *extended_len += sizeof(struct lttcomm_event_extended_header); - - if (filter_expression) { - *extended_len += strlen(filter_expression) + 1; - } - - if (exclusion) { - *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN; - } -} - -static void append_extended_info(const char *filter_expression, - struct lttng_event_exclusion *exclusion, void **extended_at) -{ - struct lttcomm_event_extended_header extended_header; - size_t filter_len = 0; - size_t nb_exclusions = 0; - - if (filter_expression) { - filter_len = strlen(filter_expression) + 1; - } - - if (exclusion) { - nb_exclusions = exclusion->count; - } - - /* Set header fields */ - extended_header.filter_len = filter_len; - extended_header.nb_exclusions = nb_exclusions; - - /* Copy header */ - memcpy(*extended_at, &extended_header, sizeof(extended_header)); - *extended_at += sizeof(extended_header); - - /* Copy filter string */ - if (filter_expression) { - memcpy(*extended_at, filter_expression, filter_len); - *extended_at += filter_len; - } - - /* Copy exclusion names */ - if (exclusion) { - size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN; - - memcpy(*extended_at, &exclusion->names, len); - *extended_at += len; - } -} - /* * Create a list of agent domain events. * * Return number of events in list on success or else a negative value. */ -static int list_lttng_agent_events(struct agent *agt, - struct lttng_event **events, size_t *total_size) +static enum lttng_error_code list_lttng_agent_events( + struct agent *agt, struct lttng_payload *reply_payload, + unsigned int *nb_events) { - int i = 0, ret = 0; - unsigned int nb_event = 0; + enum lttng_error_code ret_code; + int ret = 0; + unsigned int local_nb_events = 0; struct agent_event *event; - struct lttng_event *tmp_events; struct lttng_ht_iter iter; - size_t extended_len = 0; - void *extended_at; + unsigned long agent_event_count; assert(agt); - assert(events); + assert(reply_payload); DBG3("Listing agent events"); rcu_read_lock(); - nb_event = lttng_ht_get_count(agt->events); - rcu_read_unlock(); - if (nb_event == 0) { - ret = nb_event; - *total_size = 0; - goto error; - } - /* Compute required extended infos size */ - extended_len = nb_event * sizeof(struct lttcomm_event_extended_header); - - /* - * This is only valid because the commands which add events are - * processed in the same thread as the listing. - */ - rcu_read_lock(); - cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { - increment_extended_len(event->filter_expression, NULL, - &extended_len); + agent_event_count = lttng_ht_get_count(agt->events); + if (agent_event_count == 0) { + /* Early exit. */ + goto end; } - rcu_read_unlock(); - *total_size = nb_event * sizeof(*tmp_events) + extended_len; - tmp_events = zmalloc(*total_size); - if (!tmp_events) { - PERROR("zmalloc agent events session"); - ret = -LTTNG_ERR_FATAL; + if (agent_event_count > UINT_MAX) { + ret_code = LTTNG_ERR_OVERFLOW; goto error; } - extended_at = ((uint8_t *) tmp_events) + - nb_event * sizeof(struct lttng_event); + local_nb_events = (unsigned int) agent_event_count; - rcu_read_lock(); cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { - strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name)); - tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0'; - tmp_events[i].enabled = event->enabled; - tmp_events[i].loglevel = event->loglevel_value; - tmp_events[i].loglevel_type = event->loglevel_type; - i++; + struct lttng_event *tmp_event = lttng_event_create(); - /* Append extended info */ - append_extended_info(event->filter_expression, NULL, - &extended_at); - } - rcu_read_unlock(); + if (!tmp_event) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + + if (lttng_strncpy(tmp_event->name, event->name, sizeof(tmp_event->name))) { + lttng_event_destroy(tmp_event); + ret_code = LTTNG_ERR_FATAL; + goto error; + } + + tmp_event->name[sizeof(tmp_event->name) - 1] = '\0'; + tmp_event->enabled = !!event->enabled_count; + tmp_event->loglevel = event->loglevel_value; + tmp_event->loglevel_type = event->loglevel_type; - *events = tmp_events; - ret = nb_event; + ret = lttng_event_serialize(tmp_event, 0, NULL, + event->filter_expression, 0, NULL, reply_payload); + lttng_event_destroy(tmp_event); + if (ret) { + ret_code = LTTNG_ERR_FATAL; + goto error; + } + } +end: + ret_code = LTTNG_OK; + *nb_events = local_nb_events; error: - assert(nb_event == i); - return ret; + rcu_read_unlock(); + return ret_code; } /* * Create a list of ust global domain events. */ -static int list_lttng_ust_global_events(char *channel_name, +static enum lttng_error_code list_lttng_ust_global_events(char *channel_name, struct ltt_ust_domain_global *ust_global, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *reply_payload, + unsigned int *nb_events) { - int i = 0, ret = 0; - unsigned int nb_event = 0; + enum lttng_error_code ret_code; + int ret; struct lttng_ht_iter iter; struct lttng_ht_node_str *node; struct ltt_ust_channel *uchan; struct ltt_ust_event *uevent; - struct lttng_event *tmp; - size_t extended_len = 0; - void *extended_at; + unsigned long channel_event_count; + unsigned int local_nb_events = 0; + + assert(reply_payload); + assert(nb_events); DBG("Listing UST global events for channel %s", channel_name); rcu_read_lock(); - lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter); + lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter); node = lttng_ht_iter_get_node_str(&iter); if (node == NULL) { - ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto end; + ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; } uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node); - nb_event = lttng_ht_get_count(uchan->events); - if (nb_event == 0) { - ret = nb_event; - *total_size = 0; + channel_event_count = lttng_ht_get_count(uchan->events); + if (channel_event_count == 0) { + /* Early exit. */ + ret_code = LTTNG_OK; goto end; } - DBG3("Listing UST global %d events", nb_event); - - /* Compute required extended infos size */ - cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { - if (uevent->internal) { - nb_event--; - continue; - } - - increment_extended_len(uevent->filter_expression, - uevent->exclusion, &extended_len); - } - if (nb_event == 0) { - /* All events are internal, skip. */ - ret = 0; - *total_size = 0; - goto end; + if (channel_event_count > UINT_MAX) { + ret_code = LTTNG_ERR_OVERFLOW; + goto error; } - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - tmp = zmalloc(*total_size); - if (tmp == NULL) { - ret = -LTTNG_ERR_FATAL; - goto end; - } + local_nb_events = (unsigned int) channel_event_count; - extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event); + DBG3("Listing UST global %d events", *nb_events); cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + struct lttng_event *tmp_event = NULL; + if (uevent->internal) { /* This event should remain hidden from clients */ + local_nb_events--; continue; } - strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN); - tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - tmp[i].enabled = uevent->enabled; + + tmp_event = lttng_event_create(); + if (!tmp_event) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + + if (lttng_strncpy(tmp_event->name, uevent->attr.name, + LTTNG_SYMBOL_NAME_LEN)) { + ret_code = LTTNG_ERR_FATAL; + lttng_event_destroy(tmp_event); + goto error; + } + + tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + tmp_event->enabled = uevent->enabled; switch (uevent->attr.instrumentation) { - case LTTNG_UST_TRACEPOINT: - tmp[i].type = LTTNG_EVENT_TRACEPOINT; + case LTTNG_UST_ABI_TRACEPOINT: + tmp_event->type = LTTNG_EVENT_TRACEPOINT; break; - case LTTNG_UST_PROBE: - tmp[i].type = LTTNG_EVENT_PROBE; + case LTTNG_UST_ABI_PROBE: + tmp_event->type = LTTNG_EVENT_PROBE; break; - case LTTNG_UST_FUNCTION: - tmp[i].type = LTTNG_EVENT_FUNCTION; + case LTTNG_UST_ABI_FUNCTION: + tmp_event->type = LTTNG_EVENT_FUNCTION; break; } - tmp[i].loglevel = uevent->attr.loglevel; + tmp_event->loglevel = uevent->attr.loglevel; switch (uevent->attr.loglevel_type) { - case LTTNG_UST_LOGLEVEL_ALL: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + case LTTNG_UST_ABI_LOGLEVEL_ALL: + tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; break; - case LTTNG_UST_LOGLEVEL_RANGE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; + case LTTNG_UST_ABI_LOGLEVEL_RANGE: + tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; break; - case LTTNG_UST_LOGLEVEL_SINGLE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; + case LTTNG_UST_ABI_LOGLEVEL_SINGLE: + tmp_event->loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; break; } if (uevent->filter) { - tmp[i].filter = 1; + tmp_event->filter = 1; } if (uevent->exclusion) { - tmp[i].exclusion = 1; + tmp_event->exclusion = 1; } - i++; - /* Append extended info */ - append_extended_info(uevent->filter_expression, - uevent->exclusion, &extended_at); + /* + * We do not care about the filter bytecode and the fd from the + * userspace_probe_location. + */ + ret = lttng_event_serialize(tmp_event, uevent->exclusion ? uevent->exclusion->count : 0, + uevent->exclusion ? (char **) uevent->exclusion ->names : NULL, + uevent->filter_expression, 0, NULL, reply_payload); + lttng_event_destroy(tmp_event); + if (ret) { + ret_code = LTTNG_ERR_FATAL; + goto error; + } } - ret = nb_event; - *events = tmp; end: + /* nb_events is already set at this point. */ + ret_code = LTTNG_OK; + *nb_events = local_nb_events; +error: rcu_read_unlock(); - return ret; + return ret_code; } /* * Fill lttng_event array of all kernel events in the channel. */ -static int list_lttng_kernel_events(char *channel_name, +static enum lttng_error_code list_lttng_kernel_events(char *channel_name, struct ltt_kernel_session *kernel_session, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *reply_payload, + unsigned int *nb_events) { - int i = 0, ret; - unsigned int nb_event; + enum lttng_error_code ret_code; + int ret; struct ltt_kernel_event *event; struct ltt_kernel_channel *kchan; - size_t extended_len = 0; - void *extended_at; + + assert(reply_payload); kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); if (kchan == NULL) { - ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; - goto error; + ret_code = LTTNG_ERR_KERN_CHAN_NOT_FOUND; + goto end; } - nb_event = kchan->event_count; + *nb_events = kchan->event_count; DBG("Listing events for channel %s", kchan->channel->name); - if (nb_event == 0) { - *total_size = 0; - *events = NULL; + if (*nb_events == 0) { + ret_code = LTTNG_OK; goto end; } - /* Compute required extended infos size */ - cds_list_for_each_entry(event, &kchan->events_list.head, list) { - increment_extended_len(event->filter_expression, NULL, - &extended_len); - } + /* Kernel channels */ + cds_list_for_each_entry(event, &kchan->events_list.head , list) { + struct lttng_event *tmp_event = lttng_event_create(); - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - *events = zmalloc(*total_size); - if (*events == NULL) { - ret = LTTNG_ERR_FATAL; - goto error; - } + if (!tmp_event) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + if (lttng_strncpy(tmp_event->name, event->event->name, LTTNG_SYMBOL_NAME_LEN)) { + lttng_event_destroy(tmp_event); + ret_code = LTTNG_ERR_FATAL; + goto end; - extended_at = ((void *) *events) + - nb_event * sizeof(struct lttng_event); + } - /* Kernel channels */ - cds_list_for_each_entry(event, &kchan->events_list.head , list) { - strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); - (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - (*events)[i].enabled = event->enabled; - (*events)[i].filter = - (unsigned char) !!event->filter_expression; + tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + tmp_event->enabled = event->enabled; + tmp_event->filter = (unsigned char) !!event->filter_expression; switch (event->event->instrumentation) { - case LTTNG_KERNEL_TRACEPOINT: - (*events)[i].type = LTTNG_EVENT_TRACEPOINT; + case LTTNG_KERNEL_ABI_TRACEPOINT: + tmp_event->type = LTTNG_EVENT_TRACEPOINT; break; - case LTTNG_KERNEL_KRETPROBE: - (*events)[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, - sizeof(struct lttng_kernel_kprobe)); + case LTTNG_KERNEL_ABI_KRETPROBE: + tmp_event->type = LTTNG_EVENT_FUNCTION; + memcpy(&tmp_event->attr.probe, &event->event->u.kprobe, + sizeof(struct lttng_kernel_abi_kprobe)); break; - case LTTNG_KERNEL_KPROBE: - (*events)[i].type = LTTNG_EVENT_PROBE; - memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, - sizeof(struct lttng_kernel_kprobe)); + case LTTNG_KERNEL_ABI_KPROBE: + tmp_event->type = LTTNG_EVENT_PROBE; + memcpy(&tmp_event->attr.probe, &event->event->u.kprobe, + sizeof(struct lttng_kernel_abi_kprobe)); break; - case LTTNG_KERNEL_FUNCTION: - (*events)[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, - sizeof(struct lttng_kernel_function)); + case LTTNG_KERNEL_ABI_UPROBE: + tmp_event->type = LTTNG_EVENT_USERSPACE_PROBE; break; - case LTTNG_KERNEL_NOOP: - (*events)[i].type = LTTNG_EVENT_NOOP; + case LTTNG_KERNEL_ABI_FUNCTION: + tmp_event->type = LTTNG_EVENT_FUNCTION; + memcpy(&(tmp_event->attr.ftrace), &event->event->u.ftrace, + sizeof(struct lttng_kernel_abi_function)); break; - case LTTNG_KERNEL_SYSCALL: - (*events)[i].type = LTTNG_EVENT_SYSCALL; + case LTTNG_KERNEL_ABI_NOOP: + tmp_event->type = LTTNG_EVENT_NOOP; break; - case LTTNG_KERNEL_ALL: + case LTTNG_KERNEL_ABI_SYSCALL: + tmp_event->type = LTTNG_EVENT_SYSCALL; + break; + case LTTNG_KERNEL_ABI_ALL: + /* fall-through. */ + default: assert(0); break; } - i++; - /* Append extended info */ - append_extended_info(event->filter_expression, NULL, - &extended_at); + if (event->userspace_probe_location) { + struct lttng_userspace_probe_location *location_copy = + lttng_userspace_probe_location_copy( + event->userspace_probe_location); + + if (!location_copy) { + lttng_event_destroy(tmp_event); + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + ret = lttng_event_set_userspace_probe_location( + tmp_event, location_copy); + if (ret) { + lttng_event_destroy(tmp_event); + lttng_userspace_probe_location_destroy( + location_copy); + ret_code = LTTNG_ERR_INVALID; + goto end; + } + } + + ret = lttng_event_serialize(tmp_event, 0, NULL, + event->filter_expression, 0, NULL, reply_payload); + lttng_event_destroy(tmp_event); + if (ret) { + ret_code = LTTNG_ERR_FATAL; + goto end; + } } + ret_code = LTTNG_OK; end: - return nb_event; - -error: - /* Negate the error code to differentiate the size from an error */ - return -ret; + return ret_code; } /* * Add URI so the consumer output object. Set the correct path depending on the * domain adding the default trace directory. */ -static int add_uri_to_consumer(struct consumer_output *consumer, - struct lttng_uri *uri, enum lttng_domain_type domain, - const char *session_name) +static enum lttng_error_code add_uri_to_consumer( + const struct ltt_session *session, + struct consumer_output *consumer, + struct lttng_uri *uri, enum lttng_domain_type domain) { - int ret = LTTNG_OK; - const char *default_trace_dir; + int ret; + enum lttng_error_code ret_code = LTTNG_OK; assert(uri); if (consumer == NULL) { DBG("No consumer detected. Don't add URI. Stopping."); - ret = LTTNG_ERR_NO_CONSUMER; + ret_code = LTTNG_ERR_NO_CONSUMER; goto error; } switch (domain) { case LTTNG_DOMAIN_KERNEL: - default_trace_dir = DEFAULT_KERNEL_TRACE_DIR; + ret = lttng_strncpy(consumer->domain_subdir, + DEFAULT_KERNEL_TRACE_DIR, + sizeof(consumer->domain_subdir)); break; case LTTNG_DOMAIN_UST: - default_trace_dir = DEFAULT_UST_TRACE_DIR; + ret = lttng_strncpy(consumer->domain_subdir, + DEFAULT_UST_TRACE_DIR, + sizeof(consumer->domain_subdir)); break; default: /* - * This case is possible is we try to add the URI to the global tracing - * session consumer object which in this case there is no subdir. + * This case is possible is we try to add the URI to the global + * tracing session consumer object which in this case there is + * no subdir. */ - default_trace_dir = ""; + memset(consumer->domain_subdir, 0, + sizeof(consumer->domain_subdir)); + ret = 0; + } + if (ret) { + ERR("Failed to initialize consumer output domain subdirectory"); + ret_code = LTTNG_ERR_FATAL; + goto error; } switch (uri->dtype) { @@ -743,67 +666,50 @@ static int add_uri_to_consumer(struct consumer_output *consumer, consumer->dst.net.control_isset) || (uri->stype == LTTNG_STREAM_DATA && consumer->dst.net.data_isset)) { - ret = LTTNG_ERR_URL_EXIST; + ret_code = LTTNG_ERR_URL_EXIST; goto error; } } else { - memset(&consumer->dst.net, 0, sizeof(consumer->dst.net)); + memset(&consumer->dst, 0, sizeof(consumer->dst)); } - consumer->type = CONSUMER_DST_NET; - /* Set URI into consumer output object */ - ret = consumer_set_network_uri(consumer, uri); + ret = consumer_set_network_uri(session, consumer, uri); if (ret < 0) { - ret = -ret; + ret_code = -ret; goto error; } else if (ret == 1) { /* * URI was the same in the consumer so we do not append the subdir * again so to not duplicate output dir. */ - ret = LTTNG_OK; + ret_code = LTTNG_OK; goto error; } - - if (uri->stype == LTTNG_STREAM_CONTROL && strlen(uri->subdir) == 0) { - ret = consumer_set_subdir(consumer, session_name); - if (ret < 0) { - ret = LTTNG_ERR_FATAL; - goto error; - } - } - - if (uri->stype == LTTNG_STREAM_CONTROL) { - /* On a new subdir, reappend the default trace dir. */ - strncat(consumer->subdir, default_trace_dir, - sizeof(consumer->subdir) - strlen(consumer->subdir) - 1); - DBG3("Append domain trace name to subdir %s", consumer->subdir); - } - break; case LTTNG_DST_PATH: - DBG2("Setting trace directory path from URI to %s", uri->dst.path); - memset(consumer->dst.trace_path, 0, - sizeof(consumer->dst.trace_path)); - /* Explicit length checks for strcpy and strcat. */ - if (strlen(uri->dst.path) + strlen(default_trace_dir) - >= sizeof(consumer->dst.trace_path)) { - ret = LTTNG_ERR_FATAL; + if (*uri->dst.path != '/' || strstr(uri->dst.path, "../")) { + ret_code = LTTNG_ERR_INVALID; + goto error; + } + DBG2("Setting trace directory path from URI to %s", + uri->dst.path); + memset(&consumer->dst, 0, sizeof(consumer->dst)); + + ret = lttng_strncpy(consumer->dst.session_root_path, + uri->dst.path, + sizeof(consumer->dst.session_root_path)); + if (ret) { + ret_code = LTTNG_ERR_FATAL; goto error; } - strcpy(consumer->dst.trace_path, uri->dst.path); - /* Append default trace dir */ - strcat(consumer->dst.trace_path, default_trace_dir); - /* Flag consumer as local. */ consumer->type = CONSUMER_DST_LOCAL; break; } - ret = LTTNG_OK; - + ret_code = LTTNG_OK; error: - return ret; + return ret_code; } /* @@ -841,19 +747,20 @@ error: * Create a socket to the relayd using the URI. * * On success, the relayd_sock pointer is set to the created socket. - * Else, it's stays untouched and a lttcomm error code is returned. + * Else, it remains untouched and an LTTng error code is returned. */ -static int create_connect_relayd(struct lttng_uri *uri, +static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, struct lttcomm_relayd_sock **relayd_sock, struct consumer_output *consumer) { int ret; + enum lttng_error_code status = LTTNG_OK; struct lttcomm_relayd_sock *rsock; rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR, RELAYD_VERSION_COMM_MINOR); if (!rsock) { - ret = LTTNG_ERR_FATAL; + status = LTTNG_ERR_FATAL; goto error; } @@ -867,34 +774,50 @@ static int create_connect_relayd(struct lttng_uri *uri, health_poll_exit(); if (ret < 0) { ERR("Unable to reach lttng-relayd"); - ret = LTTNG_ERR_RELAYD_CONNECT_FAIL; + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto free_sock; } /* Create socket for control stream. */ if (uri->stype == LTTNG_STREAM_CONTROL) { + uint64_t result_flags; + DBG3("Creating relayd stream socket from URI"); /* Check relayd version */ ret = relayd_version_check(rsock); - if (ret < 0) { - ret = LTTNG_ERR_RELAYD_VERSION_FAIL; + if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) { + status = LTTNG_ERR_RELAYD_VERSION_FAIL; + goto close_sock; + } else if (ret < 0) { + ERR("Unable to reach lttng-relayd"); + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto close_sock; } consumer->relay_major_version = rsock->major; consumer->relay_minor_version = rsock->minor; + ret = relayd_get_configuration(rsock, 0, + &result_flags); + if (ret < 0) { + ERR("Unable to get relayd configuration"); + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; + goto close_sock; + } + if (result_flags & LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED) { + consumer->relay_allows_clear = true; + } } else if (uri->stype == LTTNG_STREAM_DATA) { DBG3("Creating relayd data socket from URI"); } else { /* Command is not valid */ ERR("Relayd invalid stream type: %d", uri->stype); - ret = LTTNG_ERR_INVALID; + status = LTTNG_ERR_INVALID; goto close_sock; } *relayd_sock = rsock; - return LTTNG_OK; + return status; close_sock: /* The returned value is not useful since we are on an error path. */ @@ -902,25 +825,35 @@ close_sock: free_sock: free(rsock); error: - return ret; + return status; } /* * Connect to the relayd using URI and send the socket to the right consumer. + * + * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK on success or an LTTng error code on failure. */ -static int send_consumer_relayd_socket(enum lttng_domain_type domain, - unsigned int session_id, struct lttng_uri *relayd_uri, +static enum lttng_error_code send_consumer_relayd_socket( + unsigned int session_id, + struct lttng_uri *relayd_uri, struct consumer_output *consumer, struct consumer_socket *consumer_sock, - char *session_name, char *hostname, int session_live_timer) + const char *session_name, const char *hostname, + const char *base_path, int session_live_timer, + const uint64_t *current_chunk_id, + time_t session_creation_time, + bool session_name_contains_creation_time) { int ret; struct lttcomm_relayd_sock *rsock = NULL; + enum lttng_error_code status; /* Connect to relayd and make version check if uri is the control. */ - ret = create_connect_relayd(relayd_uri, &rsock, consumer); - if (ret != LTTNG_OK) { - goto error; + status = create_connect_relayd(relayd_uri, &rsock, consumer); + if (status != LTTNG_OK) { + goto relayd_comm_error; } assert(rsock); @@ -939,9 +872,11 @@ static int send_consumer_relayd_socket(enum lttng_domain_type domain, /* Send relayd socket to consumer. */ ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer, relayd_uri->stype, session_id, - session_name, hostname, session_live_timer); + session_name, hostname, base_path, + session_live_timer, current_chunk_id, + session_creation_time, session_name_contains_creation_time); if (ret < 0) { - ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL; + status = LTTNG_ERR_ENABLE_CONSUMER_FAIL; goto close_sock; } @@ -952,19 +887,13 @@ static int send_consumer_relayd_socket(enum lttng_domain_type domain, consumer_sock->data_sock_sent = 1; } - ret = LTTNG_OK; - /* * Close socket which was dup on the consumer side. The session daemon does * NOT keep track of the relayd socket(s) once transfer to the consumer. */ close_sock: - (void) relayd_close(rsock); - free(rsock); - -error: - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { /* * The consumer output for this session should not be used anymore * since the relayd connection failed thus making any tracing or/and @@ -972,46 +901,61 @@ error: */ consumer->enabled = 0; } - return ret; + (void) relayd_close(rsock); + free(rsock); + +relayd_comm_error: + return status; } /* * Send both relayd sockets to a specific consumer and domain. This is a * helper function to facilitate sending the information to the consumer for a * session. + * + * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK, or an LTTng error code on failure. */ -static int send_consumer_relayd_sockets(enum lttng_domain_type domain, +static enum lttng_error_code send_consumer_relayd_sockets( + enum lttng_domain_type domain, unsigned int session_id, struct consumer_output *consumer, - struct consumer_socket *sock, char *session_name, - char *hostname, int session_live_timer) + struct consumer_socket *sock, const char *session_name, + const char *hostname, const char *base_path, int session_live_timer, + const uint64_t *current_chunk_id, time_t session_creation_time, + bool session_name_contains_creation_time) { - int ret = LTTNG_OK; + enum lttng_error_code status = LTTNG_OK; assert(consumer); assert(sock); /* Sending control relayd socket. */ if (!sock->control_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.control, consumer, sock, - session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + session_name, hostname, base_path, session_live_timer, + current_chunk_id, session_creation_time, + session_name_contains_creation_time); + if (status != LTTNG_OK) { goto error; } } /* Sending data relayd socket. */ if (!sock->data_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer, sock, - session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + session_name, hostname, base_path, session_live_timer, + current_chunk_id, session_creation_time, + session_name_contains_creation_time); + if (status != LTTNG_OK) { goto error; } } error: - return ret; + return status; } /* @@ -1026,6 +970,7 @@ int cmd_setup_relayd(struct ltt_session *session) struct ltt_kernel_session *ksess; struct consumer_socket *socket; struct lttng_ht_iter iter; + LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; assert(session); @@ -1035,6 +980,18 @@ int cmd_setup_relayd(struct ltt_session *session) DBG("Setting relayd for session %s", session->name); rcu_read_lock(); + if (session->current_trace_chunk) { + enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id( + session->current_trace_chunk, ¤t_chunk_id.value); + + if (status == LTTNG_TRACE_CHUNK_STATUS_OK) { + current_chunk_id.is_set = true; + } else { + ERR("Failed to get current trace chunk id"); + ret = LTTNG_ERR_UNK; + goto error; + } + } if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET && usess->consumer->enabled) { @@ -1045,7 +1002,11 @@ int cmd_setup_relayd(struct ltt_session *session) ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id, usess->consumer, socket, session->name, session->hostname, - session->live_timer); + session->base_path, + session->live_timer, + current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, + session->creation_time, + session->name_contains_creation_time); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -1057,6 +1018,8 @@ int cmd_setup_relayd(struct ltt_session *session) usess->consumer->relay_major_version; session->consumer->relay_minor_version = usess->consumer->relay_minor_version; + session->consumer->relay_allows_clear = + usess->consumer->relay_allows_clear; } if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET @@ -1067,7 +1030,11 @@ int cmd_setup_relayd(struct ltt_session *session) ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id, ksess->consumer, socket, session->name, session->hostname, - session->live_timer); + session->base_path, + session->live_timer, + current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, + session->creation_time, + session->name_contains_creation_time); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -1079,6 +1046,8 @@ int cmd_setup_relayd(struct ltt_session *session) ksess->consumer->relay_major_version; session->consumer->relay_minor_version = ksess->consumer->relay_minor_version; + session->consumer->relay_allows_clear = + ksess->consumer->relay_allows_clear; } error: @@ -1089,7 +1058,7 @@ error: /* * Start a kernel session by opening all necessary streams. */ -static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) +int start_kernel_session(struct ltt_kernel_session *ksess) { int ret; struct ltt_kernel_channel *kchan; @@ -1141,7 +1110,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) } /* Quiescent wait after starting trace */ - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); ksess->active = 1; @@ -1151,6 +1120,53 @@ error: return ret; } +int stop_kernel_session(struct ltt_kernel_session *ksess) +{ + struct ltt_kernel_channel *kchan; + bool error_occurred = false; + int ret; + + if (!ksess || !ksess->active) { + return LTTNG_OK; + } + DBG("Stopping kernel tracing"); + + ret = kernel_stop_session(ksess); + if (ret < 0) { + ret = LTTNG_ERR_KERN_STOP_FAIL; + goto error; + } + + kernel_wait_quiescent(); + + /* Flush metadata after stopping (if exists) */ + if (ksess->metadata_stream_fd >= 0) { + ret = kernel_metadata_flush_buffer(ksess->metadata_stream_fd); + if (ret < 0) { + ERR("Kernel metadata flush failed"); + error_occurred = true; + } + } + + /* Flush all buffers after stopping */ + cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) { + ret = kernel_flush_buffer(kchan); + if (ret < 0) { + ERR("Kernel flush buffer error"); + error_occurred = true; + } + } + + ksess->active = 0; + if (error_occurred) { + ret = LTTNG_ERR_UNK; + } else { + ret = LTTNG_OK; + } +error: + return ret; +} + /* * Command LTTNG_DISABLE_CHANNEL processed by the client thread. */ @@ -1173,7 +1189,7 @@ int cmd_disable_channel(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1208,124 +1224,78 @@ error: } /* - * Command LTTNG_TRACK_PID processed by the client thread. + * Command LTTNG_ENABLE_CHANNEL processed by the client thread. * - * Called with session lock held. + * The wpipe arguments is used as a notifier for the kernel thread. */ -int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) +int cmd_enable_channel(struct command_ctx *cmd_ctx, int sock, int wpipe) { int ret; + size_t channel_len; + ssize_t sock_recv_len; + struct lttng_channel *channel = NULL; + struct lttng_buffer_view view; + struct lttng_dynamic_buffer channel_buffer; + const struct lttng_domain command_domain = cmd_ctx->lsm.domain; - rcu_read_lock(); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - - ret = kernel_track_pid(ksess, pid); - if (ret != LTTNG_OK) { - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - break; + lttng_dynamic_buffer_init(&channel_buffer); + channel_len = (size_t) cmd_ctx->lsm.u.channel.length; + ret = lttng_dynamic_buffer_set_size(&channel_buffer, channel_len); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto end; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - - usess = session->ust_session; - ret = trace_ust_track_pid(usess, pid); - if (ret != LTTNG_OK) { - goto error; - } - break; - } - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; + sock_recv_len = lttcomm_recv_unix_sock(sock, channel_buffer.data, + channel_len); + if (sock_recv_len < 0 || sock_recv_len != channel_len) { + ERR("Failed to receive \"enable channel\" command payload"); + ret = LTTNG_ERR_INVALID; + goto end; } - ret = LTTNG_OK; - -error: - rcu_read_unlock(); - return ret; -} - -/* - * Command LTTNG_UNTRACK_PID processed by the client thread. - * - * Called with session lock held. - */ -int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) -{ - int ret; - - rcu_read_lock(); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - - ret = kernel_untrack_pid(ksess, pid); - if (ret != LTTNG_OK) { - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - break; + view = lttng_buffer_view_from_dynamic_buffer(&channel_buffer, 0, channel_len); + if (!lttng_buffer_view_is_valid(&view)) { + ret = LTTNG_ERR_INVALID; + goto end; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - - usess = session->ust_session; - ret = trace_ust_untrack_pid(usess, pid); - if (ret != LTTNG_OK) { - goto error; - } - break; - } - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; + if (lttng_channel_create_from_buffer(&view, &channel) != channel_len) { + ERR("Invalid channel payload received in \"enable channel\" command"); + ret = LTTNG_ERR_INVALID; + goto end; } - ret = LTTNG_OK; + ret = cmd_enable_channel_internal( + cmd_ctx->session, &command_domain, channel, wpipe); -error: - rcu_read_unlock(); +end: + lttng_dynamic_buffer_reset(&channel_buffer); + lttng_channel_destroy(channel); return ret; } -/* - * Command LTTNG_ENABLE_CHANNEL processed by the client thread. - * - * The wpipe arguments is used as a notifier for the kernel thread. - */ -int cmd_enable_channel(struct ltt_session *session, - struct lttng_domain *domain, struct lttng_channel *attr, int wpipe) +static int cmd_enable_channel_internal(struct ltt_session *session, + const struct lttng_domain *domain, + const struct lttng_channel *_attr, + int wpipe) { int ret; struct ltt_ust_session *usess = session->ust_session; struct lttng_ht *chan_ht; size_t len; + struct lttng_channel *attr = NULL; assert(session); - assert(attr); + assert(_attr); assert(domain); + attr = lttng_channel_copy(_attr); + if (!attr) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + len = lttng_strnlen(attr->name, sizeof(attr->name)); /* Validate channel name */ @@ -1339,15 +1309,6 @@ int cmd_enable_channel(struct ltt_session *session, rcu_read_lock(); - /* - * Don't try to enable a channel if the session has been started at - * some point in time before. The tracer does not allow it. - */ - if (session->has_been_started) { - ret = LTTNG_ERR_TRACE_ALREADY_STARTED; - goto error; - } - /* * If the session is a live session, remove the switch timer, the * live timer does the same thing but sends also synchronisation @@ -1362,20 +1323,26 @@ int cmd_enable_channel(struct ltt_session *session, switch (domain->type) { case LTTNG_DOMAIN_KERNEL: { - if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) { + if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) { /* Sampling position of buffer is not supported */ WARN("Kernel tracer does not support buffer monitoring. " "Setting the monitor interval timer to 0 " "(disabled) for channel '%s' of session '%s'", - attr-> name, session->name); + attr->name, session->name); lttng_channel_set_monitor_timer_interval(attr, 0); } break; } case LTTNG_DOMAIN_UST: + break; case LTTNG_DOMAIN_JUL: case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_PYTHON: + if (!agent_tracing_is_enabled()) { + DBG("Attempted to enable a channel in an agent domain but the agent thread is not running"); + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } break; default: ret = LTTNG_ERR_UNKNOWN_DOMAIN; @@ -1387,10 +1354,25 @@ int cmd_enable_channel(struct ltt_session *session, { struct ltt_kernel_channel *kchan; - kchan = trace_kernel_get_channel_by_name(attr->name, - session->kernel_session); + kchan = trace_kernel_get_channel_by_name( + attr->name, session->kernel_session); if (kchan == NULL) { - ret = channel_kernel_create(session->kernel_session, attr, wpipe); + /* + * Don't try to create a channel if the session has been started at + * some point in time before. The tracer does not allow it. + */ + if (session->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } + + if (session->snapshot.nb_output > 0 || + session->snapshot_mode) { + /* Enforce mmap output for snapshot sessions. */ + attr->attr.output = LTTNG_EVENT_MMAP; + } + ret = channel_kernel_create( + session->kernel_session, attr, wpipe); if (attr->name[0] != '\0') { session->kernel_session->has_non_default_channel = 1; } @@ -1402,7 +1384,7 @@ int cmd_enable_channel(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1444,6 +1426,15 @@ int cmd_enable_channel(struct ltt_session *session, uchan = trace_ust_find_channel_by_name(chan_ht, attr->name); if (uchan == NULL) { + /* + * Don't try to create a channel if the session has been started at + * some point in time before. The tracer does not allow it. + */ + if (session->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } + ret = channel_ust_create(usess, attr, domain->buf_type); if (attr->name[0] != '\0') { usess->has_non_default_channel = 1; @@ -1458,64 +1449,291 @@ int cmd_enable_channel(struct ltt_session *session, goto error; } + if (ret == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) { + session->has_non_mmap_channel = true; + } error: rcu_read_unlock(); end: + lttng_channel_destroy(attr); return ret; } -/* - * Command LTTNG_DISABLE_EVENT processed by the client thread. - */ -int cmd_disable_event(struct ltt_session *session, - enum lttng_domain_type domain, char *channel_name, - struct lttng_event *event) +enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy( + struct ltt_session *session, + enum lttng_domain_type domain, + enum lttng_process_attr process_attr, + enum lttng_tracking_policy *policy) { - int ret; - char *event_name; + enum lttng_error_code ret_code = LTTNG_OK; + const struct process_attr_tracker *tracker; - DBG("Disable event command for event \'%s\'", event->name); + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + tracker = kernel_get_process_attr_tracker( + session->kernel_session, process_attr); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + tracker = trace_ust_get_process_attr_tracker( + session->ust_session, process_attr); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + goto end; + } + if (tracker) { + *policy = process_attr_tracker_get_tracking_policy(tracker); + } else { + ret_code = LTTNG_ERR_INVALID; + } +end: + return ret_code; +} - event_name = event->name; +enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy( + struct ltt_session *session, + enum lttng_domain_type domain, + enum lttng_process_attr process_attr, + enum lttng_tracking_policy policy) +{ + enum lttng_error_code ret_code = LTTNG_OK; - /* Error out on unhandled search criteria */ - if (event->loglevel_type || event->loglevel != -1 || event->enabled - || event->pid || event->filter || event->exclusion) { - ret = LTTNG_ERR_UNK; - goto error; + switch (policy) { + case LTTNG_TRACKING_POLICY_INCLUDE_SET: + case LTTNG_TRACKING_POLICY_EXCLUDE_ALL: + case LTTNG_TRACKING_POLICY_INCLUDE_ALL: + break; + default: + ret_code = LTTNG_ERR_INVALID; + goto end; } - rcu_read_lock(); - switch (domain) { case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_channel *kchan; - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - - /* - * If a non-default channel has been created in the - * session, explicitely require that -c chan_name needs - * to be provided. - */ - if (ksess->has_non_default_channel && channel_name[0] == '\0') { - ret = LTTNG_ERR_NEED_CHANNEL_NAME; - goto error_unlock; + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; } - - kchan = trace_kernel_get_channel_by_name(channel_name, ksess); - if (kchan == NULL) { - ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; - goto error_unlock; + ret_code = kernel_process_attr_tracker_set_tracking_policy( + session->kernel_session, process_attr, policy); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; } + ret_code = trace_ust_process_attr_tracker_set_tracking_policy( + session->ust_session, process_attr, policy); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +end: + return ret_code; +} - switch (event->type) { - case LTTNG_EVENT_ALL: - case LTTNG_EVENT_TRACEPOINT: - case LTTNG_EVENT_SYSCALL: - case LTTNG_EVENT_PROBE: +enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value( + struct ltt_session *session, + enum lttng_domain_type domain, + enum lttng_process_attr process_attr, + const struct process_attr_value *value) +{ + enum lttng_error_code ret_code = LTTNG_OK; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = kernel_process_attr_tracker_inclusion_set_add_value( + session->kernel_session, process_attr, value); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value( + session->ust_session, process_attr, value); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +end: + return ret_code; +} + +enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value( + struct ltt_session *session, + enum lttng_domain_type domain, + enum lttng_process_attr process_attr, + const struct process_attr_value *value) +{ + enum lttng_error_code ret_code = LTTNG_OK; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = kernel_process_attr_tracker_inclusion_set_remove_value( + session->kernel_session, process_attr, value); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value( + session->ust_session, process_attr, value); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +end: + return ret_code; +} + +enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set( + struct ltt_session *session, + enum lttng_domain_type domain, + enum lttng_process_attr process_attr, + struct lttng_process_attr_values **values) +{ + enum lttng_error_code ret_code = LTTNG_OK; + const struct process_attr_tracker *tracker; + enum process_attr_tracker_status status; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + tracker = kernel_get_process_attr_tracker( + session->kernel_session, process_attr); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + tracker = trace_ust_get_process_attr_tracker( + session->ust_session, process_attr); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + goto end; + } + + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + + status = process_attr_tracker_get_inclusion_set(tracker, values); + switch (status) { + case PROCESS_ATTR_TRACKER_STATUS_OK: + ret_code = LTTNG_OK; + break; + case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY: + ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY; + break; + case PROCESS_ATTR_TRACKER_STATUS_ERROR: + ret_code = LTTNG_ERR_NOMEM; + break; + default: + ret_code = LTTNG_ERR_UNK; + break; + } + +end: + return ret_code; +} + +/* + * Command LTTNG_DISABLE_EVENT processed by the client thread. + */ +int cmd_disable_event(struct command_ctx *cmd_ctx, + struct lttng_event *event, + char *filter_expression, + struct lttng_bytecode *bytecode, + struct lttng_event_exclusion *exclusion) +{ + int ret; + const char *event_name; + const struct ltt_session *session = cmd_ctx->session; + const char *channel_name = cmd_ctx->lsm.u.disable.channel_name; + const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type; + + DBG("Disable event command for event \'%s\'", event->name); + + /* + * Filter and exclusions are simply not handled by the + * disable event command at this time. + * + * FIXME + */ + (void) filter_expression; + (void) exclusion; + + /* Ignore the presence of filter or exclusion for the event */ + event->filter = 0; + event->exclusion = 0; + + event_name = event->name; + + /* Error out on unhandled search criteria */ + if (event->loglevel_type || event->loglevel != -1 || event->enabled + || event->pid || event->filter || event->exclusion) { + ret = LTTNG_ERR_UNK; + goto error; + } + + rcu_read_lock(); + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_channel *kchan; + struct ltt_kernel_session *ksess; + + ksess = session->kernel_session; + + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (ksess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error_unlock; + } + + kchan = trace_kernel_get_channel_by_name(channel_name, ksess); + if (kchan == NULL) { + ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; + goto error_unlock; + } + + switch (event->type) { + case LTTNG_EVENT_ALL: + case LTTNG_EVENT_TRACEPOINT: + case LTTNG_EVENT_SYSCALL: + case LTTNG_EVENT_PROBE: case LTTNG_EVENT_FUNCTION: case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */ if (event_name[0] == '\0') { @@ -1534,7 +1752,7 @@ int cmd_disable_event(struct ltt_session *session, goto error_unlock; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1638,21 +1856,31 @@ int cmd_disable_event(struct ltt_session *session, error_unlock: rcu_read_unlock(); error: + free(exclusion); + free(bytecode); + free(filter_expression); return ret; } /* * Command LTTNG_ADD_CONTEXT processed by the client thread. */ -int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, - char *channel_name, struct lttng_event_context *ctx, int kwpipe) +int cmd_add_context(struct command_ctx *cmd_ctx, + const struct lttng_event_context *event_context, int kwpipe) { int ret, chan_kern_created = 0, chan_ust_created = 0; - char *app_ctx_provider_name = NULL, *app_ctx_name = NULL; + const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type; + const struct ltt_session *session = cmd_ctx->session; + const char *channel_name = cmd_ctx->lsm.u.context.channel_name; - if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) { - app_ctx_provider_name = ctx->u.app_ctx.provider_name; - app_ctx_name = ctx->u.app_ctx.ctx_name; + /* + * Don't try to add a context if the session has been started at + * some point in time before. The tracer does not allow it and would + * result in a corrupted trace. + */ + if (cmd_ctx->session->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto end; } switch (domain) { @@ -1668,7 +1896,8 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, chan_kern_created = 1; } /* Add kernel context to kernel tracer */ - ret = context_kernel_add(session->kernel_session, ctx, channel_name); + ret = context_kernel_add(session->kernel_session, + event_context, channel_name); if (ret != LTTNG_OK) { goto error; } @@ -1722,11 +1951,8 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, chan_ust_created = 1; } - ret = context_ust_add(usess, domain, ctx, channel_name); - free(app_ctx_provider_name); - free(app_ctx_name); - app_ctx_name = NULL; - app_ctx_provider_name = NULL; + ret = context_ust_add(usess, domain, event_context, + channel_name); if (ret != LTTNG_OK) { goto error; } @@ -1763,8 +1989,6 @@ error: trace_ust_destroy_channel(uchan); } end: - free(app_ctx_provider_name); - free(app_ctx_name); return ret; } @@ -1806,10 +2030,10 @@ end: * enable the events through which all "agent" events are funeled. */ static int _cmd_enable_event(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, + struct lttng_bytecode *filter, struct lttng_event_exclusion *exclusion, int wpipe, bool internal_event) { @@ -1872,7 +2096,8 @@ static int _cmd_enable_event(struct ltt_session *session, goto error; } - ret = cmd_enable_channel(session, domain, attr, wpipe); + ret = cmd_enable_channel_internal( + session, domain, attr, wpipe); if (ret != LTTNG_OK) { goto error; } @@ -1892,7 +2117,7 @@ static int _cmd_enable_event(struct ltt_session *session, case LTTNG_EVENT_ALL: { char *filter_expression_a = NULL; - struct lttng_filter_bytecode *filter_a = NULL; + struct lttng_bytecode *filter_a = NULL; /* * We need to duplicate filter_expression and filter, @@ -1942,6 +2167,7 @@ static int _cmd_enable_event(struct ltt_session *session, break; } case LTTNG_EVENT_PROBE: + case LTTNG_EVENT_USERSPACE_PROBE: case LTTNG_EVENT_FUNCTION: case LTTNG_EVENT_FUNCTION_ENTRY: case LTTNG_EVENT_TRACEPOINT: @@ -1973,7 +2199,7 @@ static int _cmd_enable_event(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -2010,7 +2236,8 @@ static int _cmd_enable_event(struct ltt_session *session, goto error; } - ret = cmd_enable_channel(session, domain, attr, wpipe); + ret = cmd_enable_channel_internal( + session, domain, attr, wpipe); if (ret != LTTNG_OK) { goto error; } @@ -2038,9 +2265,8 @@ static int _cmd_enable_event(struct ltt_session *session, */ ret = validate_ust_event_name(event->name); if (ret) { - WARN("Userspace event name %s failed validation.", - event->name ? - event->name : "NULL"); + WARN("Userspace event name %s failed validation.", + event->name); ret = LTTNG_ERR_INVALID_EVENT_NAME; goto error; } @@ -2073,6 +2299,12 @@ static int _cmd_enable_event(struct ltt_session *session, assert(usess); + if (!agent_tracing_is_enabled()) { + DBG("Attempted to enable an event in an agent domain but the agent thread is not running"); + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } + agt = trace_ust_find_agent(usess, domain->type); if (!agt) { agt = agent_create(domain->type); @@ -2121,11 +2353,11 @@ static int _cmd_enable_event(struct ltt_session *session, { char *filter_expression_copy = NULL; - struct lttng_filter_bytecode *filter_copy = NULL; + struct lttng_bytecode *filter_copy = NULL; if (filter) { const size_t filter_size = sizeof( - struct lttng_filter_bytecode) + struct lttng_bytecode) + filter->len; filter_copy = zmalloc(filter_size); @@ -2197,15 +2429,35 @@ error: * Command LTTNG_ENABLE_EVENT processed by the client thread. * We own filter, exclusion, and filter_expression. */ -int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, - char *channel_name, struct lttng_event *event, +int cmd_enable_event(struct command_ctx *cmd_ctx, + struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, struct lttng_event_exclusion *exclusion, + struct lttng_bytecode *bytecode, int wpipe) { - return _cmd_enable_event(session, domain, channel_name, event, - filter_expression, filter, exclusion, wpipe, false); + int ret; + /* + * Copied to ensure proper alignment since 'lsm' is a packed structure. + */ + const struct lttng_domain command_domain = cmd_ctx->lsm.domain; + + /* + * The ownership of the following parameters is transferred to + * _cmd_enable_event: + * + * - filter_expression, + * - bytecode, + * - exclusion + */ + ret = _cmd_enable_event(cmd_ctx->session, + &command_domain, + cmd_ctx->lsm.u.enable.channel_name, event, + filter_expression, bytecode, exclusion, wpipe, false); + filter_expression = NULL; + bytecode = NULL; + exclusion = NULL; + return ret; } /* @@ -2214,10 +2466,10 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, * reserved names. */ static int cmd_enable_event_internal(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, + struct lttng_bytecode *filter, struct lttng_event_exclusion *exclusion, int wpipe) { @@ -2228,132 +2480,204 @@ static int cmd_enable_event_internal(struct ltt_session *session, /* * Command LTTNG_LIST_TRACEPOINTS processed by the client thread. */ -ssize_t cmd_list_tracepoints(enum lttng_domain_type domain, - struct lttng_event **events) +enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain, + struct lttng_payload *reply_payload) { + enum lttng_error_code ret_code; int ret; - ssize_t nb_events = 0; + ssize_t i, nb_events = 0; + struct lttng_event *events = NULL; + struct lttcomm_list_command_header reply_command_header = {}; + size_t reply_command_header_offset; + + assert(reply_payload); + + /* Reserve space for command reply header. */ + reply_command_header_offset = reply_payload->buffer.size; + ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer, + reply_command_header_offset + + sizeof(struct lttcomm_list_command_header)); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: - nb_events = kernel_list_events(kernel_tracer_fd, events); + nb_events = kernel_list_events(&events); if (nb_events < 0) { - ret = LTTNG_ERR_KERN_LIST_FAIL; + ret_code = LTTNG_ERR_KERN_LIST_FAIL; goto error; } break; case LTTNG_DOMAIN_UST: - nb_events = ust_app_list_events(events); + nb_events = ust_app_list_events(&events); if (nb_events < 0) { - ret = LTTNG_ERR_UST_LIST_FAIL; + ret_code = LTTNG_ERR_UST_LIST_FAIL; goto error; } break; case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_JUL: case LTTNG_DOMAIN_PYTHON: - nb_events = agent_list_events(events, domain); + nb_events = agent_list_events(&events, domain); if (nb_events < 0) { - ret = LTTNG_ERR_UST_LIST_FAIL; + ret_code = LTTNG_ERR_UST_LIST_FAIL; goto error; } break; default: - ret = LTTNG_ERR_UND; + ret_code = LTTNG_ERR_UND; + goto error; + } + + for (i = 0; i < nb_events; i++) { + ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL, + reply_payload); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + } + + if (nb_events > UINT32_MAX) { + ERR("Tracepoint count would overflow the tracepoint listing command's reply"); + ret_code = LTTNG_ERR_OVERFLOW; goto error; } - return nb_events; + /* Update command reply header. */ + reply_command_header.count = (uint32_t) nb_events; + memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header, + sizeof(reply_command_header)); + ret_code = LTTNG_OK; error: - /* Return negative value to differentiate return code */ - return -ret; + free(events); + return ret_code; } /* * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread. */ -ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain, - struct lttng_event_field **fields) +enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain, + struct lttng_payload *reply) { + enum lttng_error_code ret_code; int ret; - ssize_t nb_fields = 0; + unsigned int i, nb_fields; + struct lttng_event_field *fields = NULL; + struct lttcomm_list_command_header reply_command_header = {}; + size_t reply_command_header_offset; + + assert(reply); + + /* Reserve space for command reply header. */ + reply_command_header_offset = reply->buffer.size; + ret = lttng_dynamic_buffer_set_size(&reply->buffer, + reply_command_header_offset + + sizeof(struct lttcomm_list_command_header)); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } switch (domain) { case LTTNG_DOMAIN_UST: - nb_fields = ust_app_list_event_fields(fields); - if (nb_fields < 0) { - ret = LTTNG_ERR_UST_LIST_FAIL; + ret = ust_app_list_event_fields(&fields); + if (ret < 0) { + ret_code = LTTNG_ERR_UST_LIST_FAIL; goto error; } + break; case LTTNG_DOMAIN_KERNEL: default: /* fall-through */ - ret = LTTNG_ERR_UND; + ret_code = LTTNG_ERR_UND; goto error; } - return nb_fields; + nb_fields = ret; -error: - /* Return negative value to differentiate return code */ - return -ret; -} + for (i = 0; i < nb_fields; i++) { + ret = lttng_event_field_serialize(&fields[i], reply); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + } -ssize_t cmd_list_syscalls(struct lttng_event **events) -{ - return syscall_table_list(events); + if (nb_fields > UINT32_MAX) { + ERR("Tracepoint field count would overflow the tracepoint field listing command's reply"); + ret_code = LTTNG_ERR_OVERFLOW; + goto error; + } + + /* Update command reply header. */ + reply_command_header.count = (uint32_t) nb_fields; + + memcpy(reply->buffer.data + reply_command_header_offset, &reply_command_header, + sizeof(reply_command_header)); + + ret_code = LTTNG_OK; + +error: + free(fields); + return ret_code; } -/* - * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread. - * - * Called with session lock held. - */ -ssize_t cmd_list_tracker_pids(struct ltt_session *session, - enum lttng_domain_type domain, int32_t **pids) +enum lttng_error_code cmd_list_syscalls( + struct lttng_payload *reply_payload) { + enum lttng_error_code ret_code; + ssize_t nb_events, i; int ret; - ssize_t nr_pids = 0; + struct lttng_event *events = NULL; + struct lttcomm_list_command_header reply_command_header = {}; + size_t reply_command_header_offset; - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; + assert(reply_payload); - ksess = session->kernel_session; - nr_pids = kernel_list_tracker_pids(ksess, pids); - if (nr_pids < 0) { - ret = LTTNG_ERR_KERN_LIST_FAIL; - goto error; - } - break; + /* Reserve space for command reply header. */ + reply_command_header_offset = reply_payload->buffer.size; + ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer, + reply_command_header_offset + + sizeof(struct lttcomm_list_command_header)); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - usess = session->ust_session; - nr_pids = trace_ust_list_tracker_pids(usess, pids); - if (nr_pids < 0) { - ret = LTTNG_ERR_UST_LIST_FAIL; - goto error; + nb_events = syscall_table_list(&events); + if (nb_events < 0) { + ret_code = (enum lttng_error_code) -nb_events; + goto end; + } + + for (i = 0; i < nb_events; i++) { + ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL, + reply_payload); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; } - break; } - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_PYTHON: - default: - ret = LTTNG_ERR_UND; - goto error; + + if (nb_events > UINT32_MAX) { + ERR("Syscall count would overflow the syscall listing command's reply"); + ret_code = LTTNG_ERR_OVERFLOW; + goto end; } - return nr_pids; + /* Update command reply header. */ + reply_command_header.count = (uint32_t) nb_events; + memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header, + sizeof(reply_command_header)); -error: - /* Return negative value to differentiate return code */ - return -ret; + ret_code = LTTNG_OK; +end: + free(events); + return ret_code; } /* @@ -2363,10 +2687,14 @@ error: */ int cmd_start_trace(struct ltt_session *session) { - int ret; + enum lttng_error_code ret; unsigned long nb_chan = 0; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; + const bool session_rotated_after_last_stop = + session->rotated_after_last_stop; + const bool session_cleared_after_last_stop = + session->cleared_after_last_stop; assert(session); @@ -2377,6 +2705,23 @@ int cmd_start_trace(struct ltt_session *session) /* Is the session already started? */ if (session->active) { ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + /* Perform nothing */ + goto end; + } + + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING && + !session->current_trace_chunk) { + /* + * A rotation was launched while the session was stopped and + * it has not been completed yet. It is not possible to start + * the session since starting the session here would require a + * rotation from "NULL" to a new trace chunk. That rotation + * would overlap with the ongoing rotation, which is not + * supported. + */ + WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing", + session->name); + ret = LTTNG_ERR_ROTATION_PENDING; goto error; } @@ -2395,9 +2740,54 @@ int cmd_start_trace(struct ltt_session *session) goto error; } + session->active = 1; + session->rotated_after_last_stop = false; + session->cleared_after_last_stop = false; + if (session->output_traces && !session->current_trace_chunk) { + if (!session->has_been_started) { + struct lttng_trace_chunk *trace_chunk; + + DBG("Creating initial trace chunk of session \"%s\"", + session->name); + trace_chunk = session_create_new_trace_chunk( + session, NULL, NULL, NULL); + if (!trace_chunk) { + ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + assert(!session->current_trace_chunk); + ret = session_set_trace_chunk(session, trace_chunk, + NULL); + lttng_trace_chunk_put(trace_chunk); + if (ret) { + ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + } else { + DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk", + session->name); + /* + * Rotate existing streams into the new chunk. + * This is a "quiet" rotation has no client has + * explicitly requested this operation. + * + * There is also no need to wait for the rotation + * to complete as it will happen immediately. No data + * was produced as the session was stopped, so the + * rotation should happen on reception of the command. + */ + ret = cmd_rotate_session(session, NULL, true, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION); + if (ret != LTTNG_OK) { + goto error; + } + } + } + /* Kernel tracing */ if (ksession != NULL) { - ret = start_kernel_session(ksession, kernel_tracer_fd); + DBG("Start kernel tracing session %s", session->name); + ret = start_kernel_session(ksession); if (ret != LTTNG_OK) { goto error; } @@ -2405,26 +2795,56 @@ int cmd_start_trace(struct ltt_session *session) /* Flag session that trace should start automatically */ if (usess) { - /* - * Even though the start trace might fail, flag this session active so - * other application coming in are started by default. - */ - usess->active = 1; + int int_ret = ust_app_start_trace_all(usess); - ret = ust_app_start_trace_all(usess); - if (ret < 0) { + if (int_ret < 0) { ret = LTTNG_ERR_UST_START_FAIL; goto error; } } - /* Flag this after a successful start. */ - session->has_been_started = 1; - session->active = 1; + /* + * Open a packet in every stream of the session to ensure that viewers + * can correctly identify the boundaries of the periods during which + * tracing was active for this session. + */ + ret = session_open_packets(session); + if (ret != LTTNG_OK) { + goto error; + } + + /* + * Clear the flag that indicates that a rotation was done while the + * session was stopped. + */ + session->rotated_after_last_stop = false; + + if (session->rotate_timer_period) { + int int_ret = timer_session_rotation_schedule_timer_start( + session, session->rotate_timer_period); + + if (int_ret < 0) { + ERR("Failed to enable rotate timer"); + ret = LTTNG_ERR_UNK; + goto error; + } + } ret = LTTNG_OK; error: + if (ret == LTTNG_OK) { + /* Flag this after a successful start. */ + session->has_been_started |= 1; + } else { + session->active = 0; + /* Restore initial state on error. */ + session->rotated_after_last_stop = + session_rotated_after_last_stop; + session->cleared_after_last_stop = + session_cleared_after_last_stop; + } +end: return ret; } @@ -2434,12 +2854,12 @@ error: int cmd_stop_trace(struct ltt_session *session) { int ret; - struct ltt_kernel_channel *kchan; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; assert(session); + DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id); /* Short cut */ ksession = session->kernel_session; usess = session->ust_session; @@ -2450,44 +2870,12 @@ int cmd_stop_trace(struct ltt_session *session) goto error; } - /* Kernel tracer */ - if (ksession && ksession->active) { - DBG("Stop kernel tracing"); - - ret = kernel_stop_session(ksession); - if (ret < 0) { - ret = LTTNG_ERR_KERN_STOP_FAIL; - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - - /* Flush metadata after stopping (if exists) */ - if (ksession->metadata_stream_fd >= 0) { - ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd); - if (ret < 0) { - ERR("Kernel metadata flush failed"); - } - } - - /* Flush all buffers after stopping */ - cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) { - ret = kernel_flush_buffer(kchan); - if (ret < 0) { - ERR("Kernel flush buffer error"); - } - } - - ksession->active = 0; + ret = stop_kernel_session(ksession); + if (ret != LTTNG_OK) { + goto error; } if (usess && usess->active) { - /* - * Even though the stop trace might fail, flag this session inactive so - * other application coming in are not started by default. - */ - usess->active = 0; - ret = ust_app_stop_trace_all(usess); if (ret < 0) { ret = LTTNG_ERR_UST_STOP_FAIL; @@ -2495,6 +2883,8 @@ int cmd_stop_trace(struct ltt_session *session) } } + DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name, + session->id); /* Flag inactive after a successful stop. */ session->active = 0; ret = LTTNG_OK; @@ -2503,6 +2893,45 @@ error: return ret; } +/* + * Set the base_path of the session only if subdir of a control uris is set. + * Return LTTNG_OK on success, otherwise LTTNG_ERR_*. + */ +static int set_session_base_path_from_uris(struct ltt_session *session, + size_t nb_uri, + struct lttng_uri *uris) +{ + int ret; + size_t i; + + for (i = 0; i < nb_uri; i++) { + if (uris[i].stype != LTTNG_STREAM_CONTROL || + uris[i].subdir[0] == '\0') { + /* Not interested in these URIs */ + continue; + } + + if (session->base_path != NULL) { + free(session->base_path); + session->base_path = NULL; + } + + /* Set session base_path */ + session->base_path = strdup(uris[i].subdir); + if (!session->base_path) { + PERROR("Failed to copy base path \"%s\" to session \"%s\"", + uris[i].subdir, session->name); + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG2("Setting base path \"%s\" for session \"%s\"", + session->base_path, session->name); + } + ret = LTTNG_OK; +error: + return ret; +} + /* * Command LTTNG_SET_CONSUMER_URI processed by the client thread. */ @@ -2523,10 +2952,20 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, goto error; } + /* + * Set the session base path if any. This is done inside + * cmd_set_consumer_uri to preserve backward compatibility of the + * previous session creation api vs the session descriptor api. + */ + ret = set_session_base_path_from_uris(session, nb_uri, uris); + if (ret != LTTNG_OK) { + goto error; + } + /* Set the "global" consumer URIs */ for (i = 0; i < nb_uri; i++) { - ret = add_uri_to_consumer(session->consumer, - &uris[i], 0, session->name); + ret = add_uri_to_consumer(session, session->consumer, &uris[i], + LTTNG_DOMAIN_NONE); if (ret != LTTNG_OK) { goto error; } @@ -2535,10 +2974,9 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, /* Set UST session URIs */ if (session->ust_session) { for (i = 0; i < nb_uri; i++) { - ret = add_uri_to_consumer( + ret = add_uri_to_consumer(session, session->ust_session->consumer, - &uris[i], LTTNG_DOMAIN_UST, - session->name); + &uris[i], LTTNG_DOMAIN_UST); if (ret != LTTNG_OK) { goto error; } @@ -2548,10 +2986,9 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, /* Set kernel session URIs */ if (session->kernel_session) { for (i = 0; i < nb_uri; i++) { - ret = add_uri_to_consumer( + ret = add_uri_to_consumer(session, session->kernel_session->consumer, - &uris[i], LTTNG_DOMAIN_KERNEL, - session->name); + &uris[i], LTTNG_DOMAIN_KERNEL); if (ret != LTTNG_OK) { goto error; } @@ -2578,142 +3015,346 @@ error: return ret; } -/* - * Command LTTNG_CREATE_SESSION processed by the client thread. - */ -int cmd_create_session_uri(char *name, struct lttng_uri *uris, - size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer) +static +enum lttng_error_code set_session_output_from_descriptor( + struct ltt_session *session, + const struct lttng_session_descriptor *descriptor) { int ret; - struct ltt_session *session; + enum lttng_error_code ret_code = LTTNG_OK; + enum lttng_session_descriptor_type session_type = + lttng_session_descriptor_get_type(descriptor); + enum lttng_session_descriptor_output_type output_type = + lttng_session_descriptor_get_output_type(descriptor); + struct lttng_uri uris[2] = {}; + size_t uri_count = 0; + + switch (output_type) { + case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE: + goto end; + case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL: + lttng_session_descriptor_get_local_output_uri(descriptor, + &uris[0]); + uri_count = 1; + break; + case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK: + lttng_session_descriptor_get_network_output_uris(descriptor, + &uris[0], &uris[1]); + uri_count = 2; + break; + default: + ret_code = LTTNG_ERR_INVALID; + goto end; + } - assert(name); - assert(creds); + switch (session_type) { + case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT: + { + struct snapshot_output *new_output = NULL; - /* - * Verify if the session already exist - * - * XXX: There is no need for the session lock list here since the caller - * (process_client_msg) is holding it. We might want to change that so a - * single command does not lock the entire session list. - */ - session = session_find_by_name(name); - if (session != NULL) { - ret = LTTNG_ERR_EXIST_SESS; - goto find_error; + new_output = snapshot_output_alloc(); + if (!new_output) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + ret = snapshot_output_init_with_uri(session, + DEFAULT_SNAPSHOT_MAX_SIZE, + NULL, uris, uri_count, session->consumer, + new_output, &session->snapshot); + if (ret < 0) { + ret_code = (ret == -ENOMEM) ? + LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID; + snapshot_output_destroy(new_output); + goto end; + } + snapshot_add_output(&session->snapshot, new_output); + break; + } + case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR: + case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE: + { + ret_code = cmd_set_consumer_uri(session, uri_count, uris); + break; + } + default: + ret_code = LTTNG_ERR_INVALID; + goto end; } +end: + return ret_code; +} - /* Create tracing session in the registry */ - ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds), - LTTNG_SOCK_GET_GID_CRED(creds)); - if (ret != LTTNG_OK) { - goto session_error; +static +enum lttng_error_code cmd_create_session_from_descriptor( + struct lttng_session_descriptor *descriptor, + const lttng_sock_cred *creds, + const char *home_path) +{ + int ret; + enum lttng_error_code ret_code; + const char *session_name; + struct ltt_session *new_session = NULL; + enum lttng_session_descriptor_status descriptor_status; + + session_lock_list(); + if (home_path) { + if (*home_path != '/') { + ERR("Home path provided by client is not absolute"); + ret_code = LTTNG_ERR_INVALID; + goto end; + } } - /* - * Get the newly created session pointer back - * - * XXX: There is no need for the session lock list here since the caller - * (process_client_msg) is holding it. We might want to change that so a - * single command does not lock the entire session list. - */ - session = session_find_by_name(name); - assert(session); + descriptor_status = lttng_session_descriptor_get_session_name( + descriptor, &session_name); + switch (descriptor_status) { + case LTTNG_SESSION_DESCRIPTOR_STATUS_OK: + break; + case LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET: + session_name = NULL; + break; + default: + ret_code = LTTNG_ERR_INVALID; + goto end; + } - session->live_timer = live_timer; - /* Create default consumer output for the session not yet created. */ - session->consumer = consumer_create_output(CONSUMER_DST_LOCAL); - if (session->consumer == NULL) { - ret = LTTNG_ERR_FATAL; - goto consumer_error; + ret_code = session_create(session_name, creds->uid, creds->gid, + &new_session); + if (ret_code != LTTNG_OK) { + goto end; } - if (uris) { - ret = cmd_set_consumer_uri(session, nb_uri, uris); - if (ret != LTTNG_OK) { - goto consumer_error; + if (!session_name) { + ret = lttng_session_descriptor_set_session_name(descriptor, + new_session->name); + if (ret) { + ret_code = LTTNG_ERR_SESSION_FAIL; + goto end; } - session->output_traces = 1; - } else { - session->output_traces = 0; - DBG2("Session %s created with no output", session->name); } - session->consumer->enabled = 1; + if (!lttng_session_descriptor_is_output_destination_initialized( + descriptor)) { + /* + * Only include the session's creation time in the output + * destination if the name of the session itself was + * not auto-generated. + */ + ret_code = lttng_session_descriptor_set_default_output( + descriptor, + session_name ? &new_session->creation_time : NULL, + home_path); + if (ret_code != LTTNG_OK) { + goto end; + } + } else { + new_session->has_user_specified_directory = + lttng_session_descriptor_has_output_directory( + descriptor); + } - return LTTNG_OK; + switch (lttng_session_descriptor_get_type(descriptor)) { + case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT: + new_session->snapshot_mode = 1; + break; + case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE: + new_session->live_timer = + lttng_session_descriptor_live_get_timer_interval( + descriptor); + break; + default: + break; + } -consumer_error: - session_destroy(session); -session_error: -find_error: - return ret; + ret_code = set_session_output_from_descriptor(new_session, descriptor); + if (ret_code != LTTNG_OK) { + goto end; + } + new_session->consumer->enabled = 1; + ret_code = LTTNG_OK; +end: + /* Release reference provided by the session_create function. */ + session_put(new_session); + if (ret_code != LTTNG_OK && new_session) { + /* Release the global reference on error. */ + session_destroy(new_session); + } + session_unlock_list(); + return ret_code; } -/* - * Command LTTNG_CREATE_SESSION_SNAPSHOT processed by the client thread. - */ -int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, - size_t nb_uri, lttng_sock_cred *creds) +enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, + struct lttng_session_descriptor **return_descriptor) { int ret; - struct ltt_session *session; - struct snapshot_output *new_output = NULL; + size_t payload_size; + struct lttng_dynamic_buffer payload; + struct lttng_buffer_view home_dir_view; + struct lttng_buffer_view session_descriptor_view; + struct lttng_session_descriptor *session_descriptor = NULL; + enum lttng_error_code ret_code; + + lttng_dynamic_buffer_init(&payload); + if (cmd_ctx->lsm.u.create_session.home_dir_size >= + LTTNG_PATH_MAX) { + ret_code = LTTNG_ERR_INVALID; + goto error; + } + if (cmd_ctx->lsm.u.create_session.session_descriptor_size > + LTTNG_SESSION_DESCRIPTOR_MAX_LEN) { + ret_code = LTTNG_ERR_INVALID; + goto error; + } - assert(name); - assert(creds); + payload_size = cmd_ctx->lsm.u.create_session.home_dir_size + + cmd_ctx->lsm.u.create_session.session_descriptor_size; + ret = lttng_dynamic_buffer_set_size(&payload, payload_size); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto error; + } - /* - * Create session in no output mode with URIs set to NULL. The uris we've - * received are for a default snapshot output if one. - */ - ret = cmd_create_session_uri(name, NULL, 0, creds, 0); - if (ret != LTTNG_OK) { + ret = lttcomm_recv_unix_sock(sock, payload.data, payload.size); + if (ret <= 0) { + ERR("Reception of session descriptor failed, aborting."); + ret_code = LTTNG_ERR_SESSION_FAIL; goto error; } - /* Get the newly created session pointer back. This should NEVER fail. */ - session = session_find_by_name(name); - assert(session); + home_dir_view = lttng_buffer_view_from_dynamic_buffer( + &payload, + 0, + cmd_ctx->lsm.u.create_session.home_dir_size); + if (cmd_ctx->lsm.u.create_session.home_dir_size > 0 && + !lttng_buffer_view_is_valid(&home_dir_view)) { + ERR("Invalid payload in \"create session\" command: buffer too short to contain home directory"); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto error; + } - /* Flag session for snapshot mode. */ - session->snapshot_mode = 1; + session_descriptor_view = lttng_buffer_view_from_dynamic_buffer( + &payload, + cmd_ctx->lsm.u.create_session.home_dir_size, + cmd_ctx->lsm.u.create_session.session_descriptor_size); + if (!lttng_buffer_view_is_valid(&session_descriptor_view)) { + ERR("Invalid payload in \"create session\" command: buffer too short to contain session descriptor"); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto error; + } - /* Skip snapshot output creation if no URI is given. */ - if (nb_uri == 0) { - goto end; + ret = lttng_session_descriptor_create_from_buffer( + &session_descriptor_view, &session_descriptor); + if (ret < 0) { + ERR("Failed to create session descriptor from payload of \"create session\" command"); + ret_code = LTTNG_ERR_INVALID; + goto error; } - new_output = snapshot_output_alloc(); - if (!new_output) { - ret = LTTNG_ERR_NOMEM; - goto error_snapshot_alloc; + /* + * Sets the descriptor's auto-generated properties (name, output) if + * needed. + */ + ret_code = cmd_create_session_from_descriptor(session_descriptor, + &cmd_ctx->creds, + home_dir_view.size ? home_dir_view.data : NULL); + if (ret_code != LTTNG_OK) { + goto error; } - ret = snapshot_output_init_with_uri(DEFAULT_SNAPSHOT_MAX_SIZE, NULL, - uris, nb_uri, session->consumer, new_output, &session->snapshot); - if (ret < 0) { - if (ret == -ENOMEM) { - ret = LTTNG_ERR_NOMEM; - } else { - ret = LTTNG_ERR_INVALID; - } - goto error_snapshot; + ret_code = LTTNG_OK; + *return_descriptor = session_descriptor; + session_descriptor = NULL; +error: + lttng_dynamic_buffer_reset(&payload); + lttng_session_descriptor_destroy(session_descriptor); + return ret_code; +} + +static +void cmd_destroy_session_reply(const struct ltt_session *session, + void *_reply_context) +{ + int ret; + ssize_t comm_ret; + const struct cmd_destroy_session_reply_context *reply_context = + _reply_context; + struct lttng_dynamic_buffer payload; + struct lttcomm_session_destroy_command_header cmd_header; + struct lttng_trace_archive_location *location = NULL; + struct lttcomm_lttng_msg llm = { + .cmd_type = LTTNG_DESTROY_SESSION, + .ret_code = reply_context->destruction_status, + .pid = UINT32_MAX, + .cmd_header_size = + sizeof(struct lttcomm_session_destroy_command_header), + .data_size = 0, + }; + size_t payload_size_before_location; + + lttng_dynamic_buffer_init(&payload); + + ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm)); + if (ret) { + ERR("Failed to append session destruction message"); + goto error; } - rcu_read_lock(); - snapshot_add_output(&session->snapshot, new_output); - rcu_read_unlock(); + cmd_header.rotation_state = + (int32_t) (reply_context->implicit_rotation_on_destroy ? + session->rotation_state : + LTTNG_ROTATION_STATE_NO_ROTATION); + ret = lttng_dynamic_buffer_append(&payload, &cmd_header, + sizeof(cmd_header)); + if (ret) { + ERR("Failed to append session destruction command header"); + goto error; + } -end: - return LTTNG_OK; + if (!reply_context->implicit_rotation_on_destroy) { + DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply", + session->name); + goto send_reply; + } + if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) { + DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply", + session->name); + goto send_reply; + } -error_snapshot: - snapshot_output_destroy(new_output); -error_snapshot_alloc: - session_destroy(session); + location = session_get_trace_archive_location(session); + if (!location) { + ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"", + session->name); + goto error; + } + + payload_size_before_location = payload.size; + comm_ret = lttng_trace_archive_location_serialize(location, + &payload); + lttng_trace_archive_location_put(location); + if (comm_ret < 0) { + ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"", + session->name); + goto error; + } + /* Update the message to indicate the location's length. */ + ((struct lttcomm_lttng_msg *) payload.data)->data_size = + payload.size - payload_size_before_location; +send_reply: + comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd, + payload.data, payload.size); + if (comm_ret != (ssize_t) payload.size) { + ERR("Failed to send result of the destruction of session \"%s\" to client", + session->name); + } error: - return ret; + ret = close(reply_context->reply_sock_fd); + if (ret) { + PERROR("Failed to close client socket in deferred session destroy reply"); + } + lttng_dynamic_buffer_reset(&payload); + free(_reply_context); } /* @@ -2721,47 +3362,170 @@ error: * * Called with session lock held. */ -int cmd_destroy_session(struct ltt_session *session, int wpipe) +int cmd_destroy_session(struct ltt_session *session, + struct notification_thread_handle *notification_thread_handle, + int *sock_fd) { int ret; - struct ltt_ust_session *usess; - struct ltt_kernel_session *ksess; + enum lttng_error_code destruction_last_error = LTTNG_OK; + struct cmd_destroy_session_reply_context *reply_context = NULL; + + if (sock_fd) { + reply_context = zmalloc(sizeof(*reply_context)); + if (!reply_context) { + ret = LTTNG_ERR_NOMEM; + goto end; + } + reply_context->reply_sock_fd = *sock_fd; + } /* Safety net */ assert(session); - usess = session->ust_session; - ksess = session->kernel_session; + DBG("Begin destroy session %s (id %" PRIu64 ")", session->name, + session->id); + if (session->active) { + DBG("Session \"%s\" is active, attempting to stop it before destroying it", + session->name); + ret = cmd_stop_trace(session); + if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) { + /* Carry on with the destruction of the session. */ + ERR("Failed to stop session \"%s\" as part of its destruction: %s", + session->name, lttng_strerror(-ret)); + destruction_last_error = ret; + } + } - /* Clean kernel session teardown */ - kernel_destroy_session(ksess); + if (session->rotation_schedule_timer_enabled) { + if (timer_session_rotation_schedule_timer_stop( + session)) { + ERR("Failed to stop the \"rotation schedule\" timer of session %s", + session->name); + destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR; + } + } - /* UST session teardown */ - if (usess) { - /* Close any relayd session */ - consumer_output_send_destroy_relayd(usess->consumer); + if (session->rotate_size) { + unsubscribe_session_consumed_size_rotation(session, notification_thread_handle); + session->rotate_size = 0; + } - /* Destroy every UST application related to this session. */ - ret = ust_app_destroy_trace_all(usess); - if (ret) { - ERR("Error in ust_app_destroy_trace_all"); + if (session->rotated && session->current_trace_chunk && session->output_traces) { + /* + * Perform a last rotation on destruction if rotations have + * occurred during the session's lifetime. + */ + ret = cmd_rotate_session(session, NULL, false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); + if (ret != LTTNG_OK) { + ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s", + session->name, lttng_strerror(-ret)); + destruction_last_error = -ret; + } + if (reply_context) { + reply_context->implicit_rotation_on_destroy = true; + } + } else if (session->has_been_started && session->current_trace_chunk) { + /* + * The user has not triggered a session rotation. However, to + * ensure all data has been consumed, the session is rotated + * to a 'null' trace chunk before it is destroyed. + * + * This is a "quiet" rotation meaning that no notification is + * emitted and no renaming of the current trace chunk takes + * place. + */ + ret = cmd_rotate_session(session, NULL, true, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION); + /* + * Rotation operations may not be supported by the kernel + * tracer. Hence, do not consider this implicit rotation as + * a session destruction error. The library has already stopped + * the session and waited for pending data; there is nothing + * left to do but complete the destruction of the session. + */ + if (ret != LTTNG_OK && + ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) { + ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s", + session->name, lttng_strerror(ret)); + destruction_last_error = -ret; } + } - /* Clean up the rest. */ - trace_ust_destroy_session(usess); + if (session->shm_path[0]) { + /* + * When a session is created with an explicit shm_path, + * the consumer daemon will create its shared memory files + * at that location and will *not* unlink them. This is normal + * as the intention of that feature is to make it possible + * to retrieve the content of those files should a crash occur. + * + * To ensure the content of those files can be used, the + * sessiond daemon will replicate the content of the metadata + * cache in a metadata file. + * + * On clean-up, it is expected that the consumer daemon will + * unlink the shared memory files and that the session daemon + * will unlink the metadata file. Then, the session's directory + * in the shm path can be removed. + * + * Unfortunately, a flaw in the design of the sessiond's and + * consumerd's tear down of channels makes it impossible to + * determine when the sessiond _and_ the consumerd have both + * destroyed their representation of a channel. For one, the + * unlinking, close, and rmdir happen in deferred 'call_rcu' + * callbacks in both daemons. + * + * However, it is also impossible for the sessiond to know when + * the consumer daemon is done destroying its channel(s) since + * it occurs as a reaction to the closing of the channel's file + * descriptor. There is no resulting communication initiated + * from the consumerd to the sessiond to confirm that the + * operation is completed (and was successful). + * + * Until this is all fixed, the session daemon checks for the + * removal of the session's shm path which makes it possible + * to safely advertise a session as having been destroyed. + * + * Prior to this fix, it was not possible to reliably save + * a session making use of the --shm-path option, destroy it, + * and load it again. This is because the creation of the + * session would fail upon seeing the session's shm path + * already in existence. + * + * Note that none of the error paths in the check for the + * directory's existence return an error. This is normal + * as there isn't much that can be done. The session will + * be destroyed properly, except that we can't offer the + * guarantee that the same session can be re-created. + */ + current_completion_handler = &destroy_completion_handler.handler; + ret = lttng_strncpy(destroy_completion_handler.shm_path, + session->shm_path, + sizeof(destroy_completion_handler.shm_path)); + assert(!ret); } /* - * Must notify the kernel thread here to update it's poll set in order to - * remove the channel(s)' fd just destroyed. + * The session is destroyed. However, note that the command context + * still holds a reference to the session, thus delaying its destruction + * _at least_ up to the point when that reference is released. */ - ret = notify_thread_pipe(wpipe); - if (ret < 0) { - PERROR("write kernel poll pipe"); + session_destroy(session); + if (reply_context) { + reply_context->destruction_status = destruction_last_error; + ret = session_add_destroy_notifier(session, + cmd_destroy_session_reply, + (void *) reply_context); + if (ret) { + ret = LTTNG_ERR_FATAL; + goto end; + } else { + *sock_fd = -1; + } } - - ret = session_destroy(session); - + ret = LTTNG_OK; +end: return ret; } @@ -2921,94 +3685,182 @@ error: /* * Command LTTNG_LIST_CHANNELS processed by the client thread. */ -ssize_t cmd_list_channels(enum lttng_domain_type domain, - struct ltt_session *session, struct lttng_channel **channels) +enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, + struct ltt_session *session, + struct lttng_payload *payload) { - ssize_t nb_chan = 0, payload_size = 0, ret; + int ret = 0; + unsigned int i = 0; + struct lttcomm_list_command_header cmd_header = {}; + size_t cmd_header_offset; + enum lttng_error_code ret_code; + + assert(session); + assert(payload); + + DBG("Listing channels for session %s", session->name); + + cmd_header_offset = payload->buffer.size; + + /* Reserve space for command reply header. */ + ret = lttng_dynamic_buffer_set_size(&payload->buffer, + cmd_header_offset + sizeof(cmd_header)); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: + { + /* Kernel channels */ + struct ltt_kernel_channel *kchan; if (session->kernel_session != NULL) { - nb_chan = session->kernel_session->channel_count; - } - DBG3("Number of kernel channels %zd", nb_chan); - if (nb_chan <= 0) { - ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND; - goto end; - } - break; - case LTTNG_DOMAIN_UST: - if (session->ust_session != NULL) { - rcu_read_lock(); - nb_chan = lttng_ht_get_count( - session->ust_session->domain_global.channels); - rcu_read_unlock(); - } - DBG3("Number of UST global channels %zd", nb_chan); - if (nb_chan < 0) { - ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto end; + cds_list_for_each_entry(kchan, + &session->kernel_session->channel_list.head, list) { + uint64_t discarded_events, lost_packets; + struct lttng_channel_extended *extended; + + extended = (struct lttng_channel_extended *) + kchan->channel->attr.extended.ptr; + + ret = get_kernel_runtime_stats(session, kchan, + &discarded_events, &lost_packets); + if (ret < 0) { + ret_code = LTTNG_ERR_UNK; + goto end; + } + + /* + * Update the discarded_events and lost_packets + * count for the channel + */ + extended->discarded_events = discarded_events; + extended->lost_packets = lost_packets; + + ret = lttng_channel_serialize( + kchan->channel, &payload->buffer); + if (ret) { + ERR("Failed to serialize lttng_channel: channel name = '%s'", + kchan->channel->name); + ret_code = LTTNG_ERR_UNK; + goto end; + } + + i++; + } } break; - default: - ret = -LTTNG_ERR_UND; - goto end; } + case LTTNG_DOMAIN_UST: + { + struct lttng_ht_iter iter; + struct ltt_ust_channel *uchan; + + rcu_read_lock(); + cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht, + &iter.iter, uchan, node.node) { + uint64_t discarded_events = 0, lost_packets = 0; + struct lttng_channel *channel = NULL; + struct lttng_channel_extended *extended; - if (nb_chan > 0) { - const size_t channel_size = sizeof(struct lttng_channel) + - sizeof(struct lttng_channel_extended); - struct lttng_channel_extended *channel_exts; + channel = trace_ust_channel_to_lttng_channel(uchan); + if (!channel) { + ret = LTTNG_ERR_NOMEM; + break; + } - payload_size = nb_chan * channel_size; - *channels = zmalloc(payload_size); - if (*channels == NULL) { - ret = -LTTNG_ERR_FATAL; - goto end; - } + extended = (struct lttng_channel_extended *) + channel->attr.extended.ptr; - channel_exts = ((void *) *channels) + - (nb_chan * sizeof(struct lttng_channel)); - ret = list_lttng_channels(domain, session, *channels, channel_exts); - if (ret != LTTNG_OK) { - free(*channels); - *channels = NULL; - goto end; + ret = get_ust_runtime_stats(session, uchan, + &discarded_events, &lost_packets); + if (ret < 0) { + lttng_channel_destroy(channel); + ret_code = LTTNG_ERR_UNK; + break; + } + + extended->discarded_events = discarded_events; + extended->lost_packets = lost_packets; + + ret = lttng_channel_serialize( + channel, &payload->buffer); + if (ret) { + ERR("Failed to serialize lttng_channel: channel name = '%s'", + channel->name); + ret_code = LTTNG_ERR_UNK; + ret = -1; + break; + } + + i++; } - } else { - *channels = NULL; + rcu_read_unlock(); + break; + } + default: + break; } - ret = payload_size; + if (i > UINT32_MAX) { + ERR("Channel count would overflow the channel listing command's reply"); + ret_code = LTTNG_ERR_OVERFLOW; + goto end; + } + + /* Update command reply header. */ + cmd_header.count = (uint32_t) i; + memcpy(payload->buffer.data + cmd_header_offset, &cmd_header, + sizeof(cmd_header)); + ret_code = LTTNG_OK; + end: - return ret; + return ret_code; } /* * Command LTTNG_LIST_EVENTS processed by the client thread. */ -ssize_t cmd_list_events(enum lttng_domain_type domain, - struct ltt_session *session, char *channel_name, - struct lttng_event **events, size_t *total_size) +enum lttng_error_code cmd_list_events(enum lttng_domain_type domain, + struct ltt_session *session, + char *channel_name, + struct lttng_payload *reply_payload) { - int ret = 0; - ssize_t nb_event = 0; + int buffer_resize_ret; + enum lttng_error_code ret_code = LTTNG_OK; + struct lttcomm_list_command_header reply_command_header = {}; + size_t reply_command_header_offset; + unsigned int nb_events = 0; + + assert(reply_payload); + + /* Reserve space for command reply header. */ + reply_command_header_offset = reply_payload->buffer.size; + buffer_resize_ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer, + reply_command_header_offset + + sizeof(struct lttcomm_list_command_header)); + if (buffer_resize_ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: if (session->kernel_session != NULL) { - nb_event = list_lttng_kernel_events(channel_name, - session->kernel_session, events, - total_size); + ret_code = list_lttng_kernel_events(channel_name, + session->kernel_session, reply_payload, &nb_events); } + break; case LTTNG_DOMAIN_UST: { if (session->ust_session != NULL) { - nb_event = list_lttng_ust_global_events(channel_name, - &session->ust_session->domain_global, events, - total_size); + ret_code = list_lttng_ust_global_events(channel_name, + &session->ust_session->domain_global, + reply_payload, &nb_events); } + break; } case LTTNG_DOMAIN_LOG4J: @@ -3022,25 +3874,32 @@ ssize_t cmd_list_events(enum lttng_domain_type domain, cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, agt, node.node) { if (agt->domain == domain) { - nb_event = list_lttng_agent_events( - agt, events, - total_size); + ret_code = list_lttng_agent_events( + agt, reply_payload, &nb_events); break; } } + rcu_read_unlock(); } break; default: - ret = LTTNG_ERR_UND; - goto error; + ret_code = LTTNG_ERR_UND; + break; + } + + if (nb_events > UINT32_MAX) { + ret_code = LTTNG_ERR_OVERFLOW; + goto end; } - return nb_event; + /* Update command reply header. */ + reply_command_header.count = (uint32_t) nb_events; + memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header, + sizeof(reply_command_header)); -error: - /* Return negative value to differentiate return code */ - return -ret; +end: + return ret_code; } /* @@ -3050,13 +3909,15 @@ error: * The session list lock MUST be acquired before calling this function. Use * session_lock_list() and session_unlock_list(). */ -void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, - gid_t gid) +void cmd_list_lttng_sessions(struct lttng_session *sessions, + size_t session_count, uid_t uid, gid_t gid) { int ret; unsigned int i = 0; struct ltt_session *session; struct ltt_session_list *list = session_get_list(); + struct lttng_session_extended *extended = + (typeof(extended)) (&sessions[session_count]); DBG("Getting all available session for UID %d GID %d", uid, gid); @@ -3065,10 +3926,15 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, * the buffer. */ cds_list_for_each_entry(session, &list->head, list) { + if (!session_get(session)) { + continue; + } /* * Only list the sessions the user can control. */ - if (!session_access_ok(session, uid, gid)) { + if (!session_access_ok(session, uid) || + session->destroyed) { + session_put(session); continue; } @@ -3082,10 +3948,11 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, sizeof(sessions[i].path), session); } else { ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s", - session->consumer->dst.trace_path); + session->consumer->dst.session_root_path); } if (ret < 0) { PERROR("snprintf session path"); + session_put(session); continue; } @@ -3094,7 +3961,10 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, sessions[i].enabled = session->active; sessions[i].snapshot_mode = session->snapshot_mode; sessions[i].live_timer_interval = session->live_timer; + extended[i].creation_time.value = (uint64_t) session->creation_time; + extended[i].creation_time.is_set = 1; i++; + session_put(session); } } @@ -3110,6 +3980,8 @@ int cmd_data_pending(struct ltt_session *session) assert(session); + DBG("Data pending for session %s", session->name); + /* Session MUST be stopped to ask for data availability. */ if (session->active) { ret = LTTNG_ERR_SESSION_STARTED; @@ -3131,6 +4003,13 @@ int cmd_data_pending(struct ltt_session *session) } } + /* A rotation is still pending, we have to wait. */ + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { + DBG("Rotate still pending for session %s", session->name); + ret = 1; + goto error; + } + if (ksess && ksess->consumer) { ret = consumer_is_data_pending(ksess->id, ksess->consumer); if (ret == 1) { @@ -3160,7 +4039,7 @@ error: * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_add_output(struct ltt_session *session, - struct lttng_snapshot_output *output, uint32_t *id) + const struct lttng_snapshot_output *output, uint32_t *id) { int ret; struct snapshot_output *new_output; @@ -3178,6 +4057,11 @@ int cmd_snapshot_add_output(struct ltt_session *session, goto error; } + if (session->has_non_mmap_channel) { + ret = LTTNG_ERR_SNAPSHOT_UNSUPPORTED; + goto error; + } + /* Only one output is allowed until we have the "tee" feature. */ if (session->snapshot.nb_output == 1) { ret = LTTNG_ERR_SNAPSHOT_OUTPUT_EXIST; @@ -3190,7 +4074,7 @@ int cmd_snapshot_add_output(struct ltt_session *session, goto error; } - ret = snapshot_output_init(output->max_size, output->name, + ret = snapshot_output_init(session, output->max_size, output->name, output->ctrl_url, output->data_url, session->consumer, new_output, &session->snapshot); if (ret < 0) { @@ -3223,7 +4107,7 @@ error: * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_del_output(struct ltt_session *session, - struct lttng_snapshot_output *output) + const struct lttng_snapshot_output *output) { int ret; struct snapshot_output *sout = NULL; @@ -3319,7 +4203,7 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, } if (output->consumer->type == CONSUMER_DST_LOCAL) { if (lttng_strncpy(list[idx].ctrl_url, - output->consumer->dst.trace_path, + output->consumer->dst.session_root_path, sizeof(list[idx].ctrl_url))) { ret = -LTTNG_ERR_INVALID; goto error; @@ -3403,10 +4287,12 @@ static int clear_metadata_file(int fd) { int ret; + off_t lseek_ret; - ret = lseek(fd, 0, SEEK_SET); - if (ret < 0) { + lseek_ret = lseek(fd, 0, SEEK_SET); + if (lseek_ret < 0) { PERROR("lseek"); + ret = -1; goto end; } @@ -3497,7 +4383,7 @@ end: * then regenerate the metadata. Live and per-pid sessions are not * supported and return an error. * - * Return 0 on success or else a LTTNG_ERR code. + * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_regenerate_metadata(struct ltt_session *session) { @@ -3538,7 +4424,7 @@ end: * * Ask the tracer to regenerate a new statedump. * - * Return 0 on success or else a LTTNG_ERR code. + * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_regenerate_statedump(struct ltt_session *session) { @@ -3587,248 +4473,644 @@ end: return ret; } -int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, - struct notification_thread_handle *notification_thread) +static +enum lttng_error_code synchronize_tracer_notifier_register( + struct notification_thread_handle *notification_thread, + struct lttng_trigger *trigger, const struct lttng_credentials *cmd_creds) { - int ret; - size_t trigger_len; - ssize_t sock_recv_len; - struct lttng_trigger *trigger = NULL; - struct lttng_buffer_view view; - struct lttng_dynamic_buffer trigger_buffer; - - lttng_dynamic_buffer_init(&trigger_buffer); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; - ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); - if (ret) { - ret = LTTNG_ERR_NOMEM; - goto end; + enum lttng_error_code ret_code; + const struct lttng_condition *condition = + lttng_trigger_get_const_condition(trigger); + const char *trigger_name; + uid_t trigger_owner; + enum lttng_trigger_status trigger_status; + const enum lttng_domain_type trigger_domain = + lttng_trigger_get_underlying_domain_type_restriction( + trigger); + + trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + assert(condition); + assert(lttng_condition_get_type(condition) == + LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); + + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(anonymous)"; + + session_lock_list(); + switch (trigger_domain) { + case LTTNG_DOMAIN_KERNEL: + { + ret_code = kernel_register_event_notifier(trigger, cmd_creds); + if (ret_code != LTTNG_OK) { + enum lttng_error_code notif_thread_unregister_ret; + + notif_thread_unregister_ret = + notification_thread_command_unregister_trigger( + notification_thread, trigger); + + if (notif_thread_unregister_ret != LTTNG_OK) { + /* Return the original error code. */ + ERR("Failed to unregister trigger from notification thread during error recovery: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, + (int) trigger_owner, + ret_code); + } + } + break; } + case LTTNG_DOMAIN_UST: + ust_app_global_update_all_event_notifier_rules(); + break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + { + /* Agent domains. */ + struct agent *agt = agent_find_by_event_notifier_domain( + trigger_domain); - sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, - trigger_len); - if (sock_recv_len < 0 || sock_recv_len != trigger_len) { - ERR("Failed to receive \"register trigger\" command payload"); - /* TODO: should this be a new error enum ? */ - ret = LTTNG_ERR_INVALID_TRIGGER; - goto end; - } + if (!agt) { + agt = agent_create(trigger_domain); + if (!agt) { + ret_code = LTTNG_ERR_NOMEM; + goto end_unlock_session_list; + } - view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); - if (lttng_trigger_create_from_buffer(&view, &trigger) != - trigger_len) { - ERR("Invalid trigger payload received in \"register trigger\" command"); - ret = LTTNG_ERR_INVALID_TRIGGER; - goto end; + agent_add(agt, the_trigger_agents_ht_by_domain); + } + + ret_code = trigger_agent_enable(trigger, agt); + if (ret_code != LTTNG_OK) { + goto end_unlock_session_list; + } + + break; + } + case LTTNG_DOMAIN_NONE: + default: + abort(); } - ret = notification_thread_command_register_trigger(notification_thread, - trigger); - /* Ownership of trigger was transferred. */ - trigger = NULL; -end: - lttng_trigger_destroy(trigger); - lttng_dynamic_buffer_reset(&trigger_buffer); - return ret; + ret_code = LTTNG_OK; +end_unlock_session_list: + session_unlock_list(); + return ret_code; } -int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, - struct notification_thread_handle *notification_thread) +enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds, + struct lttng_trigger *trigger, + bool is_trigger_anonymous, + struct notification_thread_handle *notification_thread, + struct lttng_trigger **return_trigger) { - int ret; - size_t trigger_len; - ssize_t sock_recv_len; - struct lttng_trigger *trigger = NULL; - struct lttng_buffer_view view; - struct lttng_dynamic_buffer trigger_buffer; + enum lttng_error_code ret_code; + const char *trigger_name; + uid_t trigger_owner; + enum lttng_trigger_status trigger_status; - lttng_dynamic_buffer_init(&trigger_buffer); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; - ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); - if (ret) { - ret = LTTNG_ERR_NOMEM; - goto end; + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(anonymous)"; + + trigger_status = lttng_trigger_get_owner_uid( + trigger, &trigger_owner); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + DBG("Running register trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); + + /* + * Validate the trigger credentials against the command credentials. + * Only the root user can register a trigger with non-matching + * credentials. + */ + if (!lttng_credentials_is_equal_uid( + lttng_trigger_get_credentials(trigger), + cmd_creds)) { + if (lttng_credentials_get_uid(cmd_creds) != 0) { + ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } } - sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, - trigger_len); - if (sock_recv_len < 0 || sock_recv_len != trigger_len) { - ERR("Failed to receive \"unregister trigger\" command payload"); - /* TODO: should this be a new error enum ? */ - ret = LTTNG_ERR_INVALID_TRIGGER; + /* + * The bytecode generation also serves as a validation step for the + * bytecode expressions. + */ + ret_code = lttng_trigger_generate_bytecode(trigger, cmd_creds); + if (ret_code != LTTNG_OK) { + ERR("Failed to generate bytecode of trigger: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, (int) trigger_owner, ret_code); goto end; } - view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); - if (lttng_trigger_create_from_buffer(&view, &trigger) != - trigger_len) { - ERR("Invalid trigger payload received in \"unregister trigger\" command"); - ret = LTTNG_ERR_INVALID_TRIGGER; + /* + * A reference to the trigger is acquired by the notification thread. + * It is safe to return the same trigger to the caller since it the + * other user holds a reference. + * + * The trigger is modified during the execution of the + * "register trigger" command. However, by the time the command returns, + * it is safe to use without any locking as its properties are + * immutable. + */ + ret_code = notification_thread_command_register_trigger( + notification_thread, trigger, is_trigger_anonymous); + if (ret_code != LTTNG_OK) { + DBG("Failed to register trigger to notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, (int) trigger_owner, ret_code); goto end; } - ret = notification_thread_command_unregister_trigger(notification_thread, - trigger); + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(anonymous)"; + + /* + * Synchronize tracers if the trigger adds an event notifier. + */ + if (lttng_trigger_needs_tracer_notifier(trigger)) { + ret_code = synchronize_tracer_notifier_register(notification_thread, + trigger, cmd_creds); + if (ret_code != LTTNG_OK) { + ERR("Error registering tracer notifier: %s", + lttng_strerror(-ret_code)); + goto end; + } + } + + /* + * Return an updated trigger to the client. + * + * Since a modified version of the same trigger is returned, acquire a + * reference to the trigger so the caller doesn't have to care if those + * are distinct instances or not. + */ + if (ret_code == LTTNG_OK) { + lttng_trigger_get(trigger); + *return_trigger = trigger; + /* Ownership of trigger was transferred to caller. */ + trigger = NULL; + } end: - lttng_trigger_destroy(trigger); - lttng_dynamic_buffer_reset(&trigger_buffer); - return ret; + return ret_code; } -/* - * Send relayd sockets from snapshot output to consumer. Ignore request if the - * snapshot output is *not* set with a remote destination. - * - * Return 0 on success or a LTTNG_ERR code. - */ -static int set_relayd_for_snapshot(struct consumer_output *consumer, - struct snapshot_output *snap_output, struct ltt_session *session) +static +enum lttng_error_code synchronize_tracer_notifier_unregister( + const struct lttng_trigger *trigger) { - int ret = LTTNG_OK; - struct lttng_ht_iter iter; - struct consumer_socket *socket; + enum lttng_error_code ret_code; + const struct lttng_condition *condition = + lttng_trigger_get_const_condition(trigger); + const enum lttng_domain_type trigger_domain = + lttng_trigger_get_underlying_domain_type_restriction( + trigger); + + assert(condition); + assert(lttng_condition_get_type(condition) == + LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); + + session_lock_list(); + switch (trigger_domain) { + case LTTNG_DOMAIN_KERNEL: + ret_code = kernel_unregister_event_notifier(trigger); + if (ret_code != LTTNG_OK) { + goto end_unlock_session_list; + } - assert(consumer); - assert(snap_output); - assert(session); + break; + case LTTNG_DOMAIN_UST: + ust_app_global_update_all_event_notifier_rules(); + break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + { + /* Agent domains. */ + struct agent *agt = agent_find_by_event_notifier_domain( + trigger_domain); - DBG2("Set relayd object from snapshot output"); + /* + * This trigger was never registered in the first place. Calling + * this function under those circumstances is an internal error. + */ + assert(agt); + ret_code = trigger_agent_disable(trigger, agt); + if (ret_code != LTTNG_OK) { + goto end_unlock_session_list; + } - /* Ignore if snapshot consumer output is not network. */ - if (snap_output->consumer->type != CONSUMER_DST_NET) { - goto error; + break; } - - /* - * For each consumer socket, create and send the relayd object of the - * snapshot output. - */ - rcu_read_lock(); - cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, - socket, node.node) { - ret = send_consumer_relayd_sockets(0, session->id, - snap_output->consumer, socket, - session->name, session->hostname, - session->live_timer); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } + case LTTNG_DOMAIN_NONE: + default: + abort(); } - rcu_read_unlock(); -error: - return ret; + ret_code = LTTNG_OK; + +end_unlock_session_list: + session_unlock_list(); + return ret_code; } -/* - * Record a kernel snapshot. - * - * Return LTTNG_OK on success or a LTTNG_ERR code. - */ -static int record_kernel_snapshot(struct ltt_kernel_session *ksess, - struct snapshot_output *output, struct ltt_session *session, - int wait, uint64_t nb_packets_per_stream) +enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd_creds, + const struct lttng_trigger *trigger, + struct notification_thread_handle *notification_thread) { - int ret; + enum lttng_error_code ret_code; + const char *trigger_name; + uid_t trigger_owner; + enum lttng_trigger_status trigger_status; + struct lttng_trigger *sessiond_trigger = NULL; - assert(ksess); - assert(output); - assert(session); + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)"; + trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + DBG("Running unregister trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); /* - * Copy kernel session sockets so we can communicate with the right - * consumer for the snapshot record command. + * Validate the trigger credentials against the command credentials. + * Only the root user can unregister a trigger with non-matching + * credentials. */ - ret = consumer_copy_sockets(output->consumer, ksess->consumer); - if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto error; + if (!lttng_credentials_is_equal_uid( + lttng_trigger_get_credentials(trigger), + cmd_creds)) { + if (lttng_credentials_get_uid(cmd_creds) != 0) { + ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } } - ret = set_relayd_for_snapshot(ksess->consumer, output, session); - if (ret != LTTNG_OK) { - goto error_snapshot; + /* Fetch the sessiond side trigger object. */ + ret_code = notification_thread_command_get_trigger( + notification_thread, trigger, &sessiond_trigger); + if (ret_code != LTTNG_OK) { + DBG("Failed to get trigger from notification thread during unregister: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, (int) trigger_owner, ret_code); + goto end; } - ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - goto error_snapshot; + assert(sessiond_trigger); + + /* + * From this point on, no matter what, consider the trigger + * unregistered. + * + * We set the unregistered state of the sessiond side trigger object in + * the client thread since we want to minimize the possibility of the + * notification thread being stalled due to a long execution of an + * action that required the trigger lock. + */ + lttng_trigger_set_as_unregistered(sessiond_trigger); + + ret_code = notification_thread_command_unregister_trigger(notification_thread, + trigger); + if (ret_code != LTTNG_OK) { + DBG("Failed to unregister trigger from notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, (int) trigger_owner, ret_code); + goto end; } - ret = LTTNG_OK; - goto end; + /* + * Synchronize tracers if the trigger removes an event notifier. + * Do this even if the trigger unregistration failed to at least stop + * the tracers from producing notifications associated with this + * event notifier. + */ + if (lttng_trigger_needs_tracer_notifier(trigger)) { + ret_code = synchronize_tracer_notifier_unregister(trigger); + if (ret_code != LTTNG_OK) { + ERR("Error unregistering trigger to tracer."); + goto end; + } + + } -error_snapshot: - /* Clean up copied sockets so this output can use some other later on. */ - consumer_destroy_output_sockets(output->consumer); -error: end: - return ret; + lttng_trigger_put(sessiond_trigger); + return ret_code; } -/* - * Record a UST snapshot. - * - * Return 0 on success or a LTTNG_ERR error code. - */ -static int record_ust_snapshot(struct ltt_ust_session *usess, - struct snapshot_output *output, struct ltt_session *session, - int wait, uint64_t nb_packets_per_stream) +enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx, + struct notification_thread_handle *notification_thread, + struct lttng_triggers **return_triggers) { int ret; + enum lttng_error_code ret_code; + struct lttng_triggers *triggers = NULL; - assert(usess); - assert(output); - assert(session); + /* Get the set of triggers from the notification thread. */ + ret_code = notification_thread_command_list_triggers( + notification_thread, cmd_ctx->creds.uid, &triggers); + if (ret_code != LTTNG_OK) { + goto end; + } - /* - * Copy UST session sockets so we can communicate with the right - * consumer for the snapshot record command. - */ - ret = consumer_copy_sockets(output->consumer, usess->consumer); - if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto error; + ret = lttng_triggers_remove_hidden_triggers(triggers); + if (ret) { + ret_code = LTTNG_ERR_UNK; + goto end; } - ret = set_relayd_for_snapshot(usess->consumer, output, session); - if (ret != LTTNG_OK) { - goto error_snapshot; + *return_triggers = triggers; + triggers = NULL; + ret_code = LTTNG_OK; +end: + lttng_triggers_destroy(triggers); + return ret_code; +} + +enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cmd_creds, + const struct lttng_error_query *query, + struct lttng_error_query_results **_results, + struct notification_thread_handle *notification_thread) +{ + enum lttng_error_code ret_code; + const struct lttng_trigger *query_target_trigger; + const struct lttng_action *query_target_action = NULL; + struct lttng_trigger *matching_trigger = NULL; + const char *trigger_name; + uid_t trigger_owner; + enum lttng_trigger_status trigger_status; + struct lttng_error_query_results *results = NULL; + + switch (lttng_error_query_get_target_type(query)) { + case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER: + query_target_trigger = lttng_error_query_trigger_borrow_target(query); + break; + case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION: + query_target_trigger = + lttng_error_query_condition_borrow_target(query); + break; + case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION: + query_target_trigger = lttng_error_query_action_borrow_trigger_target( + query); + break; + default: + abort(); } - ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream); - if (ret < 0) { - switch (-ret) { - case EINVAL: - ret = LTTNG_ERR_INVALID; + assert(query_target_trigger); + + ret_code = notification_thread_command_get_trigger(notification_thread, + query_target_trigger, &matching_trigger); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* No longer needed. */ + query_target_trigger = NULL; + + if (lttng_error_query_get_target_type(query) == + LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION) { + /* Get the sessiond-side version of the target action. */ + query_target_action = + lttng_error_query_action_borrow_action_target( + query, matching_trigger); + } + + trigger_status = lttng_trigger_get_name(matching_trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(anonymous)"; + trigger_status = lttng_trigger_get_owner_uid(matching_trigger, + &trigger_owner); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + results = lttng_error_query_results_create(); + if (!results) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + DBG("Running \"execute error query\" command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); + + /* + * Validate the trigger credentials against the command credentials. + * Only the root user can target a trigger with non-matching + * credentials. + */ + if (!lttng_credentials_is_equal_uid( + lttng_trigger_get_credentials(matching_trigger), + cmd_creds)) { + if (lttng_credentials_get_uid(cmd_creds) != 0) { + ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d", + trigger_name, (int) trigger_owner, + (int) lttng_credentials_get_uid(cmd_creds)); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + + switch (lttng_error_query_get_target_type(query)) { + case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER: + trigger_status = lttng_trigger_add_error_results( + matching_trigger, results); + + switch (trigger_status) { + case LTTNG_TRIGGER_STATUS_OK: break; default: - ret = LTTNG_ERR_SNAPSHOT_FAIL; + ret_code = LTTNG_ERR_UNK; + goto end; + } + + break; + case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION: + { + trigger_status = lttng_trigger_condition_add_error_results( + matching_trigger, results); + + switch (trigger_status) { + case LTTNG_TRIGGER_STATUS_OK: break; + default: + ret_code = LTTNG_ERR_UNK; + goto end; } - goto error_snapshot; + + break; } + case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION: + { + const enum lttng_action_status action_status = + lttng_action_add_error_query_results( + query_target_action, results); - ret = LTTNG_OK; + switch (action_status) { + case LTTNG_ACTION_STATUS_OK: + break; + default: + ret_code = LTTNG_ERR_UNK; + goto end; + } + + break; + } + default: + abort(); + break; + } + + *_results = results; + results = NULL; + ret_code = LTTNG_OK; +end: + lttng_trigger_put(matching_trigger); + lttng_error_query_results_destroy(results); + return ret_code; +} + +/* + * Send relayd sockets from snapshot output to consumer. Ignore request if the + * snapshot output is *not* set with a remote destination. + * + * Return LTTNG_OK on success or a LTTNG_ERR code. + */ +static enum lttng_error_code set_relayd_for_snapshot( + struct consumer_output *output, + const struct ltt_session *session) +{ + enum lttng_error_code status = LTTNG_OK; + struct lttng_ht_iter iter; + struct consumer_socket *socket; + LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; + const char *base_path; + + assert(output); + assert(session); + + DBG2("Set relayd object from snapshot output"); + + if (session->current_trace_chunk) { + enum lttng_trace_chunk_status chunk_status = + lttng_trace_chunk_get_id( + session->current_trace_chunk, + ¤t_chunk_id.value); + + if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) { + current_chunk_id.is_set = true; + } else { + ERR("Failed to get current trace chunk id"); + status = LTTNG_ERR_UNK; + goto error; + } + } + + /* Ignore if snapshot consumer output is not network. */ + if (output->type != CONSUMER_DST_NET) { + goto error; + } + + /* + * The snapshot record URI base path overrides the session + * base path. + */ + if (output->dst.net.control.subdir[0] != '\0') { + base_path = output->dst.net.control.subdir; + } else { + base_path = session->base_path; + } + + /* + * For each consumer socket, create and send the relayd object of the + * snapshot output. + */ + rcu_read_lock(); + cds_lfht_for_each_entry(output->socks->ht, &iter.iter, + socket, node.node) { + pthread_mutex_lock(socket->lock); + status = send_consumer_relayd_sockets(0, session->id, + output, socket, + session->name, session->hostname, + base_path, + session->live_timer, + current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, + session->creation_time, + session->name_contains_creation_time); + pthread_mutex_unlock(socket->lock); + if (status != LTTNG_OK) { + rcu_read_unlock(); + goto error; + } + } + rcu_read_unlock(); -error_snapshot: - /* Clean up copied sockets so this output can use some other later on. */ - consumer_destroy_output_sockets(output->consumer); error: - return ret; + return status; +} + +/* + * Record a kernel snapshot. + * + * Return LTTNG_OK on success or a LTTNG_ERR code. + */ +static enum lttng_error_code record_kernel_snapshot( + struct ltt_kernel_session *ksess, + const struct consumer_output *output, + const struct ltt_session *session, + int wait, uint64_t nb_packets_per_stream) +{ + enum lttng_error_code status; + + assert(ksess); + assert(output); + assert(session); + + status = kernel_snapshot_record( + ksess, output, wait, nb_packets_per_stream); + return status; +} + +/* + * Record a UST snapshot. + * + * Returns LTTNG_OK on success or a LTTNG_ERR error code. + */ +static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess, + const struct consumer_output *output, + const struct ltt_session *session, + int wait, uint64_t nb_packets_per_stream) +{ + enum lttng_error_code status; + + assert(usess); + assert(output); + assert(session); + + status = ust_app_snapshot_record( + usess, output, wait, nb_packets_per_stream); + return status; } static -uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session, - uint64_t cur_nr_packets) +uint64_t get_session_size_one_more_packet_per_stream( + const struct ltt_session *session, uint64_t cur_nr_packets) { uint64_t tot_size = 0; if (session->kernel_session) { struct ltt_kernel_channel *chan; - struct ltt_kernel_session *ksess = session->kernel_session; + const struct ltt_kernel_session *ksess = + session->kernel_session; cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { if (cur_nr_packets >= chan->channel->attr.num_subbuf) { @@ -3844,7 +5126,7 @@ uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session } if (session->ust_session) { - struct ltt_ust_session *usess = session->ust_session; + const struct ltt_ust_session *usess = session->ust_session; tot_size += ust_app_get_size_one_more_packet_per_stream(usess, cur_nr_packets); @@ -3874,7 +5156,8 @@ uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session * in between this call and actually grabbing data. */ static -int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t max_size) +int64_t get_session_nb_packets_per_stream(const struct ltt_session *session, + uint64_t max_size) { int64_t size_left; uint64_t cur_nb_packets = 0; @@ -3887,8 +5170,8 @@ int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t for (;;) { uint64_t one_more_packet_tot_size; - one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(session, - cur_nb_packets); + one_more_packet_tot_size = get_session_size_one_more_packet_per_stream( + session, cur_nb_packets); if (!one_more_packet_tot_size) { /* We are already grabbing all packets. */ break; @@ -3899,13 +5182,183 @@ int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t } cur_nb_packets++; } - if (!cur_nb_packets) { + if (!cur_nb_packets && size_left != max_size) { /* Not enough room to grab one packet of each stream, error. */ return -1; } return cur_nb_packets; } +static +enum lttng_error_code snapshot_record(struct ltt_session *session, + const struct snapshot_output *snapshot_output, int wait) +{ + int64_t nb_packets_per_stream; + char snapshot_chunk_name[LTTNG_NAME_MAX]; + int ret; + enum lttng_error_code ret_code = LTTNG_OK; + struct lttng_trace_chunk *snapshot_trace_chunk; + struct consumer_output *original_ust_consumer_output = NULL; + struct consumer_output *original_kernel_consumer_output = NULL; + struct consumer_output *snapshot_ust_consumer_output = NULL; + struct consumer_output *snapshot_kernel_consumer_output = NULL; + + ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name), + "%s-%s-%" PRIu64, + snapshot_output->name, + snapshot_output->datetime, + snapshot_output->nb_snapshot); + if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) { + ERR("Failed to format snapshot name"); + ret_code = LTTNG_ERR_INVALID; + goto error; + } + DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"", + snapshot_output->name, session->name, + snapshot_chunk_name); + if (!session->kernel_session && !session->ust_session) { + ERR("Failed to record snapshot as no channels exist"); + ret_code = LTTNG_ERR_NO_CHANNEL; + goto error; + } + + if (session->kernel_session) { + original_kernel_consumer_output = + session->kernel_session->consumer; + snapshot_kernel_consumer_output = + consumer_copy_output(snapshot_output->consumer); + strcpy(snapshot_kernel_consumer_output->chunk_path, + snapshot_chunk_name); + + /* Copy the original domain subdir. */ + strcpy(snapshot_kernel_consumer_output->domain_subdir, + original_kernel_consumer_output->domain_subdir); + + ret = consumer_copy_sockets(snapshot_kernel_consumer_output, + original_kernel_consumer_output); + if (ret < 0) { + ERR("Failed to copy consumer sockets from snapshot output configuration"); + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + ret_code = set_relayd_for_snapshot( + snapshot_kernel_consumer_output, session); + if (ret_code != LTTNG_OK) { + ERR("Failed to setup relay daemon for kernel tracer snapshot"); + goto error; + } + session->kernel_session->consumer = + snapshot_kernel_consumer_output; + } + if (session->ust_session) { + original_ust_consumer_output = session->ust_session->consumer; + snapshot_ust_consumer_output = + consumer_copy_output(snapshot_output->consumer); + strcpy(snapshot_ust_consumer_output->chunk_path, + snapshot_chunk_name); + + /* Copy the original domain subdir. */ + strcpy(snapshot_ust_consumer_output->domain_subdir, + original_ust_consumer_output->domain_subdir); + + ret = consumer_copy_sockets(snapshot_ust_consumer_output, + original_ust_consumer_output); + if (ret < 0) { + ERR("Failed to copy consumer sockets from snapshot output configuration"); + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + ret_code = set_relayd_for_snapshot( + snapshot_ust_consumer_output, session); + if (ret_code != LTTNG_OK) { + ERR("Failed to setup relay daemon for userspace tracer snapshot"); + goto error; + } + session->ust_session->consumer = + snapshot_ust_consumer_output; + } + + snapshot_trace_chunk = session_create_new_trace_chunk(session, + snapshot_kernel_consumer_output ?: + snapshot_ust_consumer_output, + consumer_output_get_base_path( + snapshot_output->consumer), + snapshot_chunk_name); + if (!snapshot_trace_chunk) { + ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"", + session->name); + ret_code = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + assert(!session->current_trace_chunk); + ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL); + lttng_trace_chunk_put(snapshot_trace_chunk); + snapshot_trace_chunk = NULL; + if (ret) { + ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"", + session->name); + ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + + nb_packets_per_stream = get_session_nb_packets_per_stream(session, + snapshot_output->max_size); + if (nb_packets_per_stream < 0) { + ret_code = LTTNG_ERR_MAX_SIZE_INVALID; + goto error_close_trace_chunk; + } + + if (session->kernel_session) { + ret_code = record_kernel_snapshot(session->kernel_session, + snapshot_kernel_consumer_output, session, + wait, nb_packets_per_stream); + if (ret_code != LTTNG_OK) { + goto error_close_trace_chunk; + } + } + + if (session->ust_session) { + ret_code = record_ust_snapshot(session->ust_session, + snapshot_ust_consumer_output, session, + wait, nb_packets_per_stream); + if (ret_code != LTTNG_OK) { + goto error_close_trace_chunk; + } + } + +error_close_trace_chunk: + if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) { + ERR("Failed to release the current trace chunk of session \"%s\"", + session->name); + ret_code = LTTNG_ERR_UNK; + } + + if (session_close_trace_chunk(session, snapshot_trace_chunk, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION, NULL)) { + /* + * Don't goto end; make sure the chunk is closed for the session + * to allow future snapshots. + */ + ERR("Failed to close snapshot trace chunk of session \"%s\"", + session->name); + ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; + } + + lttng_trace_chunk_put(snapshot_trace_chunk); + snapshot_trace_chunk = NULL; +error: + if (original_ust_consumer_output) { + session->ust_session->consumer = original_ust_consumer_output; + } + if (original_kernel_consumer_output) { + session->kernel_session->consumer = + original_kernel_consumer_output; + } + consumer_output_put(snapshot_ust_consumer_output); + consumer_output_put(snapshot_kernel_consumer_output); + return ret_code; +} + /* * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl. * @@ -3915,13 +5368,13 @@ int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_record(struct ltt_session *session, - struct lttng_snapshot_output *output, int wait) + const struct lttng_snapshot_output *output, int wait) { - int ret = LTTNG_OK; - unsigned int use_tmp_output = 0; - struct snapshot_output tmp_output; + enum lttng_error_code cmd_ret = LTTNG_OK; + int ret; unsigned int snapshot_success = 0; char datetime[16]; + struct snapshot_output *tmp_output = NULL; assert(session); assert(output); @@ -3932,7 +5385,7 @@ int cmd_snapshot_record(struct ltt_session *session, ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime, sizeof(datetime)); if (!ret) { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; goto error; } @@ -3941,65 +5394,46 @@ int cmd_snapshot_record(struct ltt_session *session, * set in no output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; + cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } /* The session needs to be started at least once. */ if (!session->has_been_started) { - ret = LTTNG_ERR_START_SESSION_ONCE; + cmd_ret = LTTNG_ERR_START_SESSION_ONCE; goto error; } /* Use temporary output for the session. */ if (*output->ctrl_url != '\0') { - ret = snapshot_output_init(output->max_size, output->name, - output->ctrl_url, output->data_url, session->consumer, - &tmp_output, NULL); + tmp_output = snapshot_output_alloc(); + if (!tmp_output) { + cmd_ret = LTTNG_ERR_NOMEM; + goto error; + } + + ret = snapshot_output_init(session, output->max_size, + output->name, + output->ctrl_url, output->data_url, + session->consumer, + tmp_output, NULL); if (ret < 0) { if (ret == -ENOMEM) { - ret = LTTNG_ERR_NOMEM; + cmd_ret = LTTNG_ERR_NOMEM; } else { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; } goto error; } /* Use the global session count for the temporary snapshot. */ - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + tmp_output->nb_snapshot = session->snapshot.nb_snapshot; /* Use the global datetime */ - memcpy(tmp_output.datetime, datetime, sizeof(datetime)); - use_tmp_output = 1; - } - - if (use_tmp_output) { - int64_t nb_packets_per_stream; - - nb_packets_per_stream = get_session_nb_packets_per_stream(session, - tmp_output.max_size); - if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + memcpy(tmp_output->datetime, datetime, sizeof(datetime)); + cmd_ret = snapshot_record(session, tmp_output, wait); + if (cmd_ret != LTTNG_OK) { goto error; } - - if (session->kernel_session) { - ret = record_kernel_snapshot(session->kernel_session, - &tmp_output, session, - wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - goto error; - } - } - - if (session->ust_session) { - ret = record_ust_snapshot(session->ust_session, - &tmp_output, session, - wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - goto error; - } - } - snapshot_success = 1; } else { struct snapshot_output *sout; @@ -4008,58 +5442,38 @@ int cmd_snapshot_record(struct ltt_session *session, rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, sout, node.node) { - int64_t nb_packets_per_stream; + struct snapshot_output output_copy; /* - * Make a local copy of the output and assign the possible - * temporary value given by the caller. + * Make a local copy of the output and override output + * parameters with those provided as part of the + * command. */ - memset(&tmp_output, 0, sizeof(tmp_output)); - memcpy(&tmp_output, sout, sizeof(tmp_output)); + memcpy(&output_copy, sout, sizeof(output_copy)); if (output->max_size != (uint64_t) -1ULL) { - tmp_output.max_size = output->max_size; + output_copy.max_size = output->max_size; } - nb_packets_per_stream = get_session_nb_packets_per_stream(session, - tmp_output.max_size); - if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; - rcu_read_unlock(); - goto error; - } + output_copy.nb_snapshot = session->snapshot.nb_snapshot; + memcpy(output_copy.datetime, datetime, + sizeof(datetime)); /* Use temporary name. */ if (*output->name != '\0') { - if (lttng_strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name))) { - ret = LTTNG_ERR_INVALID; + if (lttng_strncpy(output_copy.name, + output->name, + sizeof(output_copy.name))) { + cmd_ret = LTTNG_ERR_INVALID; rcu_read_unlock(); goto error; } } - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; - memcpy(tmp_output.datetime, datetime, sizeof(datetime)); - - if (session->kernel_session) { - ret = record_kernel_snapshot(session->kernel_session, - &tmp_output, session, - wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } - } - - if (session->ust_session) { - ret = record_ust_snapshot(session->ust_session, - &tmp_output, session, - wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } + cmd_ret = snapshot_record(session, &output_copy, wait); + if (cmd_ret != LTTNG_OK) { + rcu_read_unlock(); + goto error; } snapshot_success = 1; } @@ -4069,11 +5483,14 @@ int cmd_snapshot_record(struct ltt_session *session, if (snapshot_success) { session->snapshot.nb_snapshot++; } else { - ret = LTTNG_ERR_SNAPSHOT_FAIL; + cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL; } error: - return ret; + if (tmp_output) { + snapshot_output_destroy(tmp_output); + } + return cmd_ret; } /* @@ -4096,7 +5513,538 @@ int cmd_set_session_shm_path(struct ltt_session *session, sizeof(session->shm_path)); session->shm_path[sizeof(session->shm_path) - 1] = '\0'; - return 0; + return LTTNG_OK; +} + +/* + * Command LTTNG_ROTATE_SESSION from the lttng-ctl library. + * + * Ask the consumer to rotate the session output directory. + * The session lock must be held. + * + * Returns LTTNG_OK on success or else a negative LTTng error code. + */ +int cmd_rotate_session(struct ltt_session *session, + struct lttng_rotate_session_return *rotate_return, + bool quiet_rotation, + enum lttng_trace_chunk_command_type command) +{ + int ret; + uint64_t ongoing_rotation_chunk_id; + enum lttng_error_code cmd_ret = LTTNG_OK; + struct lttng_trace_chunk *chunk_being_archived = NULL; + struct lttng_trace_chunk *new_trace_chunk = NULL; + enum lttng_trace_chunk_status chunk_status; + bool failed_to_rotate = false; + enum lttng_error_code rotation_fail_code = LTTNG_OK; + + assert(session); + + if (!session->has_been_started) { + cmd_ret = LTTNG_ERR_START_SESSION_ONCE; + goto end; + } + + /* + * Explicit rotation is not supported for live sessions. + * However, live sessions can perform a quiet rotation on + * destroy. + * Rotation is not supported for snapshot traces (no output). + */ + if ((!quiet_rotation && session->live_timer) || + !session->output_traces) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + + /* Unsupported feature in lttng-relayd before 2.11. */ + if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET && + (session->consumer->relay_major_version == 2 && + session->consumer->relay_minor_version < 11)) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY; + goto end; + } + + /* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */ + if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL; + goto end; + } + + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { + DBG("Refusing to launch a rotation; a rotation is already in progress for session %s", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_PENDING; + goto end; + } + + /* + * After a stop, we only allow one rotation to occur, the other ones are + * useless until a new start. + */ + if (session->rotated_after_last_stop) { + DBG("Session \"%s\" was already rotated after stop, refusing rotation", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP; + goto end; + } + + /* + * After a stop followed by a clear, disallow following rotations a they would + * generate empty chunks. + */ + if (session->cleared_after_last_stop) { + DBG("Session \"%s\" was already cleared after stop, refusing rotation", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR; + goto end; + } + + if (session->active) { + new_trace_chunk = session_create_new_trace_chunk(session, NULL, + NULL, NULL); + if (!new_trace_chunk) { + cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + } + + /* + * The current trace chunk becomes the chunk being archived. + * + * After this point, "chunk_being_archived" must absolutely + * be closed on the consumer(s), otherwise it will never be + * cleaned-up, which will result in a leak. + */ + ret = session_set_trace_chunk(session, new_trace_chunk, + &chunk_being_archived); + if (ret) { + cmd_ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + + if (session->kernel_session) { + cmd_ret = kernel_rotate_session(session); + if (cmd_ret != LTTNG_OK) { + failed_to_rotate = true; + rotation_fail_code = cmd_ret; + } + } + if (session->ust_session) { + cmd_ret = ust_app_rotate_session(session); + if (cmd_ret != LTTNG_OK) { + failed_to_rotate = true; + rotation_fail_code = cmd_ret; + } + } + + if (!session->active) { + session->rotated_after_last_stop = true; + } + + if (!chunk_being_archived) { + DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check", + session->name); + if (failed_to_rotate) { + cmd_ret = rotation_fail_code; + goto error; + } + cmd_ret = LTTNG_OK; + goto end; + } + + session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, + &ongoing_rotation_chunk_id); + assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); + + ret = session_close_trace_chunk(session, chunk_being_archived, + command, session->last_chunk_path); + if (ret) { + cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + + if (failed_to_rotate) { + cmd_ret = rotation_fail_code; + goto error; + } + + session->quiet_rotation = quiet_rotation; + ret = timer_session_rotation_pending_check_start(session, + DEFAULT_ROTATE_PENDING_TIMER); + if (ret) { + cmd_ret = LTTNG_ERR_UNK; + goto error; + } + + if (rotate_return) { + rotate_return->rotation_id = ongoing_rotation_chunk_id; + } + + session->chunk_being_archived = chunk_being_archived; + chunk_being_archived = NULL; + if (!quiet_rotation) { + ret = notification_thread_command_session_rotation_ongoing( + the_notification_thread_handle, session->name, + session->uid, session->gid, + ongoing_rotation_chunk_id); + if (ret != LTTNG_OK) { + ERR("Failed to notify notification thread that a session rotation is ongoing for session %s", + session->name); + cmd_ret = ret; + } + } + + DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent", + session->name, ongoing_rotation_chunk_id); +end: + lttng_trace_chunk_put(new_trace_chunk); + lttng_trace_chunk_put(chunk_being_archived); + ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret); + return ret; +error: + if (session_reset_rotation_state(session, + LTTNG_ROTATION_STATE_ERROR)) { + ERR("Failed to reset rotation state of session \"%s\"", + session->name); + } + goto end; +} + +/* + * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library. + * + * Check if the session has finished its rotation. + * + * Return LTTNG_OK on success or else an LTTNG_ERR code. + */ +int cmd_rotate_get_info(struct ltt_session *session, + struct lttng_rotation_get_info_return *info_return, + uint64_t rotation_id) +{ + enum lttng_error_code cmd_ret = LTTNG_OK; + enum lttng_rotation_state rotation_state; + + DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name, + session->most_recent_chunk_id.value); + + if (session->chunk_being_archived) { + enum lttng_trace_chunk_status chunk_status; + uint64_t chunk_id; + + chunk_status = lttng_trace_chunk_get_id( + session->chunk_being_archived, + &chunk_id); + assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); + + rotation_state = rotation_id == chunk_id ? + LTTNG_ROTATION_STATE_ONGOING : + LTTNG_ROTATION_STATE_EXPIRED; + } else { + if (session->last_archived_chunk_id.is_set && + rotation_id != session->last_archived_chunk_id.value) { + rotation_state = LTTNG_ROTATION_STATE_EXPIRED; + } else { + rotation_state = session->rotation_state; + } + } + + switch (rotation_state) { + case LTTNG_ROTATION_STATE_NO_ROTATION: + DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"", + session->name); + goto end; + case LTTNG_ROTATION_STATE_EXPIRED: + DBG("Reporting that the rotation state of rotation id %" PRIu64 " of session \"%s\" has expired", + rotation_id, session->name); + break; + case LTTNG_ROTATION_STATE_ONGOING: + DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending", + rotation_id, session->name); + break; + case LTTNG_ROTATION_STATE_COMPLETED: + { + int fmt_ret; + char *chunk_path; + char *current_tracing_path_reply; + size_t current_tracing_path_reply_len; + + DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed", + rotation_id, session->name); + + switch (session_get_consumer_destination_type(session)) { + case CONSUMER_DST_LOCAL: + current_tracing_path_reply = + info_return->location.local.absolute_path; + current_tracing_path_reply_len = + sizeof(info_return->location.local.absolute_path); + info_return->location_type = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL; + fmt_ret = asprintf(&chunk_path, + "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s", + session_get_base_path(session), + session->last_archived_chunk_name); + if (fmt_ret == -1) { + PERROR("Failed to format the path of the last archived trace chunk"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + break; + case CONSUMER_DST_NET: + { + uint16_t ctrl_port, data_port; + + current_tracing_path_reply = + info_return->location.relay.relative_path; + current_tracing_path_reply_len = + sizeof(info_return->location.relay.relative_path); + /* Currently the only supported relay protocol. */ + info_return->location.relay.protocol = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP; + + fmt_ret = lttng_strncpy(info_return->location.relay.host, + session_get_net_consumer_hostname(session), + sizeof(info_return->location.relay.host)); + if (fmt_ret) { + ERR("Failed to copy host name to rotate_get_info reply"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_SET_URL; + goto end; + } + + session_get_net_consumer_ports(session, &ctrl_port, &data_port); + info_return->location.relay.ports.control = ctrl_port; + info_return->location.relay.ports.data = data_port; + info_return->location_type = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY; + chunk_path = strdup(session->last_chunk_path); + if (!chunk_path) { + ERR("Failed to allocate the path of the last archived trace chunk"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + break; + } + default: + abort(); + } + + fmt_ret = lttng_strncpy(current_tracing_path_reply, + chunk_path, current_tracing_path_reply_len); + free(chunk_path); + if (fmt_ret) { + ERR("Failed to copy path of the last archived trace chunk to rotate_get_info reply"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + + break; + } + case LTTNG_ROTATION_STATE_ERROR: + DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"", + rotation_id, session->name); + break; + default: + abort(); + } + + cmd_ret = LTTNG_OK; +end: + info_return->status = (int32_t) rotation_state; + return cmd_ret; +} + +/* + * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library. + * + * Configure the automatic rotation parameters. + * 'activate' to true means activate the rotation schedule type with 'new_value'. + * 'activate' to false means deactivate the rotation schedule and validate that + * 'new_value' has the same value as the currently active value. + * + * Return LTTNG_OK on success or else a positive LTTNG_ERR code. + */ +int cmd_rotation_set_schedule(struct ltt_session *session, + bool activate, enum lttng_rotation_schedule_type schedule_type, + uint64_t new_value, + struct notification_thread_handle *notification_thread_handle) +{ + int ret; + uint64_t *parameter_value; + + assert(session); + + DBG("Cmd rotate set schedule session %s", session->name); + + if (session->live_timer || !session->output_traces) { + DBG("Failing ROTATION_SET_SCHEDULE command as the rotation feature is not available for this session"); + ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + + switch (schedule_type) { + case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: + parameter_value = &session->rotate_size; + break; + case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: + parameter_value = &session->rotate_timer_period; + if (new_value >= UINT_MAX) { + DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)", + new_value, UINT_MAX); + ret = LTTNG_ERR_INVALID; + goto end; + } + break; + default: + WARN("Failing ROTATION_SET_SCHEDULE command on unknown schedule type"); + ret = LTTNG_ERR_INVALID; + goto end; + } + + /* Improper use of the API. */ + if (new_value == -1ULL) { + WARN("Failing ROTATION_SET_SCHEDULE command as the value requested is -1"); + ret = LTTNG_ERR_INVALID; + goto end; + } + + /* + * As indicated in struct ltt_session's comments, a value of == 0 means + * this schedule rotation type is not in use. + * + * Reject the command if we were asked to activate a schedule that was + * already active. + */ + if (activate && *parameter_value != 0) { + DBG("Failing ROTATION_SET_SCHEDULE (activate) command as the schedule is already active"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_SET; + goto end; + } + + /* + * Reject the command if we were asked to deactivate a schedule that was + * not active. + */ + if (!activate && *parameter_value == 0) { + DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as the schedule is already inactive"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET; + goto end; + } + + /* + * Reject the command if we were asked to deactivate a schedule that + * doesn't exist. + */ + if (!activate && *parameter_value != new_value) { + DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as an inexistant schedule was provided"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET; + goto end; + } + + *parameter_value = activate ? new_value : 0; + + switch (schedule_type) { + case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: + if (activate && session->active) { + /* + * Only start the timer if the session is active, + * otherwise it will be started when the session starts. + */ + ret = timer_session_rotation_schedule_timer_start( + session, new_value); + if (ret) { + ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + } else { + ret = timer_session_rotation_schedule_timer_stop( + session); + if (ret) { + ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + } + break; + case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: + if (activate) { + ret = subscribe_session_consumed_size_rotation(session, + new_value, notification_thread_handle); + if (ret) { + ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + } else { + ret = unsubscribe_session_consumed_size_rotation(session, + notification_thread_handle); + if (ret) { + ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + + } + break; + default: + /* Would have been caught before. */ + abort(); + } + + ret = LTTNG_OK; + + goto end; + +end: + return ret; +} + +/* Wait for a given path to be removed before continuing. */ +static enum lttng_error_code wait_on_path(void *path_data) +{ + const char *shm_path = path_data; + + DBG("Waiting for the shm path at %s to be removed before completing session destruction", + shm_path); + while (true) { + int ret; + struct stat st; + + ret = stat(shm_path, &st); + if (ret) { + if (errno != ENOENT) { + PERROR("stat() returned an error while checking for the existence of the shm path"); + } else { + DBG("shm path no longer exists, completing the destruction of session"); + } + break; + } else { + if (!S_ISDIR(st.st_mode)) { + ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal", + shm_path); + break; + } + } + usleep(SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US); + } + return LTTNG_OK; +} + +/* + * Returns a pointer to a handler to run on completion of a command. + * Returns NULL if no handler has to be run for the last command executed. + */ +const struct cmd_completion_handler *cmd_pop_completion_handler(void) +{ + struct cmd_completion_handler *handler = current_completion_handler; + + current_completion_handler = NULL; + return handler; } /*