X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=2c7bd4787c9371305455dfa7765ab9397d07877f;hp=f3002f910a1c278348caacb0cc043408b40d1d11;hb=2d97a0067600335f07eecb2c1d9ba68fc164583e;hpb=b178f53e90c376dd44b020535c32649edef8f80e diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index f3002f910..2c7bd4787 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -38,12 +38,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) @@ -410,7 +412,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; @@ -478,7 +480,7 @@ static int create_kernel_session(struct ltt_session *session) DBG("Creating kernel session"); - ret = kernel_create_session(session, kernel_tracer_fd); + ret = kernel_create_session(session); if (ret < 0) { ret = LTTNG_ERR_KERN_SESS_FAIL; goto error_create; @@ -706,10 +708,12 @@ static int send_unix_sock(int sock, void *buf, size_t len) * Return any error encountered or 0 for success. * * "sock" is only used for special-case var. len data. + * A command may assume the ownership of the socket, in which case its value + * should be set to -1. * * Should *NOT* be called with RCU read-side lock held. */ -static int process_client_msg(struct command_ctx *cmd_ctx, int sock, +static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, int *sock_error) { int ret = LTTNG_OK; @@ -744,6 +748,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: @@ -784,7 +789,7 @@ 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_LIST_TRACKER_IDS: case LTTNG_DATA_PENDING: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: @@ -877,6 +882,15 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, goto error; } + /* Kernel tracer check */ + if (!kernel_tracer_is_initialized()) { + /* Basically, load kernel tracer modules */ + ret = init_kernel_tracer(); + if (ret != 0) { + goto error; + } + } + /* Consumer is in an ERROR state. Report back to client */ if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) { ret = LTTNG_ERR_NO_KERNCONSUMERD; @@ -939,7 +953,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; } @@ -1108,13 +1122,13 @@ skip_domain: cmd_ctx->lsm->u.context.ctx.u.app_ctx.ctx_name = context_name; - ret = lttcomm_recv_unix_sock(sock, provider_name, + ret = lttcomm_recv_unix_sock(*sock, provider_name, provider_name_len); if (ret < 0) { goto error_add_context; } - ret = lttcomm_recv_unix_sock(sock, context_name, + ret = lttcomm_recv_unix_sock(*sock, context_name, context_name_len); if (ret < 0) { goto error_add_context; @@ -1128,7 +1142,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; @@ -1167,7 +1181,7 @@ error_add_context: DBG("Discarding disable event command payload of size %zu", count); while (count) { - ret = lttcomm_recv_unix_sock(sock, data, + ret = lttcomm_recv_unix_sock(*sock, data, count > sizeof(data) ? sizeof(data) : count); if (ret < 0) { goto error; @@ -1176,33 +1190,156 @@ 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_TRACK_ID: { - ret = cmd_track_pid(cmd_ctx->session, - cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + struct lttng_tracker_id *id = NULL; + enum lttng_tracker_id_status status; + + id = lttng_tracker_id_create(); + if (!id) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + + switch (cmd_ctx->lsm->u.id_tracker.id_type) { + case LTTNG_ID_ALL: + status = lttng_tracker_id_set_all(id); + break; + case LTTNG_ID_VALUE: + status = lttng_tracker_id_set_value( + id, cmd_ctx->lsm->u.id_tracker.u.value); + break; + case LTTNG_ID_STRING: + { + const size_t var_len = cmd_ctx->lsm->u.id_tracker.u.var_len; + char *string = NULL; + + string = zmalloc(var_len); + if (!string) { + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG("Receiving var len tracker id string from client"); + ret = lttcomm_recv_unix_sock(*sock, string, var_len); + if (ret <= 0) { + DBG("Nothing received"); + *sock_error = 1; + free(string); + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_INVALID; + goto error; + } + if (strnlen(string, var_len) != var_len - 1) { + DBG("String received as tracker ID is not NULL-terminated"); + free(string); + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_INVALID; + goto error; + } + + status = lttng_tracker_id_set_string(id, string); + free(string); + break; + } + default: + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_INVALID; + goto error; + } + + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ERR("Invalid value for tracker id"); + ret = LTTNG_ERR_INVALID; + lttng_tracker_id_destroy(id); + goto error; + } + + ret = cmd_track_id(cmd_ctx->session, + cmd_ctx->lsm->u.id_tracker.tracker_type, + cmd_ctx->lsm->domain.type, id); + lttng_tracker_id_destroy(id); break; } - case LTTNG_UNTRACK_PID: + case LTTNG_UNTRACK_ID: { - ret = cmd_untrack_pid(cmd_ctx->session, - cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + struct lttng_tracker_id *id = NULL; + enum lttng_tracker_id_status status; + + id = lttng_tracker_id_create(); + + switch (cmd_ctx->lsm->u.id_tracker.id_type) { + case LTTNG_ID_ALL: + status = lttng_tracker_id_set_all(id); + break; + case LTTNG_ID_VALUE: + status = lttng_tracker_id_set_value( + id, cmd_ctx->lsm->u.id_tracker.u.value); + break; + case LTTNG_ID_STRING: + { + const size_t var_len = cmd_ctx->lsm->u.id_tracker.u.var_len; + char *string = NULL; + + string = zmalloc(var_len); + if (!string) { + ret = LTTNG_ERR_NOMEM; + lttng_tracker_id_destroy(id); + goto error; + } + DBG("Receiving var len tracker id string from client"); + ret = lttcomm_recv_unix_sock(*sock, string, var_len); + if (ret <= 0) { + DBG("Nothing received"); + *sock_error = 1; + lttng_tracker_id_destroy(id); + free(string); + ret = LTTNG_ERR_INVALID; + goto error; + } + if (strnlen(string, var_len) != var_len - 1) { + DBG("String received as tracker ID is not NULL-terminated"); + lttng_tracker_id_destroy(id); + free(string); + ret = LTTNG_ERR_INVALID; + goto error; + } + status = lttng_tracker_id_set_string(id, string); + free(string); + break; + } + default: + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_INVALID; + goto error; + } + + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ERR("Invalid tracker id"); + lttng_tracker_id_destroy(id); + ret = LTTNG_ERR_INVALID; + goto error; + } + + ret = cmd_untrack_id(cmd_ctx->session, + cmd_ctx->lsm->u.id_tracker.tracker_type, + cmd_ctx->lsm->domain.type, id); + lttng_tracker_id_destroy(id); break; } case LTTNG_ENABLE_EVENT: @@ -1225,7 +1362,7 @@ error_add_context: DBG("Receiving var len exclusion event list from client ..."); exclusion->count = count; - ret = lttcomm_recv_unix_sock(sock, exclusion->names, + ret = lttcomm_recv_unix_sock(*sock, exclusion->names, count * LTTNG_SYMBOL_NAME_LEN); if (ret <= 0) { DBG("Nothing recv() from client var len data... continuing"); @@ -1256,7 +1393,7 @@ error_add_context: /* Receive var. len. data */ DBG("Receiving var len filter's expression from client ..."); - ret = lttcomm_recv_unix_sock(sock, filter_expression, + ret = lttcomm_recv_unix_sock(*sock, filter_expression, expression_len); if (ret <= 0) { DBG("Nothing recv() from client var len data... continuing"); @@ -1289,7 +1426,7 @@ error_add_context: /* Receive var. len. data */ DBG("Receiving var len filter's bytecode from client ..."); - ret = lttcomm_recv_unix_sock(sock, bytecode, bytecode_len); + ret = lttcomm_recv_unix_sock(*sock, bytecode, bytecode_len); if (ret <= 0) { DBG("Nothing recv() from client var len data... continuing"); *sock_error = 1; @@ -1309,7 +1446,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); @@ -1323,7 +1460,7 @@ error_add_context: if (cmd_ctx->lsm->u.enable.userspace_probe_location_len > 0) { /* Expect a userspace probe description. */ - ret = receive_userspace_probe(cmd_ctx, sock, sock_error, ev); + ret = receive_userspace_probe(cmd_ctx, *sock, sock_error, ev); if (ret) { free(filter_expression); free(bytecode); @@ -1333,7 +1470,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, @@ -1427,27 +1565,81 @@ error_add_context: ret = LTTNG_OK; break; } - case LTTNG_LIST_TRACKER_PIDS: + case LTTNG_LIST_TRACKER_IDS: { - 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) { + struct lttcomm_tracker_command_header cmd_header; + struct lttng_tracker_id **ids = NULL; + ssize_t nr_ids, i; + struct lttng_dynamic_buffer buf; + + nr_ids = cmd_list_tracker_ids( + cmd_ctx->lsm->u.id_tracker.tracker_type, + cmd_ctx->session, cmd_ctx->lsm->domain.type, + &ids); + if (nr_ids < 0) { /* Return value is a negative lttng_error_code. */ - ret = -nr_pids; + ret = -nr_ids; 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); + lttng_dynamic_buffer_init(&buf); + for (i = 0; i < nr_ids; i++) { + struct lttng_tracker_id *id = ids[i]; + struct lttcomm_tracker_id_header id_hdr; + size_t var_data_len = 0; + enum lttng_tracker_id_status status; + const char *string; + int value; + + memset(&id_hdr, 0, sizeof(id_hdr)); + id_hdr.type = lttng_tracker_id_get_type(id); + switch (id_hdr.type) { + case LTTNG_ID_ALL: + break; + case LTTNG_ID_VALUE: + status = lttng_tracker_id_get_value(id, &value); + id_hdr.u.value = value; + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ret = LTTNG_ERR_INVALID; + goto error_list_tracker; + } + break; + case LTTNG_ID_STRING: + status = lttng_tracker_id_get_string( + id, &string); + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ret = LTTNG_ERR_INVALID; + goto error_list_tracker; + } + id_hdr.u.var_data_len = var_data_len = + strlen(string) + 1; + break; + default: + ret = LTTNG_ERR_INVALID; + goto error_list_tracker; + } + ret = lttng_dynamic_buffer_append( + &buf, &id_hdr, sizeof(id_hdr)); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error_list_tracker; + } + ret = lttng_dynamic_buffer_append( + &buf, string, var_data_len); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error_list_tracker; + } + } + + cmd_header.nb_tracker_id = nr_ids; + ret = setup_lttng_msg(cmd_ctx, buf.data, buf.size, &cmd_header, + sizeof(cmd_header)); + error_list_tracker: + lttng_tracker_ids_destroy(ids, nr_ids); + free(ids); + lttng_dynamic_buffer_reset(&buf); if (ret < 0) { goto setup_error; } @@ -1476,7 +1668,7 @@ error_add_context: /* Receive variable len data */ DBG("Receiving %zu URI(s) from client ...", nb_uri); - ret = lttcomm_recv_unix_sock(sock, uris, len); + ret = lttcomm_recv_unix_sock(*sock, uris, len); if (ret <= 0) { DBG("No URIs received from client... continuing"); *sock_error = 1; @@ -1521,7 +1713,8 @@ error_add_context: case LTTNG_DESTROY_SESSION: { ret = cmd_destroy_session(cmd_ctx->session, - notification_thread_handle); + notification_thread_handle, + sock); break; } case LTTNG_LIST_DOMAINS: @@ -1700,13 +1893,16 @@ error_add_context: } case LTTNG_SNAPSHOT_ADD_OUTPUT: { + uint32_t snapshot_id; struct lttcomm_lttng_output_id reply; ret = cmd_snapshot_add_output(cmd_ctx->session, - &cmd_ctx->lsm->u.snapshot_output.output, &reply.id); + ALIGNED_CONST_PTR(cmd_ctx->lsm->u.snapshot_output.output), + &snapshot_id); if (ret != LTTNG_OK) { goto error; } + reply.id = snapshot_id; ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply, sizeof(reply)); @@ -1721,7 +1917,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: @@ -1750,7 +1946,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; } @@ -1760,7 +1956,7 @@ error_add_context: struct lttng_session_descriptor *return_descriptor = NULL; lttng_dynamic_buffer_init(&payload); - ret = cmd_create_session(cmd_ctx, sock, &return_descriptor); + ret = cmd_create_session(cmd_ctx, *sock, &return_descriptor); if (ret != LTTNG_OK) { goto error; } @@ -1809,13 +2005,13 @@ error_add_context: } case LTTNG_REGISTER_TRIGGER: { - ret = cmd_register_trigger(cmd_ctx, sock, + ret = cmd_register_trigger(cmd_ctx, *sock, notification_thread_handle); break; } case LTTNG_UNREGISTER_TRIGGER: { - ret = cmd_unregister_trigger(cmd_ctx, sock, + ret = cmd_unregister_trigger(cmd_ctx, *sock, notification_thread_handle); break; } @@ -1832,7 +2028,9 @@ error_add_context: goto error; } - ret = cmd_rotate_session(cmd_ctx->session, &rotate_return); + ret = cmd_rotate_session(cmd_ctx->session, &rotate_return, + false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); if (ret < 0) { ret = -ret; goto error; @@ -1916,6 +2114,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; @@ -1934,6 +2137,7 @@ setup_error: if (cmd_ctx->session) { session_unlock(cmd_ctx->session); session_put(cmd_ctx->session); + cmd_ctx->session = NULL; } if (need_tracing_session) { session_unlock_list(); @@ -1967,8 +2171,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); @@ -2001,7 +2208,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); @@ -2010,10 +2217,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(); @@ -2090,11 +2293,6 @@ static void *thread_manage_clients(void *data) health_code_update(); - if (!revents) { - /* No activity for this FD (poll implementation). */ - continue; - } - if (pollfd == thread_quit_pipe_fd) { err = 0; goto exit; @@ -2183,14 +2381,16 @@ static void *thread_manage_clients(void *data) * informations for the client. The command context struct contains * everything this function may needs. */ - ret = process_client_msg(cmd_ctx, sock, &sock_error); + ret = process_client_msg(cmd_ctx, &sock, &sock_error); rcu_thread_offline(); if (ret < 0) { - ret = close(sock); - if (ret) { - PERROR("close"); - } - sock = -1; + if (sock >= 0) { + ret = close(sock); + if (ret) { + PERROR("close"); + } + } + sock = -1; /* * TODO: Inform client somehow of the fatal error. At * this point, ret < 0 means that a zmalloc failed @@ -2216,21 +2416,24 @@ static void *thread_manage_clients(void *data) health_code_update(); - DBG("Sending response (size: %d, retcode: %s (%d))", - cmd_ctx->lttng_msg_size, - lttng_strerror(-cmd_ctx->llm->ret_code), - cmd_ctx->llm->ret_code); - ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size); - if (ret < 0) { - ERR("Failed to send data back to client"); - } + if (sock >= 0) { + DBG("Sending response (size: %d, retcode: %s (%d))", + cmd_ctx->lttng_msg_size, + lttng_strerror(-cmd_ctx->llm->ret_code), + cmd_ctx->llm->ret_code); + ret = send_unix_sock(sock, cmd_ctx->llm, + cmd_ctx->lttng_msg_size); + if (ret < 0) { + ERR("Failed to send data back to client"); + } - /* End of transmission */ - ret = close(sock); - if (ret) { - PERROR("close"); - } - sock = -1; + /* End of transmission */ + ret = close(sock); + if (ret) { + PERROR("close"); + } + } + sock = -1; clean_command_ctx(&cmd_ctx); @@ -2252,11 +2455,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) { @@ -2285,7 +2486,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); @@ -2293,6 +2495,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, @@ -2301,6 +2509,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 @@ -2308,11 +2519,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; }