X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=2f5a4e98c74978d8ac8d7480cb539bc595e2afd7;hp=2963577563cc94aa658003e89095c95b36fdb770;hb=fbc9f37df245d544a7705ba576297df791220b44;hpb=c0a66c84b5b2484b75798aec7543b680b4d4ab6c diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 296357756..2f5a4e98c 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -6,10 +6,6 @@ * */ -#include "bin/lttng-sessiond/tracker.h" -#include "common/sessiond-comm/payload.h" -#include "lttng/lttng-error.h" -#include "lttng/tracker.h" #define _LGPL_SOURCE #include #include @@ -27,8 +23,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -41,6 +37,8 @@ #include #include #include +#include +#include #include #include "channel.h" @@ -60,6 +58,7 @@ #include "rotation-thread.h" #include "timer.h" #include "agent-thread.h" +#include "tracker.h" #include "cmd.h" @@ -396,95 +395,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; @@ -496,89 +469,55 @@ 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); - - /* - * 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); + cds_lfht_for_each_entry ( + agt->events->ht, &iter.iter, agent_event, node.node) { + struct lttng_event event = { + .enabled = agent_event->enabled, + .loglevel = agent_event->loglevel_value, + .loglevel_type = agent_event->loglevel_type, + }; + + strncpy(event.name, agent_event->name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; + + 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; } /* @@ -586,23 +525,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; @@ -611,99 +547,75 @@ 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); - if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - 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; - } + strncpy(event.name, uevent->attr.name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; - 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; @@ -714,14 +626,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) { @@ -733,69 +643,42 @@ 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; - } - - /* 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); - if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; - } - } - - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - *events = zmalloc(*total_size); - if (*events == NULL) { - ret = -LTTNG_ERR_FATAL; - goto error; - } + /* Kernel channels */ + cds_list_for_each_entry(kevent, &kchan->events_list.head , list) { + struct lttng_event event = {}; - extended_at = ((void *) *events) + - nb_event * sizeof(struct lttng_event); + strncpy(event.name, kevent->event->name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; + 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. */ @@ -803,11 +686,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; @@ -817,10 +709,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; } /* @@ -1056,7 +946,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) { @@ -1184,9 +1074,9 @@ 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; @@ -2398,7 +2288,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; @@ -2794,6 +2684,16 @@ int cmd_start_trace(struct ltt_session *session) } } + /* + * 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. @@ -3177,19 +3077,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; @@ -3206,11 +3106,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); @@ -3264,10 +3176,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 ? @@ -3390,10 +3302,10 @@ int cmd_destroy_session(struct ltt_session *session, 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 @@ -3491,8 +3403,8 @@ int cmd_destroy_session(struct ltt_session *session, } else { *sock_fd = -1; } - } - ret = LTTNG_OK; + } + ret = LTTNG_OK; end: return ret; } @@ -3721,25 +3633,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; } @@ -3754,9 +3674,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; } } @@ -3768,7 +3687,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 */ @@ -3789,7 +3711,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", @@ -3805,7 +3727,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; @@ -4347,16 +4269,21 @@ end: } int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, - struct notification_thread_handle *notification_thread) + 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_payload trigger_payload; + 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(&trigger_payload); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; + trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; ret = lttng_dynamic_buffer_set_size( &trigger_payload.buffer, trigger_len); if (ret) { @@ -4373,6 +4300,20 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, goto end; } + /* Receive fds, if any. */ + if (cmd_ctx->lsm.fd_count > 0) { + ret = lttcomm_recv_payload_fds_unix_sock( + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) { + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } else if (ret <= 0) { + ret = LTTNG_ERR_FATAL; + goto end; + } + } + + /* Deserialize trigger. */ { struct lttng_payload_view view = lttng_payload_view_from_payload( @@ -4386,8 +4327,41 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, } } + /* + * 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"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + + /* + * 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 = notification_thread_command_register_trigger(notification_thread, trigger); + if (ret != LTTNG_OK) { + goto end_notification_thread; + } + + /* Return an updated trigger to the client. */ + *return_trigger = trigger; + +end_notification_thread: /* Ownership of trigger was transferred. */ trigger = NULL; end: @@ -4404,9 +4378,13 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, ssize_t sock_recv_len; struct lttng_trigger *trigger = NULL; struct lttng_payload trigger_payload; + 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(&trigger_payload); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; + trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; ret = lttng_dynamic_buffer_set_size( &trigger_payload.buffer, trigger_len); if (ret) { @@ -4423,6 +4401,19 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, goto end; } + /* Receive fds, if any. */ + if (cmd_ctx->lsm.fd_count > 0) { + ret = lttcomm_recv_payload_fds_unix_sock( + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) { + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } else if (ret <= 0) { + ret = LTTNG_ERR_FATAL; + goto end; + } + } + { struct lttng_payload_view view = lttng_payload_view_from_payload( @@ -4436,6 +4427,21 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, } } + /* + * 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"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + ret = notification_thread_command_unregister_trigger(notification_thread, trigger); end: @@ -4444,6 +4450,29 @@ end: return ret; } +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; + } + + *return_triggers = triggers; + triggers = NULL; + ret = LTTNG_OK; +end: + lttng_triggers_destroy(triggers); + return ret; +} /* * Send relayd sockets from snapshot output to consumer. Ignore request if the * snapshot output is *not* set with a remote destination. @@ -5059,7 +5088,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.