X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=f6f80286963dddff18ba3e91443e86efe5b3eb39;hp=fa7672b5834a370f3484ae43cb3d8f2306ba937a;hb=4a76dfd303409d7a6293aa8bafa8103748c1cf37;hpb=a914e76ac1a529191035f1fec439026c83beee3f diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index fa7672b58..f6f802869 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -1,33 +1,29 @@ /* - * Copyright (C) 2011 - David Goulet - * Mathieu Desnoyers - * 2013 - Jérémie Galarneau + * Copyright (C) 2011 David Goulet + * Copyright (C) 2011 Mathieu Desnoyers + * Copyright (C) 2013 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. */ -#include -#include -#include -#include +#include "common/buffer-view.h" +#include "common/dynamic-buffer.h" +#include "common/sessiond-comm/sessiond-comm.h" +#include "lttng/lttng-error.h" +#include "lttng/tracker.h" #include +#include #include #include -#include #include -#include #include +#include +#include +#include +#include +#include +#include #include "client.h" #include "lttng-sessiond.h" @@ -38,12 +34,14 @@ #include "testpoint.h" #include "utils.h" #include "manage-consumer.h" +#include "clear.h" static bool is_root; static struct thread_state { sem_t ready; bool running; + int client_sock; } thread_state; static void set_thread_status(bool running) @@ -189,7 +187,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) case LTTNG_CONSUMER64_UST: { if (config.consumerd64_lib_dir.value) { - char *tmp; + const char *tmp; size_t tmplen; char *tmpnew; @@ -226,7 +224,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) case LTTNG_CONSUMER32_UST: { if (config.consumerd32_lib_dir.value) { - char *tmp; + const char *tmp; size_t tmplen; char *tmpnew; @@ -410,7 +408,7 @@ error: * Should *NOT* be called with RCU read-side lock held. */ static int create_ust_session(struct ltt_session *session, - struct lttng_domain *domain) + const struct lttng_domain *domain) { int ret; struct ltt_ust_session *lus = NULL; @@ -497,6 +495,7 @@ static int create_kernel_session(struct ltt_session *session) session->kernel_session->gid = session->gid; session->kernel_session->output_traces = session->output_traces; session->kernel_session->snapshot_mode = session->snapshot_mode; + session->kernel_session->is_live_session = session->live_timer != 0; return LTTNG_OK; @@ -746,6 +745,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_ROTATION_GET_INFO: case LTTNG_ROTATION_SET_SCHEDULE: case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: + case LTTNG_CLEAR_SESSION: need_domain = 0; break; default: @@ -786,11 +786,12 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_LIST_CHANNELS: case LTTNG_LIST_EVENTS: case LTTNG_LIST_SYSCALLS: - case LTTNG_LIST_TRACKER_PIDS: + case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: + case LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY: + case LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: case LTTNG_DATA_PENDING: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: - case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: break; default: /* Setup lttng message with no payload */ @@ -950,7 +951,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* Create UST session if none exist. */ if (cmd_ctx->session->ust_session == NULL) { ret = create_ust_session(cmd_ctx->session, - &cmd_ctx->lsm->domain); + ALIGNED_CONST_PTR(cmd_ctx->lsm->domain)); if (ret != LTTNG_OK) { goto error; } @@ -1139,7 +1140,7 @@ skip_domain: ret = cmd_add_context(cmd_ctx->session, cmd_ctx->lsm->domain.type, cmd_ctx->lsm->u.context.channel_name, - &cmd_ctx->lsm->u.context.ctx, + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.context.ctx), kernel_poll_pipe[1]); cmd_ctx->lsm->u.context.ctx.u.app_ctx.provider_name = NULL; @@ -1187,33 +1188,204 @@ error_add_context: count -= (size_t) ret; } } - /* FIXME: passing packed structure to non-packed pointer */ ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type, cmd_ctx->lsm->u.disable.channel_name, - &cmd_ctx->lsm->u.disable.event); + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.disable.event)); break; } case LTTNG_ENABLE_CHANNEL: { cmd_ctx->lsm->u.channel.chan.attr.extended.ptr = (struct lttng_channel_extended *) &cmd_ctx->lsm->u.channel.extended; - ret = cmd_enable_channel(cmd_ctx->session, &cmd_ctx->lsm->domain, - &cmd_ctx->lsm->u.channel.chan, + ret = cmd_enable_channel(cmd_ctx->session, + ALIGNED_CONST_PTR(cmd_ctx->lsm->domain), + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.channel.chan), kernel_poll_pipe[1]); break; } - case LTTNG_TRACK_PID: + case LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE: + case LTTNG_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE: { - ret = cmd_track_pid(cmd_ctx->session, - cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + struct lttng_dynamic_buffer payload; + struct lttng_buffer_view payload_view; + const bool add_value = + cmd_ctx->lsm->cmd_type == + LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE; + const size_t name_len = + cmd_ctx->lsm->u.process_attr_tracker_add_remove_include_value + .name_len; + const enum lttng_domain_type domain_type = + (enum lttng_domain_type) + cmd_ctx->lsm->domain.type; + const enum lttng_process_attr process_attr = + (enum lttng_process_attr) cmd_ctx->lsm->u + .process_attr_tracker_add_remove_include_value + .process_attr; + const enum lttng_process_attr_value_type value_type = + (enum lttng_process_attr_value_type) cmd_ctx + ->lsm->u + .process_attr_tracker_add_remove_include_value + .value_type; + struct process_attr_value *value; + enum lttng_error_code ret_code; + + /* Receive remaining variable length payload if applicable. */ + if (name_len > LOGIN_NAME_MAX) { + /* + * POSIX mandates user and group names that are at least + * 8 characters long. Note that although shadow-utils + * (useradd, groupaadd, etc.) use 32 chars as their + * limit (from bits/utmp.h, UT_NAMESIZE), + * LOGIN_NAME_MAX is defined to 256. + */ + ERR("Rejecting process attribute tracker value %s as the provided exceeds the maximal allowed length: argument length = %zu, maximal length = %d", + add_value ? "addition" : "removal", + name_len, LOGIN_NAME_MAX); + ret = LTTNG_ERR_INVALID; + goto error; + } + + lttng_dynamic_buffer_init(&payload); + if (name_len != 0) { + /* + * Receive variable payload for user/group name + * arguments. + */ + ret = lttng_dynamic_buffer_set_size(&payload, name_len); + if (ret) { + ERR("Failed to allocate buffer to receive payload of %s process attribute tracker value argument", + add_value ? "add" : "remove"); + ret = LTTNG_ERR_NOMEM; + goto error_add_remove_tracker_value; + } + + ret = lttcomm_recv_unix_sock( + *sock, payload.data, name_len); + if (ret <= 0) { + ERR("Failed to receive payload of %s process attribute tracker value argument", + add_value ? "add" : "remove"); + *sock_error = 1; + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto error_add_remove_tracker_value; + } + } + + payload_view = lttng_buffer_view_from_dynamic_buffer( + &payload, 0, name_len); + /* + * Validate the value type and domains are legal for the process + * attribute tracker that is specified and convert the value to + * add/remove to the internal sessiond representation. + */ + ret_code = process_attr_value_from_comm(domain_type, + process_attr, value_type, + &cmd_ctx->lsm->u.process_attr_tracker_add_remove_include_value + .integral_value, + &payload_view, &value); + if (ret_code != LTTNG_OK) { + ret = ret_code; + goto error_add_remove_tracker_value; + } + + if (add_value) { + ret = cmd_process_attr_tracker_inclusion_set_add_value( + cmd_ctx->session, domain_type, + process_attr, value); + } else { + ret = cmd_process_attr_tracker_inclusion_set_remove_value( + cmd_ctx->session, domain_type, + process_attr, value); + } + process_attr_value_destroy(value); + error_add_remove_tracker_value: + lttng_dynamic_buffer_reset(&payload); break; } - case LTTNG_UNTRACK_PID: + case LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY: { - ret = cmd_untrack_pid(cmd_ctx->session, - cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + enum lttng_tracking_policy tracking_policy; + const enum lttng_domain_type domain_type = + (enum lttng_domain_type) + cmd_ctx->lsm->domain.type; + const enum lttng_process_attr process_attr = + (enum lttng_process_attr) cmd_ctx->lsm->u + .process_attr_tracker_get_tracking_policy + .process_attr; + + ret = cmd_process_attr_tracker_get_tracking_policy( + cmd_ctx->session, domain_type, process_attr, + &tracking_policy); + if (ret != LTTNG_OK) { + goto error; + } + + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, + &(uint32_t){tracking_policy}, sizeof(uint32_t)); + if (ret < 0) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + ret = LTTNG_OK; + break; + } + case LTTNG_PROCESS_ATTR_TRACKER_SET_POLICY: + { + const enum lttng_tracking_policy tracking_policy = + (enum lttng_tracking_policy) cmd_ctx->lsm->u + .process_attr_tracker_set_tracking_policy + .tracking_policy; + const enum lttng_domain_type domain_type = + (enum lttng_domain_type) + cmd_ctx->lsm->domain.type; + const enum lttng_process_attr process_attr = + (enum lttng_process_attr) cmd_ctx->lsm->u + .process_attr_tracker_set_tracking_policy + .process_attr; + + ret = cmd_process_attr_tracker_set_tracking_policy( + cmd_ctx->session, domain_type, process_attr, + tracking_policy); + if (ret != LTTNG_OK) { + goto error; + } + break; + } + case LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: + { + struct lttng_process_attr_values *values; + struct lttng_dynamic_buffer reply; + const enum lttng_domain_type domain_type = + (enum lttng_domain_type) + cmd_ctx->lsm->domain.type; + const enum lttng_process_attr process_attr = + (enum lttng_process_attr) cmd_ctx->lsm->u + .process_attr_tracker_get_inclusion_set + .process_attr; + + ret = cmd_process_attr_tracker_get_inclusion_set( + cmd_ctx->session, domain_type, process_attr, + &values); + if (ret != LTTNG_OK) { + goto error; + } + + lttng_dynamic_buffer_init(&reply); + ret = lttng_process_attr_values_serialize(values, &reply); + if (ret < 0) { + goto error_tracker_get_inclusion_set; + } + + ret = setup_lttng_msg_no_cmd_header( + cmd_ctx, reply.data, reply.size); + if (ret < 0) { + ret = LTTNG_ERR_NOMEM; + goto error_tracker_get_inclusion_set; + } + ret = LTTNG_OK; + + error_tracker_get_inclusion_set: + lttng_process_attr_values_destroy(values); + lttng_dynamic_buffer_reset(&reply); break; } case LTTNG_ENABLE_EVENT: @@ -1320,7 +1492,7 @@ error_add_context: } } - ev = lttng_event_copy(&cmd_ctx->lsm->u.enable.event); + ev = lttng_event_copy(ALIGNED_CONST_PTR(cmd_ctx->lsm->u.enable.event)); if (!ev) { DBG("Failed to copy event: %s", cmd_ctx->lsm->u.enable.event.name); @@ -1344,7 +1516,8 @@ error_add_context: } } - ret = cmd_enable_event(cmd_ctx->session, &cmd_ctx->lsm->domain, + ret = cmd_enable_event(cmd_ctx->session, + ALIGNED_CONST_PTR(cmd_ctx->lsm->domain), cmd_ctx->lsm->u.enable.channel_name, ev, filter_expression, bytecode, exclusion, @@ -1438,34 +1611,6 @@ error_add_context: ret = LTTNG_OK; break; } - case LTTNG_LIST_TRACKER_PIDS: - { - int32_t *pids = NULL; - ssize_t nr_pids; - - nr_pids = cmd_list_tracker_pids(cmd_ctx->session, - cmd_ctx->lsm->domain.type, &pids); - if (nr_pids < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -nr_pids; - goto error; - } - - /* - * Setup lttng message with payload size set to the event list size in - * bytes and then copy list into the llm payload. - */ - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, pids, - sizeof(int32_t) * nr_pids); - free(pids); - - if (ret < 0) { - goto setup_error; - } - - ret = LTTNG_OK; - break; - } case LTTNG_SET_CONSUMER_URI: { size_t nb_uri, len; @@ -1716,7 +1861,8 @@ error_add_context: struct lttcomm_lttng_output_id reply; ret = cmd_snapshot_add_output(cmd_ctx->session, - &cmd_ctx->lsm->u.snapshot_output.output, &snapshot_id); + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.snapshot_output.output), + &snapshot_id); if (ret != LTTNG_OK) { goto error; } @@ -1735,7 +1881,7 @@ error_add_context: case LTTNG_SNAPSHOT_DEL_OUTPUT: { ret = cmd_snapshot_del_output(cmd_ctx->session, - &cmd_ctx->lsm->u.snapshot_output.output); + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.snapshot_output.output)); break; } case LTTNG_SNAPSHOT_LIST_OUTPUT: @@ -1764,7 +1910,7 @@ error_add_context: case LTTNG_SNAPSHOT_RECORD: { ret = cmd_snapshot_record(cmd_ctx->session, - &cmd_ctx->lsm->u.snapshot_record.output, + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.snapshot_record.output), cmd_ctx->lsm->u.snapshot_record.wait); break; } @@ -1847,7 +1993,8 @@ error_add_context: } ret = cmd_rotate_session(cmd_ctx->session, &rotate_return, - false); + false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); if (ret < 0) { ret = -ret; goto error; @@ -1931,6 +2078,11 @@ error_add_context: ret = LTTNG_OK; break; } + case LTTNG_CLEAR_SESSION: + { + ret = cmd_clear_session(cmd_ctx->session, sock); + break; + } default: ret = LTTNG_ERR_UND; break; @@ -1983,8 +2135,11 @@ static int create_client_sock(void) /* File permission MUST be 660 */ ret = chmod(config.client_unix_sock_path.value, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (ret < 0) { - ERR("Set file permissions failed: %s", config.client_unix_sock_path.value); + ERR("Set file permissions failed: %s", + config.client_unix_sock_path.value); PERROR("chmod"); + (void) lttcomm_close_unix_sock(client_sock); + ret = -1; goto end; } DBG("Created client socket (fd = %i)", client_sock); @@ -2017,7 +2172,7 @@ static void *thread_manage_clients(void *data) uint32_t revents, nb_fd; struct command_ctx *cmd_ctx = NULL; struct lttng_poll_event events; - int client_sock = -1; + const int client_sock = thread_state.client_sock; struct lttng_pipe *quit_pipe = data; const int thread_quit_pipe_fd = lttng_pipe_get_readfd(quit_pipe); @@ -2026,10 +2181,6 @@ static void *thread_manage_clients(void *data) is_root = (getuid() == 0); pthread_cleanup_push(thread_init_cleanup, NULL); - client_sock = create_client_sock(); - if (client_sock < 0) { - goto error_listen; - } rcu_register_thread(); @@ -2202,8 +2353,8 @@ static void *thread_manage_clients(void *data) if (ret) { PERROR("close"); } - } - sock = -1; + } + sock = -1; /* * TODO: Inform client somehow of the fatal error. At * this point, ret < 0 means that a zmalloc failed @@ -2245,8 +2396,8 @@ static void *thread_manage_clients(void *data) if (ret) { PERROR("close"); } - } - sock = -1; + } + sock = -1; clean_command_ctx(&cmd_ctx); @@ -2268,11 +2419,9 @@ error: error_listen: error_create_poll: unlink(config.client_unix_sock_path.value); - if (client_sock >= 0) { - ret = close(client_sock); - if (ret) { - PERROR("close"); - } + ret = close(client_sock); + if (ret) { + PERROR("close"); } if (err) { @@ -2301,7 +2450,8 @@ struct lttng_thread *launch_client_thread(void) { bool thread_running; struct lttng_pipe *client_quit_pipe; - struct lttng_thread *thread; + struct lttng_thread *thread = NULL; + int client_sock_fd = -1; sem_init(&thread_state.ready, 0, 0); client_quit_pipe = lttng_pipe_open(FD_CLOEXEC); @@ -2309,6 +2459,12 @@ struct lttng_thread *launch_client_thread(void) goto error; } + client_sock_fd = create_client_sock(); + if (client_sock_fd < 0) { + goto error; + } + + thread_state.client_sock = client_sock_fd; thread = lttng_thread_create("Client management", thread_manage_clients, shutdown_client_thread, @@ -2317,6 +2473,9 @@ struct lttng_thread *launch_client_thread(void) if (!thread) { goto error; } + /* The client thread now owns the client sock fd and the quit pipe. */ + client_sock_fd = -1; + client_quit_pipe = NULL; /* * This thread is part of the threads that need to be fully @@ -2324,11 +2483,16 @@ struct lttng_thread *launch_client_thread(void) */ thread_running = wait_thread_status(); if (!thread_running) { - lttng_thread_put(thread); - thread = NULL; + goto error; } return thread; error: + if (client_sock_fd >= 0) { + if (close(client_sock_fd)) { + PERROR("Failed to close client socket"); + } + } + lttng_thread_put(thread); cleanup_client_thread(client_quit_pipe); return NULL; }