X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=67ac9fd7bd7c2cfe3313c57ecdf54d624f383e00;hb=refs%2Fheads%2Fsow-2020-0002-rev2;hp=1dec61ea17b6ba7f74e122e37a7df99afa2e07c6;hpb=e3876bf0e1d1be72170b53e9fcb39f3108f069dc;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 1dec61ea1..67ac9fd7b 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1,19 +1,9 @@ /* - * 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 @@ -26,6 +16,7 @@ #include #include +#include #include #include #include @@ -33,18 +24,33 @@ #include #include #include +#include +#include #include #include #include #include +#include +#include +#include +#include +#include #include +#include +#include +#include #include #include +#include "lttng/domain.h" +#include "lttng/map/map.h" +#include #include #include #include #include #include +#include +#include #include #include "channel.h" @@ -58,12 +64,15 @@ #include "lttng-syscall.h" #include "agent.h" #include "buffer-registry.h" +#include "map.h" #include "notification-thread.h" #include "notification-thread-commands.h" #include "rotate.h" #include "rotation-thread.h" #include "timer.h" #include "agent-thread.h" +#include "session.h" +#include "tracker.h" #include "cmd.h" @@ -115,7 +124,7 @@ static int cmd_enable_event_internal(struct ltt_session *session, 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); @@ -288,6 +297,340 @@ end: return ret; } +enum tracer_executed_action_state { + TRACER_EXECUTED_ACTION_STATE_REGISTER, + TRACER_EXECUTED_ACTION_STATE_UNREGISTER +}; + +static +enum lttng_error_code sync_incr_value_action_ust( + struct ltt_session *session, + const struct lttng_condition *condition, + const char *map_name, + uint64_t tracer_token, + struct lttng_map_key *key, + enum tracer_executed_action_state state) +{ + enum lttng_error_code ret_code; + const struct lttng_event_rule *event_rule; + enum lttng_condition_status cond_status; + enum lttng_event_rule_status er_status; + struct ltt_ust_session *usess = session->ust_session; + const char *pattern; + struct ltt_ust_map *map; + char *filter_expression; + struct lttng_bytecode *filter; + struct lttng_event_exclusion *exclusion; + enum lttng_event_rule_generate_exclusions_status + generate_exclusion_status; + + DBG("Syncing UST incr-value action for session '%s', map '%s'", + session->name, map_name); + if (!usess) { + DBG("No UST session"); + ret_code = LTTNG_OK; + goto end; + } + + assert(usess->domain_global.maps); + + map = trace_ust_find_map_by_name(usess->domain_global.maps, map_name); + if (!map) { + DBG("UST map \"%s\" not found", map_name); + ret_code = LTTNG_OK; + goto end; + } + + cond_status = lttng_condition_on_event_get_rule(condition, &event_rule); + if (cond_status != LTTNG_CONDITION_STATUS_OK) { + ERR("Error getting on-event condition event-rule"); + ret_code = LTTNG_ERR_INVALID_MAP; + goto end; + } + + er_status = lttng_event_rule_tracepoint_get_pattern(event_rule, &pattern); + if (er_status != LTTNG_EVENT_RULE_STATUS_OK) { + /* At this point, this is a fatal error. */ + abort(); + } + + /* + * FIXME: frdeso, reuse the event notifier functions and approach to + * create the event. + */ + filter_expression = (char *) lttng_event_rule_get_filter(event_rule); + filter = (struct lttng_bytecode *)lttng_event_rule_get_filter_bytecode( + event_rule); + generate_exclusion_status = lttng_event_rule_generate_exclusions( + event_rule, &exclusion); + if (generate_exclusion_status == LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR) { + ERR("Error generating the exclusion"); + ret_code = LTTNG_ERR_EXCLUSION_INVAL; + goto end; + } + + switch (state) { + case TRACER_EXECUTED_ACTION_STATE_REGISTER: + ret_code = map_event_ust_enable_tracepoint(usess, + map, tracer_token, (char *) pattern, key, + LTTNG_EVENT_TRACEPOINT, LTTNG_EVENT_LOGLEVEL_ALL, + 0, filter_expression, filter, exclusion, false); + if (ret_code == LTTNG_ERR_UST_EVENT_ENABLED) { + ret_code = LTTNG_OK; + } else if (ret_code != LTTNG_OK) { + ERR("Enabling UST map event"); + goto end; + } + break; + case TRACER_EXECUTED_ACTION_STATE_UNREGISTER: + ret_code = map_event_ust_disable_tracepoint(usess, + map, tracer_token, (char *) pattern, key, + LTTNG_EVENT_TRACEPOINT, LTTNG_EVENT_LOGLEVEL_ALL, + 0, filter_expression, filter, exclusion, false); + if (ret_code == LTTNG_ERR_UST_EVENT_ENABLED) { + ret_code = LTTNG_OK; + } else if (ret_code != LTTNG_OK) { + ERR("Enabling UST map event"); + goto end; + } + break; + default: + abort(); + } + + ret_code = LTTNG_OK; + +end: + return ret_code; +} + +static +enum lttng_error_code sync_incr_value_action_kernel( + struct ltt_session *session, + const struct lttng_credentials *creds, + const struct lttng_condition *condition, + const char *map_name, + uint64_t tracer_token, + struct lttng_map_key *key, + enum tracer_executed_action_state state) +{ + enum lttng_error_code ret_code; + const struct lttng_event_rule *event_rule; + enum lttng_condition_status cond_status; + struct ltt_kernel_map *kmap; + struct ltt_kernel_session *ksess = session->kernel_session; + + DBG("Syncing kernel incr-value action for session '%s', map '%s'", + session->name, map_name); + + if (!ksess) { + DBG("No kernel session"); + ret_code = LTTNG_OK; + goto end; + } + + kmap = trace_kernel_get_map_by_name(map_name, ksess); + if (!kmap) { + DBG("Kernel map \"%s\" not found", map_name); + ret_code = LTTNG_OK; + goto end; + } + + cond_status = lttng_condition_on_event_get_rule(condition, &event_rule); + if (cond_status != LTTNG_CONDITION_STATUS_OK) { + ret_code = LTTNG_ERR_INVALID_MAP; + ERR("Error getting on-event condition event-rule"); + goto end; + } + + switch (state) { + case TRACER_EXECUTED_ACTION_STATE_REGISTER: + ret_code = map_event_kernel_enable_event(kmap, creds, tracer_token, + event_rule, key); + if(ret_code != LTTNG_OK) { + ERR("Error enabling event counter to the kernel tracer"); + goto end; + } + break; + case TRACER_EXECUTED_ACTION_STATE_UNREGISTER: + ret_code = map_event_kernel_disable_event(kmap, tracer_token); + if(ret_code != LTTNG_OK) { + ERR("Error disabling event counter to the kernel tracer"); + goto end; + } + break; + } + +end: + return ret_code; +} + +static +enum lttng_error_code sync_incr_value_action( + const struct lttng_credentials *creds, + const struct lttng_condition *condition, + const struct lttng_action *action, + enum tracer_executed_action_state state) +{ + enum lttng_error_code ret; + const char *session_name, *map_name; + enum lttng_action_status action_status; + enum lttng_condition_status cond_status; + const struct lttng_event_rule *event_rule; + struct ltt_session *session = NULL; + struct lttng_map_key *key; + uint64_t action_tracer_token; + + action_status = lttng_action_incr_value_get_map_name(action, + &map_name); + if (action_status != LTTNG_ACTION_STATUS_OK) { + ERR("Map name not set for incr-value action"); + ret = LTTNG_ERR_INVALID_MAP; + goto end; + } + + action_status = lttng_action_incr_value_get_session_name(action, + &session_name); + if (action_status != LTTNG_ACTION_STATUS_OK) { + ERR("Session name not set for incr-value action"); + ret = LTTNG_ERR_INVALID_MAP; + goto end; + } + + action_status = lttng_action_incr_value_borrow_key_mutable(action, &key); + if (action_status != LTTNG_ACTION_STATUS_OK) { + ERR("Key not set for incr-value action"); + ret = LTTNG_ERR_INVALID_MAP; + goto end; + } + + /* Returns a refcounted reference */ + session = session_find_by_name(session_name); + if(!session) { + DBG("Session not found for incr-value action: session-name=%s", + session_name); + ret = LTTNG_OK; + goto end; + } + + cond_status = lttng_condition_on_event_get_rule(condition, &event_rule); + if (cond_status != LTTNG_CONDITION_STATUS_OK) { + ERR("Error getting on-event condition event-rule"); + ret = LTTNG_ERR_INVALID_MAP; + session_put(session); + goto end; + } + + action_tracer_token = lttng_action_incr_value_get_tracer_token(action); + + switch (lttng_event_rule_get_domain_type(event_rule)) { + case LTTNG_DOMAIN_UST: + ret = sync_incr_value_action_ust(session, condition, + map_name, action_tracer_token, key, state); + if (ret == LTTNG_ERR_UST_EVENT_EXIST) { + DBG("Incr-value action already registered"); + ret = LTTNG_OK; + } + break; + case LTTNG_DOMAIN_KERNEL: + ret = sync_incr_value_action_kernel(session, creds, condition, + map_name, action_tracer_token, key, state); + if (ret == LTTNG_ERR_KERN_EVENT_EXIST) { + DBG("Incr-value action already registered"); + ret = LTTNG_OK; + } + break; + default: + abort(); + } + + goto end; +end: + if (session) { + session_put(session); + } + return ret; +} + +static +enum lttng_error_code sync_one_tracer_executed_action( + const struct lttng_credentials *creds, + const struct lttng_condition *condition, + const struct lttng_action *action, + enum tracer_executed_action_state state) +{ + enum lttng_action_type action_type; + enum lttng_error_code ret; + + action_type = lttng_action_get_type(action); + assert(action_type != LTTNG_ACTION_TYPE_GROUP); + + switch (action_type) { + case LTTNG_ACTION_TYPE_INCREMENT_VALUE: + DBG("Action type \"%s\" is a tracer executed action.", + lttng_action_type_string(action_type)); + + ret = sync_incr_value_action(creds, condition, action, state); + if (ret != LTTNG_OK) { + ERR("Error syncing increment value action to the tracer"); + } + break; + default: + DBG("Action type \"%s\" is not a tracer executed action.", + lttng_action_type_string(action_type)); + ret = LTTNG_OK; + goto end; + } + +end: + return ret; +} + +static +enum lttng_error_code sync_all_tracer_executed_actions( + const struct lttng_trigger *trigger, + const struct lttng_credentials *cmd_creds, + enum tracer_executed_action_state state) +{ + enum lttng_error_code ret; + unsigned int i, count; + enum lttng_action_status action_status; + enum lttng_action_type action_type; + const struct lttng_action *action; + const struct lttng_condition *condition; + + condition = lttng_trigger_get_const_condition(trigger); + action = lttng_trigger_get_const_action(trigger); + + action_type = lttng_action_get_type(action); + + DBG("Iterating over all actions of trigger \"%s\" to sync any tracer executed actions", + trigger->name); + + if (action_type != LTTNG_ACTION_TYPE_GROUP) { + ret = sync_one_tracer_executed_action(cmd_creds, condition, action, + state); + } else { + action_status = lttng_action_group_get_count(action, &count); + assert(action_status == LTTNG_ACTION_STATUS_OK); + + for (i = 0; i < count; i++) { + const struct lttng_action *inner_action = + lttng_action_group_get_at_index(action, i); + + ret = sync_one_tracer_executed_action(cmd_creds, condition, + inner_action, state); + if (ret != LTTNG_OK) { + ERR("Error syncing tracer executed action"); + goto end; + } + } + } + +end: + return ret; +} + /* * Fill lttng_channel array of all channels. */ @@ -400,95 +743,69 @@ end: } } -static int increment_extended_len(const char *filter_expression, - struct lttng_event_exclusion *exclusion, - const struct lttng_userspace_probe_location *probe_location, - size_t *extended_len) -{ - int ret = 0; - - *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; - } - - if (probe_location) { - ret = lttng_userspace_probe_location_serialize(probe_location, - NULL, NULL); - if (ret < 0) { - goto end; - } - *extended_len += ret; - } - ret = 0; -end: - return ret; -} - static int append_extended_info(const char *filter_expression, struct lttng_event_exclusion *exclusion, struct lttng_userspace_probe_location *probe_location, - void **extended_at) + struct lttng_payload *payload) { int ret = 0; size_t filter_len = 0; size_t nb_exclusions = 0; size_t userspace_probe_location_len = 0; - struct lttng_dynamic_buffer location_buffer; - struct lttcomm_event_extended_header extended_header; + struct lttcomm_event_extended_header extended_header = {}; + struct lttcomm_event_extended_header *p_extended_header; + const size_t original_payload_size = payload->buffer.size; + + ret = lttng_dynamic_buffer_append(&payload->buffer, &extended_header, + sizeof(extended_header)); + if (ret) { + goto end; + } if (filter_expression) { filter_len = strlen(filter_expression) + 1; + ret = lttng_dynamic_buffer_append(&payload->buffer, + filter_expression, filter_len); + if (ret) { + goto end; + } } if (exclusion) { + const size_t len = exclusion->count * LTTNG_SYMBOL_NAME_LEN; + nb_exclusions = exclusion->count; + + ret = lttng_dynamic_buffer_append( + &payload->buffer, &exclusion->names, len); + if (ret) { + goto end; + } } if (probe_location) { - lttng_dynamic_buffer_init(&location_buffer); + const size_t size_before_probe = payload->buffer.size; + ret = lttng_userspace_probe_location_serialize(probe_location, - &location_buffer, NULL); + payload); if (ret < 0) { ret = -1; goto end; } - userspace_probe_location_len = location_buffer.size; - } - - /* Set header fields */ - extended_header.filter_len = filter_len; - extended_header.nb_exclusions = nb_exclusions; - extended_header.userspace_probe_location_len = userspace_probe_location_len; - - /* 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; + userspace_probe_location_len = + payload->buffer.size - size_before_probe; } - /* Copy exclusion names */ - if (exclusion) { - size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN; + /* Set header fields */ + p_extended_header = (struct lttcomm_event_extended_header *) + (payload->buffer.data + original_payload_size); - memcpy(*extended_at, &exclusion->names, len); - *extended_at += len; - } + p_extended_header->filter_len = filter_len; + p_extended_header->nb_exclusions = nb_exclusions; + p_extended_header->userspace_probe_location_len = + userspace_probe_location_len; - if (probe_location) { - memcpy(*extended_at, location_buffer.data, location_buffer.size); - *extended_at += location_buffer.size; - lttng_dynamic_buffer_reset(&location_buffer); - } ret = 0; end: return ret; @@ -500,89 +817,61 @@ end: * 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) + struct lttng_payload *payload) { - int i = 0, ret = 0; - unsigned int nb_event = 0; - struct agent_event *event; - struct lttng_event *tmp_events = NULL; + int nb_events = 0, ret = 0; + const struct agent_event *agent_event; struct lttng_ht_iter iter; - size_t extended_len = 0; - void *extended_at; assert(agt); - assert(events); 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); + cds_lfht_for_each_entry ( + agt->events->ht, &iter.iter, agent_event, node.node) { + struct lttng_event event = { + .enabled = AGENT_EVENT_IS_ENABLED(agent_event), + .loglevel = agent_event->loglevel_value, + .loglevel_type = agent_event->loglevel_type, + }; + + ret = lttng_strncpy(event.name, agent_event->name, sizeof(event.name)); + if (ret) { + /* Internal error, invalid name. */ + ERR("Invalid event name while listing agent events: '%s' exceeds the maximal allowed length of %zu bytes", + agent_event->name, sizeof(event.name)); + ret = -LTTNG_ERR_UNK; + goto end; + } - /* - * 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) { - ret = increment_extended_len(event->filter_expression, NULL, NULL, - &extended_len); + ret = lttng_dynamic_buffer_append( + &payload->buffer, &event, sizeof(event)); if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + 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; - goto error; + nb_events++; } - extended_at = ((uint8_t *) tmp_events) + - nb_event * sizeof(struct lttng_event); - - 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++; - - /* Append extended info */ - ret = append_extended_info(event->filter_expression, NULL, NULL, - &extended_at); + cds_lfht_for_each_entry ( + agt->events->ht, &iter.iter, agent_event, node.node) { + /* Append extended info. */ + ret = append_extended_info(agent_event->filter_expression, NULL, + NULL, payload); if (ret) { - DBG("Error appending extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; + ERR("Failed to append extended event info to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; } } - *events = tmp_events; - ret = nb_event; - assert(nb_event == i); - + ret = nb_events; end: rcu_read_unlock(); return ret; -error: - free(tmp_events); - goto end; } /* @@ -590,23 +879,20 @@ error: */ static int 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 *payload) { - int i = 0, ret = 0; - unsigned int nb_event = 0; + int ret = 0; + unsigned int nb_events = 0; 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; + const struct lttng_ht_node_str *node; + const struct ltt_ust_channel *uchan; + const struct ltt_ust_event *uevent; 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; @@ -615,99 +901,81 @@ static int list_lttng_ust_global_events(char *channel_name, 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; - goto end; - } - - DBG3("Listing UST global %d events", nb_event); + DBG3("Listing UST global events"); - /* Compute required extended infos size */ cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + struct lttng_event event = {}; + if (uevent->internal) { - nb_event--; continue; } - ret = increment_extended_len(uevent->filter_expression, - uevent->exclusion, NULL, &extended_len); + ret = lttng_strncpy(event.name, uevent->attr.name, sizeof(event.name)); if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; + /* Internal error, invalid name. */ + ERR("Invalid event name while listing user space tracer events: '%s' exceeds the maximal allowed length of %zu bytes", + uevent->attr.name, sizeof(event.name)); + ret = -LTTNG_ERR_UNK; goto end; } - } - if (nb_event == 0) { - /* All events are internal, skip. */ - ret = 0; - *total_size = 0; - goto end; - } - - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - tmp = zmalloc(*total_size); - if (tmp == NULL) { - ret = -LTTNG_ERR_FATAL; - goto end; - } - extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event); - - cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { - if (uevent->internal) { - /* This event should remain hidden from clients */ - 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; + event.enabled = uevent->enabled; switch (uevent->attr.instrumentation) { case LTTNG_UST_TRACEPOINT: - tmp[i].type = LTTNG_EVENT_TRACEPOINT; + event.type = LTTNG_EVENT_TRACEPOINT; break; case LTTNG_UST_PROBE: - tmp[i].type = LTTNG_EVENT_PROBE; + event.type = LTTNG_EVENT_PROBE; break; case LTTNG_UST_FUNCTION: - tmp[i].type = LTTNG_EVENT_FUNCTION; + event.type = LTTNG_EVENT_FUNCTION; break; } - tmp[i].loglevel = uevent->attr.loglevel; + event.loglevel = uevent->attr.loglevel; switch (uevent->attr.loglevel_type) { case LTTNG_UST_LOGLEVEL_ALL: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; break; case LTTNG_UST_LOGLEVEL_RANGE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; break; case LTTNG_UST_LOGLEVEL_SINGLE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; break; } + if (uevent->filter) { - tmp[i].filter = 1; + event.filter = 1; } + if (uevent->exclusion) { - tmp[i].exclusion = 1; + event.exclusion = 1; } - i++; - /* Append extended info */ + ret = lttng_dynamic_buffer_append(&payload->buffer, &event, sizeof(event)); + if (ret) { + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + nb_events++; + } + + cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + /* Append extended info. */ ret = append_extended_info(uevent->filter_expression, - uevent->exclusion, NULL, &extended_at); + uevent->exclusion, NULL, payload); if (ret) { - DBG("Error appending extended info message"); + ERR("Failed to append extended event info to payload"); ret = -LTTNG_ERR_FATAL; goto end; } } - ret = nb_event; - *events = tmp; + ret = nb_events; end: rcu_read_unlock(); return ret; @@ -718,14 +986,12 @@ end: */ static int list_lttng_kernel_events(char *channel_name, struct ltt_kernel_session *kernel_session, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *payload) { - int i = 0, ret; + int ret; unsigned int nb_event; - struct ltt_kernel_event *event; - struct ltt_kernel_channel *kchan; - size_t extended_len = 0; - void *extended_at; + const struct ltt_kernel_event *kevent; + const struct ltt_kernel_channel *kchan; kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); if (kchan == NULL) { @@ -737,69 +1003,50 @@ static int list_lttng_kernel_events(char *channel_name, DBG("Listing events for channel %s", kchan->channel->name); - if (nb_event == 0) { - *total_size = 0; - *events = NULL; - goto end; - } + /* Kernel channels */ + cds_list_for_each_entry(kevent, &kchan->events_list.head , list) { + struct lttng_event event = {}; - /* Compute required extended infos size */ - cds_list_for_each_entry(event, &kchan->events_list.head, list) { - ret = increment_extended_len(event->filter_expression, NULL, - event->userspace_probe_location, - &extended_len); + ret = lttng_strncpy(event.name, kevent->event->name, sizeof(event.name)); if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; + /* Internal error, invalid name. */ + ERR("Invalid event name while listing kernel events: '%s' exceeds the maximal allowed length of %zu bytes", + kevent->event->name, + sizeof(event.name)); + ret = -LTTNG_ERR_UNK; + goto end; } - } - - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - *events = zmalloc(*total_size); - if (*events == NULL) { - ret = -LTTNG_ERR_FATAL; - goto error; - } - extended_at = ((void *) *events) + - nb_event * sizeof(struct lttng_event); + event.enabled = kevent->enabled; + event.filter = (unsigned char) !!kevent->filter_expression; - /* 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; - - switch (event->event->instrumentation) { + switch (kevent->event->instrumentation) { case LTTNG_KERNEL_TRACEPOINT: - (*events)[i].type = LTTNG_EVENT_TRACEPOINT; + 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, + event.type = LTTNG_EVENT_FUNCTION; + memcpy(&event.attr.probe, &kevent->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_KPROBE: - (*events)[i].type = LTTNG_EVENT_PROBE; - memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, + event.type = LTTNG_EVENT_PROBE; + memcpy(&event.attr.probe, &kevent->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_UPROBE: - (*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE; + event.type = LTTNG_EVENT_USERSPACE_PROBE; break; case LTTNG_KERNEL_FUNCTION: - (*events)[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, + event.type = LTTNG_EVENT_FUNCTION; + memcpy(&event.attr.ftrace, &kevent->event->u.ftrace, sizeof(struct lttng_kernel_function)); break; case LTTNG_KERNEL_NOOP: - (*events)[i].type = LTTNG_EVENT_NOOP; + event.type = LTTNG_EVENT_NOOP; break; case LTTNG_KERNEL_SYSCALL: - (*events)[i].type = LTTNG_EVENT_SYSCALL; + event.type = LTTNG_EVENT_SYSCALL; break; case LTTNG_KERNEL_ALL: /* fall-through. */ @@ -807,11 +1054,20 @@ static int list_lttng_kernel_events(char *channel_name, assert(0); break; } - i++; - /* Append extended info */ - ret = append_extended_info(event->filter_expression, NULL, - event->userspace_probe_location, &extended_at); + ret = lttng_dynamic_buffer_append( + &payload->buffer, &event, sizeof(event)); + if (ret) { + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + } + + cds_list_for_each_entry(kevent, &kchan->events_list.head , list) { + /* Append extended info. */ + ret = append_extended_info(kevent->filter_expression, NULL, + kevent->userspace_probe_location, payload); if (ret) { DBG("Error appending extended info message"); ret = -LTTNG_ERR_FATAL; @@ -821,10 +1077,8 @@ static int list_lttng_kernel_events(char *channel_name, end: return nb_event; - error: - /* Negate the error code to differentiate the size from an error */ - return -ret; + return ret; } /* @@ -998,6 +1252,8 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, /* 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 */ @@ -1012,6 +1268,16 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, } 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 { @@ -1048,7 +1314,7 @@ static enum lttng_error_code send_consumer_relayd_socket( struct consumer_socket *consumer_sock, const char *session_name, const char *hostname, const char *base_path, int session_live_timer, - const uint64_t *current_chunk_id, + const uint64_t *current_chunk_id, time_t session_creation_time, bool session_name_contains_creation_time) { @@ -1176,15 +1442,16 @@ 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 = {}; + LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; - assert(session); + assert(session); usess = session->ust_session; ksess = session->kernel_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); @@ -1198,8 +1465,6 @@ int cmd_setup_relayd(struct ltt_session *session) } } - rcu_read_lock(); - if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET && usess->consumer->enabled) { /* For each consumer socket, send relayd sockets */ @@ -1225,6 +1490,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 @@ -1251,6 +1518,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: @@ -1261,7 +1530,7 @@ error: /* * Start a kernel session by opening all necessary streams. */ -static int start_kernel_session(struct ltt_kernel_session *ksess) +int start_kernel_session(struct ltt_kernel_session *ksess) { int ret; struct ltt_kernel_channel *kchan; @@ -1323,133 +1592,71 @@ error: return ret; } -/* - * Command LTTNG_DISABLE_CHANNEL processed by the client thread. - */ -int cmd_disable_channel(struct ltt_session *session, - enum lttng_domain_type domain, char *channel_name) +int stop_kernel_session(struct ltt_kernel_session *ksess) { + struct ltt_kernel_channel *kchan; + bool error_occurred = false; int ret; - struct ltt_ust_session *usess; - - usess = session->ust_session; - rcu_read_lock(); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - ret = channel_kernel_disable(session->kernel_session, - channel_name); - if (ret != LTTNG_OK) { - goto error; - } - - kernel_wait_quiescent(); - break; + if (!ksess || !ksess->active) { + return LTTNG_OK; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_channel *uchan; - struct lttng_ht *chan_ht; - - chan_ht = usess->domain_global.channels; - - uchan = trace_ust_find_channel_by_name(chan_ht, channel_name); - if (uchan == NULL) { - ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto error; - } + DBG("Stopping kernel tracing"); - ret = channel_ust_disable(usess, uchan); - if (ret != LTTNG_OK) { - goto error; - } - break; - } - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; + ret = kernel_stop_session(ksess); + if (ret < 0) { + ret = LTTNG_ERR_KERN_STOP_FAIL; goto error; } - ret = LTTNG_OK; - -error: - rcu_read_unlock(); - return ret; -} - -/* - * Command LTTNG_TRACK_PID processed by the client thread. - * - * Called with session lock held. - */ -int cmd_track_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; + kernel_wait_quiescent(); - ret = kernel_track_pid(ksess, pid); - if (ret != LTTNG_OK) { - goto error; + /* 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; } - - kernel_wait_quiescent(); - break; } - 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; + /* 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; } - break; - } - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; } - ret = LTTNG_OK; - + ksess->active = 0; + if (error_occurred) { + ret = LTTNG_ERR_UNK; + } else { + ret = LTTNG_OK; + } error: - rcu_read_unlock(); return ret; } /* - * Command LTTNG_UNTRACK_PID processed by the client thread. - * - * Called with session lock held. + * Command LTTNG_DISABLE_CHANNEL processed by the client thread. */ -int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) +int cmd_disable_channel(struct ltt_session *session, + enum lttng_domain_type domain, char *channel_name) { int ret; + struct ltt_ust_session *usess; + + usess = session->ust_session; rcu_read_lock(); switch (domain) { case LTTNG_DOMAIN_KERNEL: { - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - - ret = kernel_untrack_pid(ksess, pid); + ret = channel_kernel_disable(session->kernel_session, + channel_name); if (ret != LTTNG_OK) { goto error; } @@ -1459,11 +1666,18 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, } case LTTNG_DOMAIN_UST: { - struct ltt_ust_session *usess; + struct ltt_ust_channel *uchan; + struct lttng_ht *chan_ht; - usess = session->ust_session; + chan_ht = usess->domain_global.channels; - ret = trace_ust_untrack_pid(usess, pid); + uchan = trace_ust_find_channel_by_name(chan_ht, channel_name); + if (uchan == NULL) { + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } + + ret = channel_ust_disable(usess, uchan); if (ret != LTTNG_OK) { goto error; } @@ -1583,73 +1797,509 @@ int cmd_enable_channel(struct ltt_session *session, ret = channel_kernel_enable(session->kernel_session, kchan); } - if (ret != LTTNG_OK) { - goto error; + if (ret != LTTNG_OK) { + goto error; + } + + kernel_wait_quiescent(); + break; + } + case LTTNG_DOMAIN_UST: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + { + struct ltt_ust_channel *uchan; + + /* + * FIXME + * + * Current agent implementation limitations force us to allow + * only one channel at once in "agent" subdomains. Each + * subdomain has a default channel name which must be strictly + * adhered to. + */ + if (domain->type == LTTNG_DOMAIN_JUL) { + if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } else if (domain->type == LTTNG_DOMAIN_LOG4J) { + if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } else if (domain->type == LTTNG_DOMAIN_PYTHON) { + if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } + + chan_ht = usess->domain_global.channels; + + uchan = trace_ust_find_channel_by_name(chan_ht, attr.name); + if (uchan == NULL) { + ret = channel_ust_create(usess, &attr, domain->buf_type); + if (attr.name[0] != '\0') { + usess->has_non_default_channel = 1; + } + } else { + ret = channel_ust_enable(usess, uchan); + } + break; + } + default: + ret = LTTNG_ERR_UNKNOWN_DOMAIN; + goto error; + } + + if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) { + session->has_non_mmap_channel = true; + } +error: + rcu_read_unlock(); +end: + return ret; +} + +enum lttng_error_code cmd_add_map(struct command_ctx *cmd_ctx, int sock) +{ + int ret; + enum lttng_error_code ret_code; + size_t map_len; + struct lttng_payload map_payload; + ssize_t sock_recv_len; + struct lttng_map *map = NULL; + const struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + lttng_payload_init(&map_payload); + map_len = (size_t) cmd_ctx->lsm.u.add_map.length; + ret = lttng_dynamic_buffer_set_size( + &map_payload.buffer, map_len); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + sock_recv_len = lttcomm_recv_unix_sock( + sock, map_payload.buffer.data, map_len); + if (sock_recv_len < 0 || sock_recv_len != map_len) { + ERR("Failed to receive \"register map\" command payload"); + ret_code = LTTNG_ERR_INVALID_MAP; + goto end; + } + + /* Deserialize map. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &map_payload, 0, -1); + + if (lttng_map_create_from_payload(&view, &map) != map_len) { + ERR("Invalid map payload received in \"add map\" command"); + ret_code = LTTNG_ERR_INVALID_MAP; + goto end; + } + } + + switch (lttng_map_get_domain(map)) { + case LTTNG_DOMAIN_KERNEL: + ret_code = map_kernel_add(cmd_ctx->session->kernel_session, map); + if (ret_code != LTTNG_OK) { + ERR("Creating a new kernel map: %s", lttng_strerror(ret_code)); + goto end; + } + + ret_code = LTTNG_OK; + break; + case LTTNG_DOMAIN_UST: + ret = map_ust_add(cmd_ctx->session->ust_session, map); + if (ret) { + ERR("Creating a new UST map: %s", lttng_strerror(-ret)); + ret_code = ret; + goto end; + } + + ret_code = LTTNG_OK; + break; + default: + abort(); + } + + + { + struct lttng_triggers *triggers = NULL; + enum lttng_trigger_status t_status; + unsigned int count, i; + + /* + * FRDESO: beware of moving this code. This is currently not + * racy because this is executed by the client thread and the + * client thread is the thread registering new triggers. If + * this code is relocate special care must be taken. + */ + ret_code = notification_thread_command_list_triggers( + notification_thread_handle, 0, &triggers); + if (ret_code != LTTNG_OK) { + ret = -1; + goto end; + } + + assert(triggers); + + t_status = lttng_triggers_get_count(triggers, &count); + if (t_status != LTTNG_TRIGGER_STATUS_OK) { + ret = -1; + lttng_triggers_destroy(triggers); + goto end; + } + + for (i = 0; i < count; i++) { + const struct lttng_trigger *trigger; + + trigger = lttng_triggers_get_at_index(triggers, i); + assert(trigger); + + ret_code = sync_all_tracer_executed_actions(trigger, + &cmd_creds, TRACER_EXECUTED_ACTION_STATE_REGISTER); + assert(ret_code == LTTNG_OK); + } + + lttng_triggers_destroy(triggers); + } + + lttng_map_put(map); + +end: + lttng_payload_reset(&map_payload); + return ret_code; +} + +enum lttng_error_code cmd_enable_map(struct ltt_session *session, + enum lttng_domain_type domain, char *map_name) +{ + struct ltt_ust_session *usess = session->ust_session; + enum lttng_error_code ret_code; + + DBG("Enabling map %s for session %s", map_name, session->name); + + rcu_read_lock(); + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_map *kmap; + struct ltt_kernel_session *ksess = session->kernel_session; + + kmap = trace_kernel_get_map_by_name(map_name, ksess); + if (kmap == NULL) { + ret_code = LTTNG_ERR_KERNEL_MAP_NOT_FOUND; + goto error; + } + + ret_code = map_kernel_enable(ksess, kmap); + if (ret_code != LTTNG_OK) { + goto error; + } + break; + } + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_map *umap; + struct lttng_ht *map_ht; + + map_ht = usess->domain_global.maps; + + umap = trace_ust_find_map_by_name(map_ht, map_name); + if (umap == NULL) { + ret_code = LTTNG_ERR_UST_MAP_NOT_FOUND; + goto error; + } + + ret_code = map_ust_enable(usess, umap); + if (ret_code != LTTNG_OK) { + goto error; + } + break; + } + default: + abort(); + } + + ret_code = LTTNG_OK; +error: + rcu_read_unlock(); + return ret_code; +} + +enum lttng_error_code cmd_disable_map(struct ltt_session *session, + enum lttng_domain_type domain, char *map_name) +{ + enum lttng_error_code ret_code; + + rcu_read_lock(); + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_map *kmap; + struct ltt_kernel_session *ksess = session->kernel_session; + + kmap = trace_kernel_get_map_by_name(map_name, ksess); + if (kmap == NULL) { + ret_code = LTTNG_ERR_KERNEL_MAP_NOT_FOUND; + goto error; + } + + ret_code = map_kernel_disable(ksess, kmap); + if (ret_code != LTTNG_OK) { + goto error; + } + break; + } + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_map *umap; + struct lttng_ht *map_ht; + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + map_ht = usess->domain_global.maps; + + umap = trace_ust_find_map_by_name(map_ht, map_name); + if (umap == NULL) { + ret_code = LTTNG_ERR_UST_MAP_NOT_FOUND; + goto error; + } + + ret_code = map_ust_disable(usess, umap); + if (ret_code != LTTNG_OK) { + goto error; + } + break; + } + default: + abort(); + } + + ret_code = LTTNG_OK; + +error: + rcu_read_unlock(); + return ret_code; +} + +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) +{ + enum lttng_error_code ret_code = LTTNG_OK; + const struct process_attr_tracker *tracker; + + 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; +} + +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; + + 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; + } + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + 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; +} + +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; } - - kernel_wait_quiescent(); + tracker = kernel_get_process_attr_tracker( + session->kernel_session, process_attr); break; - } case LTTNG_DOMAIN_UST: - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_PYTHON: - { - struct ltt_ust_channel *uchan; - - /* - * FIXME - * - * Current agent implementation limitations force us to allow - * only one channel at once in "agent" subdomains. Each - * subdomain has a default channel name which must be strictly - * adhered to. - */ - if (domain->type == LTTNG_DOMAIN_JUL) { - if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME, - LTTNG_SYMBOL_NAME_LEN)) { - ret = LTTNG_ERR_INVALID_CHANNEL_NAME; - goto error; - } - } else if (domain->type == LTTNG_DOMAIN_LOG4J) { - if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME, - LTTNG_SYMBOL_NAME_LEN)) { - ret = LTTNG_ERR_INVALID_CHANNEL_NAME; - goto error; - } - } else if (domain->type == LTTNG_DOMAIN_PYTHON) { - if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME, - LTTNG_SYMBOL_NAME_LEN)) { - ret = LTTNG_ERR_INVALID_CHANNEL_NAME; - goto error; - } + 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; + } - chan_ht = usess->domain_global.channels; + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } - uchan = trace_ust_find_channel_by_name(chan_ht, attr.name); - if (uchan == NULL) { - ret = channel_ust_create(usess, &attr, domain->buf_type); - if (attr.name[0] != '\0') { - usess->has_non_default_channel = 1; - } - } else { - ret = channel_ust_enable(usess, uchan); - } + 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 = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; + ret_code = LTTNG_ERR_UNK; + break; } - if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) { - session->has_non_mmap_channel = true; - } -error: - rcu_read_unlock(); end: - return ret; + return ret_code; } /* @@ -2007,7 +2657,7 @@ static int _cmd_enable_event(struct ltt_session *session, 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) { @@ -2090,7 +2740,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, @@ -2237,7 +2887,7 @@ 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.", + WARN("Userspace event name %s failed validation.", event->name); ret = LTTNG_ERR_INVALID_EVENT_NAME; goto error; @@ -2325,11 +2975,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); @@ -2405,7 +3055,7 @@ int cmd_enable_event(struct ltt_session *session, 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) { @@ -2422,7 +3072,7 @@ static int cmd_enable_event_internal(struct ltt_session *session, 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) { @@ -2510,57 +3160,6 @@ ssize_t cmd_list_syscalls(struct lttng_event **events) return syscall_table_list(events); } -/* - * 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) -{ - int ret; - ssize_t nr_pids = 0; - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - - 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; - } - 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; - } - break; - } - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_PYTHON: - default: - ret = LTTNG_ERR_UND; - goto error; - } - - return nr_pids; - -error: - /* Return negative value to differentiate return code */ - return -ret; -} - /* * Command LTTNG_START_TRACE processed by the client thread. * @@ -2569,9 +3168,13 @@ error: int cmd_start_trace(struct ltt_session *session) { enum lttng_error_code ret; - unsigned long nb_chan = 0; + unsigned long nb_chan = 0, nb_map = 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); @@ -2582,6 +3185,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; } @@ -2591,30 +3211,58 @@ int cmd_start_trace(struct ltt_session *session) */ if (usess && usess->domain_global.channels) { nb_chan += lttng_ht_get_count(usess->domain_global.channels); + nb_map += lttng_ht_get_count(usess->domain_global.maps); } if (ksession) { nb_chan += ksession->channel_count; + nb_map += ksession->map_count; } - if (!nb_chan) { + if (!nb_chan && !nb_map) { ret = LTTNG_ERR_NO_CHANNEL; 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) { - struct lttng_trace_chunk *trace_chunk; + if (!session->has_been_started) { + struct lttng_trace_chunk *trace_chunk; - 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; + 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; + } } } @@ -2637,9 +3285,15 @@ int cmd_start_trace(struct ltt_session *session) } } - /* 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 @@ -2661,6 +3315,18 @@ int cmd_start_trace(struct ltt_session *session) 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; } @@ -2670,14 +3336,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; - bool error_occurred = false; assert(session); - DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id); + DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id); /* Short cut */ ksession = session->kernel_session; usess = session->ust_session; @@ -2688,39 +3352,9 @@ 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(); - - /* 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"); - error_occurred = true; - } - } - - /* 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"); - error_occurred = true; - } - } - - ksession->active = 0; - DBG("Kernel session stopped %s (id %" PRIu64 ")", session->name, - session->id); + ret = stop_kernel_session(ksession); + if (ret != LTTNG_OK) { + goto error; } if (usess && usess->active) { @@ -2731,33 +3365,26 @@ 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 = !error_occurred ? LTTNG_OK : LTTNG_ERR_UNK; + ret = LTTNG_OK; error: return ret; } /* - * Command LTTNG_SET_CONSUMER_URI processed by the client thread. + * Set the base_path of the session only if subdir of a control uris is set. + * Return LTTNG_OK on success, otherwise LTTNG_ERR_*. */ -int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, +static int set_session_base_path_from_uris(struct ltt_session *session, + size_t nb_uri, struct lttng_uri *uris) { - int ret, i; - struct ltt_kernel_session *ksess = session->kernel_session; - struct ltt_ust_session *usess = session->ust_session; - - assert(session); - assert(uris); - assert(nb_uri > 0); - - /* Can't set consumer URI if the session is active. */ - if (session->active) { - ret = LTTNG_ERR_TRACE_ALREADY_STARTED; - goto error; - } + int ret; + size_t i; for (i = 0; i < nb_uri; i++) { if (uris[i].stype != LTTNG_STREAM_CONTROL || @@ -2774,11 +3401,47 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, /* Set session base_path */ session->base_path = strdup(uris[i].subdir); if (!session->base_path) { - PERROR("Copying base path: %s", uris[i].subdir); + 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 for session %" PRIu64 ": %s", - session->id, session->base_path); + 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. + */ +int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, + struct lttng_uri *uris) +{ + int ret, i; + struct ltt_kernel_session *ksess = session->kernel_session; + struct ltt_ust_session *usess = session->ust_session; + + assert(session); + assert(uris); + assert(nb_uri > 0); + + /* Can't set consumer URI if the session is active. */ + if (session->active) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + 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 */ @@ -3015,19 +3678,19 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, enum lttng_error_code ret_code; lttng_dynamic_buffer_init(&payload); - if (cmd_ctx->lsm->u.create_session.home_dir_size >= + 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 > + if (cmd_ctx->lsm.u.create_session.session_descriptor_size > LTTNG_SESSION_DESCRIPTOR_MAX_LEN) { ret_code = LTTNG_ERR_INVALID; goto error; } - payload_size = cmd_ctx->lsm->u.create_session.home_dir_size + - cmd_ctx->lsm->u.create_session.session_descriptor_size; + 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; @@ -3044,11 +3707,23 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, home_dir_view = lttng_buffer_view_from_dynamic_buffer( &payload, 0, - cmd_ctx->lsm->u.create_session.home_dir_size); + 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; + } + 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); + 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; + } ret = lttng_session_descriptor_create_from_buffer( &session_descriptor_view, &session_descriptor); @@ -3102,10 +3777,10 @@ void cmd_destroy_session_reply(const struct ltt_session *session, lttng_dynamic_buffer_init(&payload); ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm)); - if (ret) { + if (ret) { ERR("Failed to append session destruction message"); goto error; - } + } cmd_header.rotation_state = (int32_t) (reply_context->implicit_rotation_on_destroy ? @@ -3216,23 +3891,22 @@ int cmd_destroy_session(struct ltt_session *session, session->rotate_size = 0; } - if (session->most_recent_chunk_id.is_set && - session->most_recent_chunk_id.value != 0 && - session->current_trace_chunk && session->output_traces) { + 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); + 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) { + if (reply_context) { reply_context->implicit_rotation_on_destroy = true; - } - } else if (session->has_been_started && session->current_trace_chunk) { + } + } 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 @@ -3242,10 +3916,19 @@ int cmd_destroy_session(struct ltt_session *session, * emitted and no renaming of the current trace chunk takes * place. */ - ret = cmd_rotate_session(session, NULL, true); - if (ret != LTTNG_OK) { + 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)); + session->name, lttng_strerror(ret)); destruction_last_error = -ret; } } @@ -3321,8 +4004,8 @@ int cmd_destroy_session(struct ltt_session *session, } else { *sock_fd = -1; } - } - ret = LTTNG_OK; + } + ret = LTTNG_OK; end: return ret; } @@ -3537,13 +4220,71 @@ ssize_t cmd_list_channels(enum lttng_domain_type domain, *channels = NULL; goto end; } - } else { - *channels = NULL; + } else { + *channels = NULL; + } + + ret = payload_size; +end: + return ret; +} + +enum lttng_error_code cmd_list_maps(enum lttng_domain_type domain, + struct ltt_session *session, + struct lttng_map_list **return_map_list) +{ + enum lttng_error_code ret_code; + struct lttng_map_list *map_list = NULL; + + map_list = lttng_map_list_create(); + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (session->kernel_session != NULL) { + struct ltt_kernel_map *kmap; + cds_list_for_each_entry(kmap, + &session->kernel_session->map_list.head, list) { + enum lttng_map_status map_status; + map_status = lttng_map_list_add(map_list, kmap->map); + if (map_status != LTTNG_MAP_STATUS_OK) { + ERR("Error appending kernel map to list"); + ret_code = LTTNG_ERR_FATAL; + break; + } + } + + } + break; + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_map *umap; + struct lttng_ht_iter iter; + + rcu_read_lock(); + cds_lfht_for_each_entry(session->ust_session->domain_global.maps->ht, + &iter.iter, umap, node.node) { + enum lttng_map_status map_status; + map_status = lttng_map_list_add(map_list, umap->map); + if (map_status != LTTNG_MAP_STATUS_OK) { + ERR("Error appending UST map to list"); + ret_code = LTTNG_ERR_FATAL; + break; + } + } + rcu_read_unlock(); + break; + } + default: + ret_code = LTTNG_ERR_UND; + goto end; } - ret = payload_size; + *return_map_list = map_list; + map_list = NULL; + ret_code = LTTNG_OK; end: - return ret; + lttng_map_list_destroy(map_list); + return ret_code; } /* @@ -3551,25 +4292,33 @@ end: */ 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) + struct lttng_payload *payload) { int ret = 0; - ssize_t nb_event = 0; + ssize_t nb_events = 0; + struct lttcomm_event_command_header cmd_header = {}; + const size_t cmd_header_offset = payload->buffer.size; + + ret = lttng_dynamic_buffer_append( + &payload->buffer, &cmd_header, sizeof(cmd_header)); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error; + } 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); + nb_events = list_lttng_kernel_events(channel_name, + session->kernel_session, payload); } 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); + nb_events = list_lttng_ust_global_events(channel_name, + &session->ust_session->domain_global, + payload); } break; } @@ -3584,9 +4333,8 @@ 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); + nb_events = list_lttng_agent_events( + agt, payload); break; } } @@ -3598,7 +4346,10 @@ ssize_t cmd_list_events(enum lttng_domain_type domain, goto error; } - return nb_event; + ((struct lttcomm_event_command_header *) (payload->buffer.data + + cmd_header_offset))->nb_events = (uint32_t) nb_events; + + return nb_events; error: /* Return negative value to differentiate return code */ @@ -3619,7 +4370,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, unsigned int i = 0; struct ltt_session *session; struct ltt_session_list *list = session_get_list(); - struct lttng_session_extended *extended = + struct lttng_session_extended *extended = (typeof(extended)) (&sessions[session_count]); DBG("Getting all available session for UID %d GID %d", @@ -3635,7 +4386,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, /* * 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; @@ -4086,7 +4837,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) { @@ -4127,7 +4878,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) { @@ -4176,91 +4927,426 @@ 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; + enum lttng_error_code ret_code; + struct lttng_condition *condition = lttng_trigger_get_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); - 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_owner_uid(trigger, &trigger_owner); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + assert(condition); + assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT); + + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(unnamed)"; + + 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_NONE: + abort(); + default: + { + /* Agent domains. */ + struct agent *agt = agent_find_by_event_notifier_domain( + trigger_domain); + if (!agt) { + agt = agent_create(trigger_domain); + if (!agt) { + ret_code = LTTNG_ERR_NOMEM; + goto end_unlock_session_list; + } + agent_add(agt, trigger_agents_ht_by_domain); + } + + ret_code = trigger_agent_enable(trigger, agt); + if (ret_code != LTTNG_OK) { + goto end_unlock_session_list; + } + + break; + } } - 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; + ret_code = LTTNG_OK; +end_unlock_session_list: + session_unlock_list(); + return ret_code; +} + +enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds, + struct lttng_trigger *trigger, + struct notification_thread_handle *notification_thread, + struct lttng_trigger **return_trigger) +{ + enum lttng_error_code ret_code; + const char *trigger_name; + const struct lttng_condition *condition; + uid_t trigger_owner; + enum lttng_trigger_status trigger_status; + + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(unnamed)"; + + 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; + } } - 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; + /* + * 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; } - ret = notification_thread_command_register_trigger(notification_thread, + /* + * 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); - /* Ownership of trigger was transferred. */ - trigger = NULL; + 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; + } + + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? + trigger_name : "(unnamed)"; + + /* + * 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"); + goto end; + } + } + + condition = lttng_trigger_get_const_condition(trigger); + + /* TODO: Extract condition below to lttng_trigger internal function */ + if (lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT) { + session_lock_list(); + ret_code = sync_all_tracer_executed_actions(trigger, + cmd_creds, TRACER_EXECUTED_ACTION_STATE_REGISTER); + session_unlock_list(); + if (ret_code != LTTNG_OK) { + ERR("Error registering tracer executed actions"); + 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; +} + +static +enum lttng_error_code synchronize_tracer_notifier_unregister( + const struct lttng_trigger *trigger) +{ + 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_ON_EVENT); + + session_lock_list(); + switch (trigger_domain) { + case LTTNG_DOMAIN_KERNEL: + ret_code = kernel_unregister_event_notifier(trigger); + break; + case LTTNG_DOMAIN_UST: + ust_app_global_update_all_event_notifier_rules(); + break; + case LTTNG_DOMAIN_NONE: + abort(); + default: + { + /* Agent domains. */ + struct agent *agt = agent_find_by_event_notifier_domain( + trigger_domain); + if (!agt) { + agt = agent_create(trigger_domain); + if (!agt) { + ret_code = LTTNG_ERR_NOMEM; + goto end_unlock_session_list; + } + agent_add(agt, trigger_agents_ht_by_domain); + } + + ret_code = trigger_agent_disable(trigger, agt); + if (ret_code != LTTNG_OK) { + goto end_unlock_session_list; + } + + break; + } + } + + 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, +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; - 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; + struct lttng_trigger *real_trigger; + 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; + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(unnamed)"; + 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)); + + /* + * Validate the trigger credentials against the command credentials. + * Only the root user can unregister 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; + } + } + + ret_code = notification_thread_command_get_trigger( + notification_thread, trigger, &real_trigger); + if (ret_code != LTTNG_OK) { + DBG("Failed to get the real trigger from notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d", + trigger_name, (int) trigger_owner, ret_code); + goto end; + } + + ret_code = notification_thread_command_unregister_trigger( + notification_thread, real_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; + } + + /* + * 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(real_trigger)) { + ret_code = synchronize_tracer_notifier_unregister(real_trigger); + if (ret_code != LTTNG_OK) { + ERR("Error unregistering trigger to tracer."); + goto end; + } + + } + + session_lock_list(); + ret_code = sync_all_tracer_executed_actions(real_trigger, + cmd_creds, TRACER_EXECUTED_ACTION_STATE_UNREGISTER); + session_unlock_list(); + if (ret_code != LTTNG_OK) { + ERR("Error registering tracer executed actions"); 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; + lttng_trigger_put(real_trigger); +end: + return ret_code; +} + +int cmd_list_triggers(struct command_ctx *cmd_ctx, + struct notification_thread_handle *notification_thread, + struct lttng_triggers **return_triggers) +{ + int ret = 0; + enum lttng_error_code ret_code; + struct lttng_triggers *triggers = NULL; + + /* 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) { + ret = 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; + *return_triggers = triggers; + triggers = NULL; + ret = LTTNG_OK; +end: + lttng_triggers_destroy(triggers); + return ret; +} + +int cmd_list_map_values(const char *session_name, + const struct lttng_map *map, + const struct lttng_map_query *map_query, + struct lttng_map_content **return_map_content) +{ + enum lttng_error_code ret; + struct ltt_session *session; + enum lttng_domain_type domain; + const char *map_name; + enum lttng_map_status map_status; + + /* Returns a refcounted reference */ + session = session_find_by_name(session_name); + if (!session) { + DBG("Session '%s' not found", session_name); + ret = LTTNG_ERR_SESS_NOT_FOUND; goto end; } - ret = notification_thread_command_unregister_trigger(notification_thread, - trigger); + domain = lttng_map_get_domain(map); + + map_status = lttng_map_get_name(map, &map_name); + assert(map_status == LTTNG_MAP_STATUS_OK); + + if (domain == LTTNG_DOMAIN_KERNEL) { + if (session->kernel_session) { + struct ltt_kernel_map *kmap; + + kmap = trace_kernel_get_map_by_name(map_name, + session->kernel_session); + if (kmap) { + ret = kernel_list_map_values(kmap, map_query, + return_map_content); + if (ret != LTTNG_OK) { + ERR("Error listing kernel map '%s' values", map_name); + goto end; + } + } else { + DBG("No kernel map '%s' in session '%s'", map_name, session_name); + } + } + } else if (domain == LTTNG_DOMAIN_UST) { + if (session->ust_session) { + struct ltt_ust_map *umap; + struct ltt_ust_session *usess = session->ust_session; + + umap = trace_ust_find_map_by_name( + usess->domain_global.maps, map_name); + if (umap) { + ret = ust_app_map_list_values(usess, umap, + map_query, return_map_content); + if (ret) { + ret = LTTNG_ERR_MAP_VALUES_LIST_FAIL; + ERR("Error listing UST map '%s' values", map_name); + goto end; + } + } else { + DBG("No UST map '%s' in session '%s'", map_name, session_name); + } + } + } + + + ret = LTTNG_OK; end: - lttng_trigger_destroy(trigger); - lttng_dynamic_buffer_reset(&trigger_buffer); + session_put(session); return ret; } @@ -4467,7 +5553,7 @@ int64_t get_session_nb_packets_per_stream(const struct ltt_session *session, } 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; } @@ -4580,7 +5666,7 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, snapshot_output->max_size); if (nb_packets_per_stream < 0) { ret_code = LTTNG_ERR_MAX_SIZE_INVALID; - goto error; + goto error_close_trace_chunk; } if (session->kernel_session) { @@ -4588,7 +5674,7 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, snapshot_kernel_consumer_output, session, wait, nb_packets_per_stream); if (ret_code != LTTNG_OK) { - goto error; + goto error_close_trace_chunk; } } @@ -4597,12 +5683,19 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, snapshot_ust_consumer_output, session, wait, nb_packets_per_stream); if (ret_code != LTTNG_OK) { - goto error; + goto error_close_trace_chunk; } } - if (session_close_trace_chunk( - session, session->current_trace_chunk, NULL, NULL)) { +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. @@ -4611,11 +5704,6 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, session->name); ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; } - if (session_set_trace_chunk(session, NULL, NULL)) { - ERR("Failed to release the current trace chunk of session \"%s\"", - session->name); - ret_code = LTTNG_ERR_UNK; - } error: if (original_ust_consumer_output) { session->ust_session->consumer = original_ust_consumer_output; @@ -4783,7 +5871,7 @@ 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; } /* @@ -4796,7 +5884,8 @@ int cmd_set_session_shm_path(struct ltt_session *session, */ int cmd_rotate_session(struct ltt_session *session, struct lttng_rotate_session_return *rotate_return, - bool quiet_rotation) + bool quiet_rotation, + enum lttng_trace_chunk_command_type command) { int ret; uint64_t ongoing_rotation_chunk_id; @@ -4834,6 +5923,12 @@ int cmd_rotate_session(struct ltt_session *session, 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); @@ -4852,7 +5947,16 @@ int cmd_rotate_session(struct ltt_session *session, goto end; } - session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + /* + * 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, @@ -4861,7 +5965,7 @@ int cmd_rotate_session(struct ltt_session *session, cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; goto error; } - } + } /* * The current trace chunk becomes the chunk being archived. @@ -4877,11 +5981,6 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - assert(chunk_being_archived); - chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, - &ongoing_rotation_chunk_id); - assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); - if (session->kernel_session) { cmd_ret = kernel_rotate_session(session); if (cmd_ret != LTTNG_OK) { @@ -4897,12 +5996,28 @@ int cmd_rotate_session(struct ltt_session *session, } } + 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, - quiet_rotation ? - NULL : - &((enum lttng_trace_chunk_command_type){ - LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}), - session->last_chunk_path); + command, session->last_chunk_path); if (ret) { cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; goto error; @@ -4921,10 +6036,6 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - if (!session->active) { - session->rotated_after_last_stop = true; - } - if (rotate_return) { rotate_return->rotation_id = ongoing_rotation_chunk_id; } @@ -5113,7 +6224,7 @@ end: * 'activate' to false means deactivate the rotation schedule and validate that * 'new_value' has the same value as the currently active value. * - * Return 0 on success or else a positive LTTNG_ERR code. + * 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,