X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=ba6d08cbda6a28c78196eb7a502dce45de9a61e7;hp=3ccc29efceaf335a71ce0bc3c5d705aaefd90619;hb=refs%2Fheads%2Fsow-2020-0002-rev2;hpb=9124c6304bba12b0d4424b4071a25a34445ff4da diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index 3ccc29efc..ba6d08cbd 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -24,6 +24,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -43,6 +46,7 @@ #include "utils.h" #include "manage-consumer.h" #include "clear.h" +#include "agent-thread.h" static bool is_root; @@ -694,6 +698,178 @@ error: return ret; } +static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, + int sock, + int *sock_error, + struct lttng_trigger **_trigger) +{ + int ret; + size_t trigger_len; + ssize_t sock_recv_len; + enum lttng_error_code ret_code; + struct lttng_payload trigger_payload; + struct lttng_trigger *trigger = NULL; + + lttng_payload_init(&trigger_payload); + trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; + ret = lttng_dynamic_buffer_set_size( + &trigger_payload.buffer, trigger_len); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + sock_recv_len = lttcomm_recv_unix_sock( + sock, trigger_payload.buffer.data, trigger_len); + if (sock_recv_len < 0 || sock_recv_len != trigger_len) { + ERR("Failed to receive trigger in command payload"); + *sock_error = 1; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } + + /* Receive fds, if any. */ + if (cmd_ctx->lsm.fd_count > 0) { + sock_recv_len = lttcomm_recv_payload_fds_unix_sock( + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (sock_recv_len > 0 && + sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { + ERR("Failed to receive all file descriptors for trigger in command payload: expected fd count = %u, ret = %d", + cmd_ctx->lsm.fd_count, (int) ret); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + *sock_error = 1; + goto end; + } else if (sock_recv_len <= 0) { + ERR("Failed to receive file descriptors for trigger in command payload: expected fd count = %u, ret = %d", + cmd_ctx->lsm.fd_count, (int) ret); + ret_code = LTTNG_ERR_FATAL; + *sock_error = 1; + goto end; + } + } + + /* Deserialize trigger. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &trigger_payload, 0, -1); + + if (lttng_trigger_create_from_payload(&view, &trigger) != + trigger_len) { + ERR("Invalid trigger received as part of command payload"); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + lttng_trigger_put(trigger); + goto end; + } + } + + *_trigger = trigger; + ret_code = LTTNG_OK; + +end: + return ret_code; +} + +static enum lttng_error_code receive_lttng_map(int sock, + int *sock_error, + uint32_t map_len, + struct lttng_map **_map) +{ + int ret; + ssize_t sock_recv_len; + enum lttng_error_code ret_code; + struct lttng_payload map_payload; + struct lttng_map *map = NULL; + + lttng_payload_init(&map_payload); + 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 map in command payload"); + *sock_error = 1; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + 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 received as part of command payload"); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + lttng_map_put(map); + goto end; + } + } + + *_map = map; + ret_code = LTTNG_OK; + +end: + return ret_code; +} + +static enum lttng_error_code receive_lttng_map_query(int sock, + int *sock_error, + uint32_t map_query_len, + struct lttng_map_query **_map_query) +{ + int ret; + ssize_t sock_recv_len; + enum lttng_error_code ret_code; + struct lttng_payload map_query_payload; + struct lttng_map_query *map_query = NULL; + + lttng_payload_init(&map_query_payload); + ret = lttng_dynamic_buffer_set_size( + &map_query_payload.buffer, map_query_len); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; + } + + sock_recv_len = lttcomm_recv_unix_sock( + sock, map_query_payload.buffer.data, map_query_len); + if (sock_recv_len < 0 || sock_recv_len != map_query_len) { + ERR("Failed to receive map query in command payload"); + *sock_error = 1; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } + + /* Deserialize map query. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &map_query_payload, 0, -1); + + if (lttng_map_query_create_from_payload(&view, &map_query) != + map_query_len) { + ERR("Invalid map query received as part of command payload"); + ret_code = LTTNG_ERR_INVALID_TRIGGER; + lttng_map_query_destroy(map_query); + goto end; + } + } + + *_map_query = map_query; + ret_code = LTTNG_OK; + +end: + return ret_code; +} + /* * Version of setup_lttng_msg() without command header. */ @@ -773,7 +949,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, bool need_domain; bool need_consumerd; - DBG("Processing client command %d", cmd_ctx->lsm.cmd_type); + DBG("Processing client command '%s\' (%d)", + lttcomm_sessiond_command_str(cmd_ctx->lsm.cmd_type), + cmd_ctx->lsm.cmd_type); assert(!rcu_read_ongoing()); @@ -801,6 +979,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: case LTTNG_CLEAR_SESSION: case LTTNG_LIST_TRIGGERS: + case LTTNG_LIST_MAP_VALUES: need_domain = false; break; default: @@ -811,6 +990,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, switch (cmd_ctx->lsm.cmd_type) { case LTTNG_REGISTER_TRIGGER: case LTTNG_UNREGISTER_TRIGGER: + case LTTNG_ADD_MAP: + case LTTNG_ENABLE_MAP: + case LTTNG_DISABLE_MAP: + case LTTNG_LIST_MAP_VALUES: need_consumerd = false; break; default: @@ -911,6 +1094,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, switch (cmd_ctx->lsm.cmd_type) { case LTTNG_DISABLE_CHANNEL: case LTTNG_DISABLE_EVENT: + case LTTNG_DISABLE_MAP: switch (cmd_ctx->lsm.domain.type) { case LTTNG_DOMAIN_KERNEL: if (!cmd_ctx->session->kernel_session) { @@ -1005,6 +1189,11 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_DOMAIN_JUL: case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_PYTHON: + if (!agent_tracing_is_enabled()) { + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } + /* Fallthrough */ case LTTNG_DOMAIN_UST: { if (!ust_app_supported()) { @@ -1274,6 +1463,23 @@ error_add_context: kernel_poll_pipe[1]); break; } + case LTTNG_ADD_MAP: + { + ret = cmd_add_map(cmd_ctx, *sock); + + break; + } + case LTTNG_ENABLE_MAP: + ret = cmd_enable_map(cmd_ctx->session, cmd_ctx->lsm.domain.type, + cmd_ctx->lsm.u.enable_map.map_name); + break; + case LTTNG_DISABLE_MAP: + { + ret = cmd_disable_map(cmd_ctx->session, cmd_ctx->lsm.domain.type, + cmd_ctx->lsm.u.disable_map.map_name); + + break; + } case LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE: case LTTNG_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE: { @@ -1476,7 +1682,7 @@ error_add_context: { struct lttng_event *ev = NULL; struct lttng_event_exclusion *exclusion = NULL; - struct lttng_filter_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = NULL; char *filter_expression = NULL; /* Handle exclusion events and receive it from the client. */ @@ -1812,6 +2018,45 @@ error_add_context: ret = LTTNG_OK; break; } + case LTTNG_LIST_MAPS: + { + struct lttng_map_list *return_map_list = NULL; + size_t original_payload_size; + size_t payload_size; + + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_error; + } + + original_payload_size = cmd_ctx->reply_payload.buffer.size; + + ret = cmd_list_maps(cmd_ctx->lsm.domain.type, cmd_ctx->session, + &return_map_list); + if (ret != LTTNG_OK) { + goto error; + } + + assert(return_map_list); + ret = lttng_map_list_serialize(return_map_list, + &cmd_ctx->reply_payload); + lttng_map_list_destroy(return_map_list); + if (ret) { + ERR("Failed to serialize map_list in reply to `%s` command", + lttcomm_sessiond_command_str(cmd_ctx->lsm.cmd_type)); + ret = LTTNG_ERR_NOMEM; + goto error; + } + + payload_size = cmd_ctx->reply_payload.buffer.size - + original_payload_size; + + update_lttng_msg(cmd_ctx, 0, payload_size); + + ret = LTTNG_OK; + break; + } case LTTNG_LIST_EVENTS: { ssize_t list_ret; @@ -2055,9 +2300,14 @@ error_add_context: } case LTTNG_REGISTER_TRIGGER: { + struct lttng_trigger *payload_trigger; struct lttng_trigger *return_trigger; - size_t original_payload_size; - size_t payload_size; + size_t original_reply_payload_size; + size_t reply_payload_size; + const struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; ret = setup_empty_lttng_msg(cmd_ctx); if (ret) { @@ -2065,37 +2315,55 @@ error_add_context: goto setup_error; } - original_payload_size = cmd_ctx->reply_payload.buffer.size; + ret = receive_lttng_trigger( + cmd_ctx, *sock, sock_error, &payload_trigger); + if (ret != LTTNG_OK) { + goto error; + } - ret = cmd_register_trigger(cmd_ctx, *sock, + original_reply_payload_size = cmd_ctx->reply_payload.buffer.size; + + ret = cmd_register_trigger(&cmd_creds, payload_trigger, notification_thread_handle, &return_trigger); if (ret != LTTNG_OK) { + lttng_trigger_put(payload_trigger); goto error; } ret = lttng_trigger_serialize(return_trigger, &cmd_ctx->reply_payload); + lttng_trigger_put(payload_trigger); + lttng_trigger_put(return_trigger); if (ret) { ERR("Failed to serialize trigger in reply to \"register trigger\" command"); ret = LTTNG_ERR_NOMEM; - lttng_trigger_destroy(return_trigger); goto error; } - lttng_trigger_destroy(return_trigger); - return_trigger = NULL; + reply_payload_size = cmd_ctx->reply_payload.buffer.size - + original_reply_payload_size; - payload_size = cmd_ctx->reply_payload.buffer.size - - original_payload_size; - - update_lttng_msg(cmd_ctx, 0, payload_size); + update_lttng_msg(cmd_ctx, 0, reply_payload_size); ret = LTTNG_OK; break; } case LTTNG_UNREGISTER_TRIGGER: { - ret = cmd_unregister_trigger(cmd_ctx, *sock, + struct lttng_trigger *payload_trigger; + const struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + ret = receive_lttng_trigger( + cmd_ctx, *sock, sock_error, &payload_trigger); + if (ret != LTTNG_OK) { + goto error; + } + + ret = cmd_unregister_trigger(&cmd_creds, payload_trigger, notification_thread_handle); + lttng_trigger_put(payload_trigger); break; } case LTTNG_ROTATE_SESSION: @@ -2240,6 +2508,60 @@ error_add_context: ret = LTTNG_OK; break; } + case LTTNG_LIST_MAP_VALUES: + { + struct lttng_map_content *return_map_content = NULL; + struct lttng_map *payload_map = NULL; + struct lttng_map_query *payload_map_query = NULL; + size_t original_reply_payload_size; + size_t reply_payload_size; + + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_error; + } + + original_reply_payload_size = cmd_ctx->reply_payload.buffer.size; + + ret = receive_lttng_map(*sock, sock_error, + cmd_ctx->lsm.u.list_map_values.map_length, + &payload_map); + if (ret != LTTNG_OK) { + goto error; + } + + ret = receive_lttng_map_query(*sock, sock_error, + cmd_ctx->lsm.u.list_map_values.query_length, + &payload_map_query); + if (ret != LTTNG_OK) { + goto error; + } + + ret = cmd_list_map_values(cmd_ctx->lsm.session.name, + payload_map, payload_map_query, + &return_map_content); + if (ret != LTTNG_OK) { + goto error; + } + assert(return_map_content); + ret = lttng_map_content_serialize(return_map_content, + &cmd_ctx->reply_payload); + lttng_map_content_destroy(return_map_content); + if (ret) { + ERR("Failed to serialize key-value pair list in reply to `list map values` command"); + ret = LTTNG_ERR_NOMEM; + goto error; + } + + reply_payload_size = cmd_ctx->reply_payload.buffer.size - + original_reply_payload_size; + + update_lttng_msg(cmd_ctx, 0, reply_payload_size); + + ret = LTTNG_OK; + break; + } default: ret = LTTNG_ERR_UND; break; @@ -2514,6 +2836,14 @@ static void *thread_manage_clients(void *data) continue; } + if (ret < LTTNG_OK || ret >= LTTNG_ERR_NR) { + WARN("Command returned an invalid status code, returning unknown error: " + "command type = %s (%d), ret = %d", + lttcomm_sessiond_command_str(cmd_ctx.lsm.cmd_type), + cmd_ctx.lsm.cmd_type, ret); + ret = LTTNG_ERR_UNK; + } + cmd_completion_handler = cmd_pop_completion_handler(); if (cmd_completion_handler) { enum lttng_error_code completion_code; @@ -2535,8 +2865,7 @@ static void *thread_manage_clients(void *data) struct lttcomm_lttng_msg *llm = (typeof( llm)) cmd_ctx.reply_payload.buffer.data; - assert(cmd_ctx.reply_payload.buffer.size >= - sizeof(llm)); + assert(cmd_ctx.reply_payload.buffer.size >= sizeof(*llm)); assert(cmd_ctx.lttng_msg_size == cmd_ctx.reply_payload.buffer.size); llm->fd_count = lttng_payload_view_get_fd_handle_count(&view);