X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=3ccc29efceaf335a71ce0bc3c5d705aaefd90619;hp=04c04465f2659385282a42fe0dcdf2e75b59efb2;hb=9124c6304bba12b0d4424b4071a25a34445ff4da;hpb=3a91de3ac8a651db110efe1214181d75b036b141 diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index 04c04465f..3ccc29efc 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -11,9 +11,12 @@ #include "common/compat/socket.h" #include "common/dynamic-buffer.h" #include "common/dynamic-array.h" -#include "common/sessiond-comm/payload.h" -#include "common/sessiond-comm/payload-view.h" +#include "common/payload.h" +#include "common/payload-view.h" +#include "common/fd-handle.h" #include "common/sessiond-comm/sessiond-comm.h" +#include "common/payload.h" +#include "common/payload-view.h" #include "lttng/lttng-error.h" #include "lttng/tracker.h" #include @@ -28,6 +31,7 @@ #include #include #include +#include #include "client.h" #include "lttng-sessiond.h" @@ -89,7 +93,12 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, .data_size = payload_len, }; - lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + if (ret) { + goto end; + } + + lttng_dynamic_pointer_array_clear(&cmd_ctx->reply_payload._fd_handles); cmd_ctx->lttng_msg_size = total_msg_size; @@ -124,6 +133,51 @@ end: return ret; } +static int setup_empty_lttng_msg(struct command_ctx *cmd_ctx) +{ + int ret; + const struct lttcomm_lttng_msg llm = {}; + + ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + if (ret) { + goto end; + } + + /* Append place-holder reply header. */ + ret = lttng_dynamic_buffer_append( + &cmd_ctx->reply_payload.buffer, &llm, sizeof(llm)); + if (ret) { + goto end; + } + + cmd_ctx->lttng_msg_size = sizeof(llm); +end: + return ret; +} + +static void update_lttng_msg(struct command_ctx *cmd_ctx, size_t cmd_header_len, + size_t payload_len) +{ + const size_t header_len = sizeof(struct lttcomm_lttng_msg); + const size_t total_msg_size = header_len + cmd_header_len + payload_len; + const struct lttcomm_lttng_msg llm = { + .cmd_type = cmd_ctx->lsm.cmd_type, + .pid = cmd_ctx->lsm.domain.attr.pid, + .cmd_header_size = cmd_header_len, + .data_size = payload_len, + }; + struct lttcomm_lttng_msg *p_llm; + + assert(cmd_ctx->reply_payload.buffer.size >= sizeof(llm)); + + p_llm = (typeof(p_llm)) cmd_ctx->reply_payload.buffer.data; + + /* Update existing header. */ + memcpy(p_llm, &llm, sizeof(llm)); + + cmd_ctx->lttng_msg_size = total_msg_size; +} + /* * Start the thread_manage_consumer. This must be done after a lttng-consumerd * exec or it will fail. @@ -526,15 +580,14 @@ static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) struct ltt_session *session; const struct ltt_session_list *session_list = session_get_list(); - DBG("Counting number of available session for UID %d GID %d", - uid, gid); + DBG("Counting number of available session for UID %d", uid); cds_list_for_each_entry(session, &session_list->head, list) { if (!session_get(session)) { continue; } session_lock(session); /* Only count the sessions the user can control. */ - if (session_access_ok(session, uid, gid) && + if (session_access_ok(session, uid) && !session->destroyed) { i++; } @@ -547,18 +600,18 @@ static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock, int *sock_error, struct lttng_event *event) { - int fd, ret; + int fd = -1, ret; struct lttng_userspace_probe_location *probe_location; - const struct lttng_userspace_probe_location_lookup_method *lookup = NULL; - struct lttng_dynamic_buffer probe_location_buffer; - struct lttng_buffer_view buffer_view; + struct lttng_payload probe_location_payload; + struct fd_handle *handle = NULL; /* - * Create a buffer to store the serialized version of the probe + * Create a payload to store the serialized version of the probe * location. */ - lttng_dynamic_buffer_init(&probe_location_buffer); - ret = lttng_dynamic_buffer_set_size(&probe_location_buffer, + lttng_payload_init(&probe_location_payload); + + ret = lttng_dynamic_buffer_set_size(&probe_location_payload.buffer, cmd_ctx->lsm.u.enable.userspace_probe_location_len); if (ret) { ret = LTTNG_ERR_NOMEM; @@ -568,27 +621,11 @@ static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock, /* * Receive the probe location. */ - ret = lttcomm_recv_unix_sock(sock, probe_location_buffer.data, - probe_location_buffer.size); + ret = lttcomm_recv_unix_sock(sock, probe_location_payload.buffer.data, + probe_location_payload.buffer.size); if (ret <= 0) { DBG("Nothing recv() from client var len data... continuing"); *sock_error = 1; - lttng_dynamic_buffer_reset(&probe_location_buffer); - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; - } - - buffer_view = lttng_buffer_view_from_dynamic_buffer( - &probe_location_buffer, 0, probe_location_buffer.size); - - /* - * Extract the probe location from the serialized version. - */ - ret = lttng_userspace_probe_location_create_from_buffer( - &buffer_view, &probe_location); - if (ret < 0) { - WARN("Failed to create a userspace probe location from the received buffer"); - lttng_dynamic_buffer_reset( &probe_location_buffer); ret = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; } @@ -605,35 +642,35 @@ static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock, goto error; } - /* - * Set the file descriptor received from the client through the unix - * socket in the probe location. - */ - lookup = lttng_userspace_probe_location_get_lookup_method(probe_location); - if (!lookup) { - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; + handle = fd_handle_create(fd); + if (!handle) { + ret = LTTNG_ERR_NOMEM; goto error; } - /* - * From the kernel tracer's perspective, all userspace probe event types - * are all the same: a file and an offset. - */ - switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) { - case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: - ret = lttng_userspace_probe_location_function_set_binary_fd( - probe_location, fd); - break; - case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: - ret = lttng_userspace_probe_location_tracepoint_set_binary_fd( - probe_location, fd); - break; - default: - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; + /* Transferred to the handle. */ + fd = -1; + + ret = lttng_payload_push_fd_handle(&probe_location_payload, handle); + if (ret) { + ERR("Failed to add userspace probe file descriptor to payload"); + ret = LTTNG_ERR_NOMEM; goto error; } - if (ret) { + fd_handle_put(handle); + handle = NULL; + + { + struct lttng_payload_view view = lttng_payload_view_from_payload( + &probe_location_payload, 0, -1); + + /* Extract the probe location from the serialized version. */ + ret = lttng_userspace_probe_location_create_from_payload( + &view, &probe_location); + } + if (ret < 0) { + WARN("Failed to create a userspace probe location from the received buffer"); ret = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; } @@ -645,8 +682,15 @@ static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock, goto error; } - lttng_dynamic_buffer_reset(&probe_location_buffer); error: + if (fd >= 0) { + if (close(fd)) { + PERROR("Failed to close userspace probe location binary fd"); + } + } + + fd_handle_put(handle); + lttng_payload_reset(&probe_location_payload); return ret; } @@ -683,6 +727,7 @@ static int check_rotate_compatible(void) static int send_unix_sock(int sock, struct lttng_payload_view *view) { int ret; + const int fd_count = lttng_payload_view_get_fd_handle_count(view); /* Check valid length */ if (view->buffer.size == 0) { @@ -696,10 +741,11 @@ static int send_unix_sock(int sock, struct lttng_payload_view *view) goto end; } - if (lttng_dynamic_array_get_count(&view->_fds) > 0) { - ret = lttcomm_send_fds_unix_sock(sock, - (const int *) view->_fds.buffer.data, - lttng_dynamic_array_get_count(&view->_fds)); + if (fd_count > 0) { + ret = lttcomm_send_payload_view_fds_unix_sock(sock, view); + if (ret < 0) { + goto end; + } } end: @@ -723,8 +769,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, int *sock_error) { int ret = LTTNG_OK; - int need_tracing_session = 1; - int need_domain; + bool need_tracing_session = true; + bool need_domain; + bool need_consumerd; DBG("Processing client command %d", cmd_ctx->lsm.cmd_type); @@ -748,17 +795,27 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SET_SESSION_SHM_PATH: case LTTNG_REGENERATE_METADATA: case LTTNG_REGENERATE_STATEDUMP: - case LTTNG_REGISTER_TRIGGER: - case LTTNG_UNREGISTER_TRIGGER: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: case LTTNG_ROTATION_SET_SCHEDULE: case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: case LTTNG_CLEAR_SESSION: - need_domain = 0; + case LTTNG_LIST_TRIGGERS: + need_domain = false; break; default: - need_domain = 1; + need_domain = true; + } + + /* Needs a functioning consumerd? */ + switch (cmd_ctx->lsm.cmd_type) { + case LTTNG_REGISTER_TRIGGER: + case LTTNG_UNREGISTER_TRIGGER: + need_consumerd = false; + break; + default: + need_consumerd = true; + break; } if (config.no_kernel && need_domain @@ -801,6 +858,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_DATA_PENDING: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: + case LTTNG_REGISTER_TRIGGER: + case LTTNG_LIST_TRIGGERS: break; default: /* Setup lttng message with no payload */ @@ -821,7 +880,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SAVE_SESSION: case LTTNG_REGISTER_TRIGGER: case LTTNG_UNREGISTER_TRIGGER: - need_tracing_session = 0; + case LTTNG_LIST_TRIGGERS: + need_tracing_session = false; break; default: DBG("Getting session %s by name", cmd_ctx->lsm.session.name); @@ -899,7 +959,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Consumer is in an ERROR state. Report back to client */ - if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) { + if (need_consumerd && uatomic_read(&kernel_consumerd_state) == + CONSUMER_ERROR) { ret = LTTNG_ERR_NO_KERNCONSUMERD; goto error; } @@ -950,8 +1011,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, ret = LTTNG_ERR_NO_UST; goto error; } + /* Consumer is in an ERROR state. Report back to client */ - if (uatomic_read(&ust_consumerd_state) == CONSUMER_ERROR) { + if (need_consumerd && uatomic_read(&ust_consumerd_state) == + CONSUMER_ERROR) { ret = LTTNG_ERR_NO_USTCONSUMERD; goto error; } @@ -1060,13 +1123,12 @@ skip_domain: } /* - * Check that the UID or GID match that of the tracing session. + * Check that the UID matches that of the tracing session. * The root user can interact with all sessions. */ if (need_tracing_session) { if (!session_access_ok(cmd_ctx->session, - LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), - LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)) || + LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) || cmd_ctx->session->destroyed) { ret = LTTNG_ERR_EPERM; goto error; @@ -1237,9 +1299,17 @@ error_add_context: .value_type; struct process_attr_value *value; enum lttng_error_code ret_code; + long login_name_max; + + login_name_max = sysconf(_SC_LOGIN_NAME_MAX); + if (login_name_max < 0) { + PERROR("Failed to get _SC_LOGIN_NAME_MAX system configuration"); + ret = LTTNG_ERR_INVALID; + goto error; + } /* Receive remaining variable length payload if applicable. */ - if (name_len > LOGIN_NAME_MAX) { + if (name_len > login_name_max) { /* * POSIX mandates user and group names that are at least * 8 characters long. Note that although shadow-utils @@ -1247,9 +1317,9 @@ error_add_context: * 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", + ERR("Rejecting process attribute tracker value %s as the provided exceeds the maximal allowed length: argument length = %zu, maximal length = %ld", add_value ? "addition" : "removal", - name_len, LOGIN_NAME_MAX); + name_len, login_name_max); ret = LTTNG_ERR_INVALID; goto error; } @@ -1281,6 +1351,11 @@ error_add_context: payload_view = lttng_buffer_view_from_dynamic_buffer( &payload, 0, name_len); + if (name_len > 0 && !lttng_buffer_view_is_valid(&payload_view)) { + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto error_add_remove_tracker_value; + } + /* * Validate the value type and domains are legal for the process * attribute tracker that is specified and convert the value to @@ -1739,32 +1814,34 @@ error_add_context: } case LTTNG_LIST_EVENTS: { - ssize_t nb_event; - struct lttng_event *events = NULL; - struct lttcomm_event_command_header cmd_header; - size_t total_size; - - memset(&cmd_header, 0, sizeof(cmd_header)); - /* Extended infos are included at the end of events */ - nb_event = cmd_list_events(cmd_ctx->lsm.domain.type, - cmd_ctx->session, cmd_ctx->lsm.u.list.channel_name, - &events, &total_size); - - if (nb_event < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -nb_event; - goto error; + ssize_t list_ret; + struct lttcomm_event_command_header cmd_header = {}; + 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; } - cmd_header.nb_events = nb_event; - ret = setup_lttng_msg(cmd_ctx, events, total_size, - &cmd_header, sizeof(cmd_header)); - free(events); + original_payload_size = cmd_ctx->reply_payload.buffer.size; - if (ret < 0) { - goto setup_error; + /* Extended infos are included at the end of the payload. */ + list_ret = cmd_list_events(cmd_ctx->lsm.domain.type, + cmd_ctx->session, + cmd_ctx->lsm.u.list.channel_name, + &cmd_ctx->reply_payload); + if (list_ret < 0) { + /* Return value is a negative lttng_error_code. */ + ret = -list_ret; + goto error; } + payload_size = cmd_ctx->reply_payload.buffer.size - + sizeof(cmd_header) - original_payload_size; + update_lttng_msg(cmd_ctx, sizeof(cmd_header), payload_size); + ret = LTTNG_OK; break; } @@ -1978,8 +2055,41 @@ error_add_context: } case LTTNG_REGISTER_TRIGGER: { + struct lttng_trigger *return_trigger; + 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_register_trigger(cmd_ctx, *sock, - notification_thread_handle); + notification_thread_handle, &return_trigger); + if (ret != LTTNG_OK) { + goto error; + } + + ret = lttng_trigger_serialize(return_trigger, &cmd_ctx->reply_payload); + 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; + + 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_UNREGISTER_TRIGGER: @@ -2092,6 +2202,44 @@ error_add_context: ret = cmd_clear_session(cmd_ctx->session, sock); break; } + case LTTNG_LIST_TRIGGERS: + { + struct lttng_triggers *return_triggers = 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_triggers(cmd_ctx, + notification_thread_handle, &return_triggers); + if (ret != LTTNG_OK) { + goto error; + } + + assert(return_triggers); + ret = lttng_triggers_serialize( + return_triggers, &cmd_ctx->reply_payload); + lttng_triggers_destroy(return_triggers); + if (ret) { + ERR("Failed to serialize triggers in reply to `list triggers` command"); + 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; + } default: ret = LTTNG_ERR_UND; break; @@ -2248,8 +2396,8 @@ static void *thread_manage_clients(void *data) .gid = UINT32_MAX, }; cmd_ctx.session = NULL; - lttng_dynamic_buffer_set_size(&cmd_ctx.reply_payload.buffer, 0); - lttng_dynamic_array_clear(&cmd_ctx.reply_payload._fds); + lttng_payload_clear(&cmd_ctx.reply_payload); + cmd_ctx.lttng_msg_size = 0; DBG("Accepting client command ..."); @@ -2384,13 +2532,15 @@ static void *thread_manage_clients(void *data) lttng_payload_view_from_payload( &cmd_ctx.reply_payload, 0, -1); - const struct lttcomm_lttng_msg *llm = (typeof( + 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.lttng_msg_size == cmd_ctx.reply_payload.buffer.size); + llm->fd_count = lttng_payload_view_get_fd_handle_count(&view); + DBG("Sending response (size: %d, retcode: %s (%d))", cmd_ctx.lttng_msg_size, lttng_strerror(-llm->ret_code),