From 1d4b027abdef2dc52b41b05ec56c5046c5000c4c Mon Sep 17 00:00:00 2001 From: David Goulet Date: Thu, 26 May 2011 14:43:41 -0400 Subject: [PATCH] Cleanup static declaration and move code around Also set the ltt_session_list to extern and thus global. There is no mutex protecting it for now. This will come on the multi-threaded version of the session daemon. Move a lot of code around to make static prototype disappear. Signed-off-by: David Goulet --- ltt-sessiond/main.c | 747 ++++++++++++++++++++--------------------- ltt-sessiond/session.c | 10 +- ltt-sessiond/session.h | 3 +- 3 files changed, 377 insertions(+), 383 deletions(-) diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c index a7c6e5fbf..5337d6df4 100644 --- a/ltt-sessiond/main.c +++ b/ltt-sessiond/main.c @@ -59,257 +59,150 @@ const char default_tracing_group[] = DEFAULT_TRACING_GROUP; const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR; const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE; -/* Static functions */ -static int check_existing_daemon(void); -static int ust_connect_app(pid_t pid); -static int init_daemon_socket(void); -static int notify_apps(const char* name); -static int process_client_msg(struct command_ctx *cmd_ctx); -static int send_unix_sock(int sock, void *buf, size_t len); -static int set_signal_handler(void); -static int set_permissions(void); -static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size); -static int create_lttng_rundir(void); -static int create_trace_dir(struct ltt_kernel_session *session); -static int set_kconsumerd_sockets(void); -static void cleanup(void); -static void sighandler(int sig); -static void clean_command_ctx(struct command_ctx *cmd_ctx); -static void teardown_kernel_session(struct ltt_session *session); - -static void *thread_manage_clients(void *data); -static void *thread_manage_apps(void *data); -static void *thread_manage_kconsumerd(void *data); - /* Variables */ -int opt_verbose; -int opt_quiet; +int opt_verbose; /* Not static for lttngerr.h */ +int opt_quiet; /* Not static for lttngerr.h */ const char *progname; const char *opt_tracing_group; static int opt_sig_parent; static int opt_daemon; static int is_root; /* Set to 1 if the daemon is running as root */ -static pid_t ppid; +static pid_t ppid; /* Parent PID for --sig-parent option */ +static pid_t kconsumerd_pid; static char apps_unix_sock_path[PATH_MAX]; /* Global application Unix socket path */ static char client_unix_sock_path[PATH_MAX]; /* Global client Unix socket path */ static char kconsumerd_err_unix_sock_path[PATH_MAX]; /* kconsumerd error Unix socket path */ static char kconsumerd_cmd_unix_sock_path[PATH_MAX]; /* kconsumerd command Unix socket path */ +/* Sockets and FDs */ static int client_sock; static int apps_sock; static int kconsumerd_err_sock; static int kconsumerd_cmd_sock; static int kernel_tracer_fd; + +/* Pthread, Mutexes and Semaphores */ static pthread_t kconsumerd_thread; +static pthread_t apps_thread; +static pthread_t client_thread; static sem_t kconsumerd_sem; -static pthread_mutex_t kconsumerd_pid_mutex; -static pid_t kconsumerd_pid; +static pthread_mutex_t kconsumerd_pid_mutex; /* Mutex to control kconsumerd pid assignation */ /* - * thread_manage_kconsumerd + * free_kernel_session * - * This thread manage the kconsumerd error sent - * back to the session daemon. + * Free all data structure inside a kernel session and the session pointer. */ -static void *thread_manage_kconsumerd(void *data) +static void free_kernel_session(struct ltt_kernel_session *session) { - int sock, ret; - enum lttcomm_return_code code; - - DBG("[thread] Manage kconsumerd started"); - - ret = lttcomm_listen_unix_sock(kconsumerd_err_sock); - if (ret < 0) { - goto error; - } - - sock = lttcomm_accept_unix_sock(kconsumerd_err_sock); - if (sock < 0) { - goto error; - } + struct ltt_kernel_channel *chan; + struct ltt_kernel_stream *stream; + struct ltt_kernel_event *event; - ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); - if (ret <= 0) { - goto error; - } + /* Clean metadata */ + close(session->metadata_stream_fd); + close(session->metadata->fd); + free(session->metadata->conf); + free(session->metadata); - if (code == KCONSUMERD_COMMAND_SOCK_READY) { - kconsumerd_cmd_sock = lttcomm_connect_unix_sock(kconsumerd_cmd_unix_sock_path); - if (kconsumerd_cmd_sock < 0) { - perror("kconsumerd connect"); - goto error; + cds_list_for_each_entry(chan, &session->channel_list.head, list) { + /* Clean all event(s) */ + cds_list_for_each_entry(event, &chan->events_list.head, list) { + close(event->fd); + free(event->event); + free(event); } - /* Signal condition to tell that the kconsumerd is ready */ - sem_post(&kconsumerd_sem); - DBG("Kconsumerd command socket ready"); - } else { - DBG("[sessiond] Kconsumerd error when waiting for SOCK_READY : %s", - lttcomm_get_readable_code(-code)); - goto error; - } - /* Wait for any kconsumerd error */ - ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); - if (ret <= 0) { - ERR("[sessiond] Kconsumerd closed the command socket"); - goto error; + /* Clean streams */ + cds_list_for_each_entry(stream, &chan->stream_list.head, list) { + close(stream->fd); + free(stream->pathname); + free(stream); + } + /* Clean channel */ + close(chan->fd); + free(chan->channel); + free(chan->pathname); + free(chan); } - ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code)); + close(session->fd); + free(session); -error: - teardown_kernel_session((struct ltt_session *) data); - return NULL; + DBG("All kernel session data structures freed"); } /* - * thread_manage_apps + * teardown_kernel_session * - * This thread manage the application socket communication + * Complete teardown of a kernel session. This free all data structure + * related to a kernel session and update counter. */ -static void *thread_manage_apps(void *data) +static void teardown_kernel_session(struct ltt_session *session) { - int sock, ret; - - /* TODO: Something more elegant is needed but fine for now */ - /* FIXME: change all types to either uint8_t, uint32_t, uint64_t - * for 32-bit vs 64-bit compat processes. */ - /* replicate in ust with version number */ - struct { - int reg; /* 1:register, 0:unregister */ - pid_t pid; - uid_t uid; - } reg_msg; - - DBG("[thread] Manage apps started"); - - ret = lttcomm_listen_unix_sock(apps_sock); - if (ret < 0) { - goto error; - } - - /* Notify all applications to register */ - notify_apps(default_global_apps_pipe); - - while (1) { - DBG("Accepting application registration"); - /* Blocking call, waiting for transmission */ - sock = lttcomm_accept_unix_sock(apps_sock); - if (sock < 0) { - goto error; - } - - /* Basic recv here to handle the very simple data - * that the libust send to register (reg_msg). - */ - ret = recv(sock, ®_msg, sizeof(reg_msg), 0); - if (ret < 0) { - perror("recv"); - continue; - } - - /* Add application to the global traceable list */ - if (reg_msg.reg == 1) { - /* Registering */ - ret = register_traceable_app(reg_msg.pid, reg_msg.uid); - if (ret < 0) { - /* register_traceable_app only return an error with - * ENOMEM. At this point, we better stop everything. - */ - goto error; - } - } else { - /* Unregistering */ - unregister_traceable_app(reg_msg.pid); - } + if (session->kernel_session != NULL) { + DBG("Tearing down kernel session"); + free_kernel_session(session->kernel_session); + /* Extra precaution */ + session->kernel_session = NULL; + /* Decrement session count */ + session->kern_session_count--; } - -error: - - return NULL; } /* - * thread_manage_clients + * cleanup * - * This thread manage all clients request using the unix - * client socket for communication. + * Cleanup the daemon on exit */ -static void *thread_manage_clients(void *data) +static void cleanup() { - int sock, ret; - struct command_ctx *cmd_ctx; + int ret; + char *cmd; + struct ltt_session *sess; - DBG("[thread] Manage client started"); + DBG("Cleaning up"); - ret = lttcomm_listen_unix_sock(client_sock); - if (ret < 0) { - goto error; - } + /* */ + MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0); + MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0); + /* */ - /* Notify parent pid that we are ready - * to accept command for client side. - */ - if (opt_sig_parent) { - kill(ppid, SIGCHLD); + /* Stopping all threads */ + DBG("Terminating all threads"); + pthread_cancel(client_thread); + pthread_cancel(apps_thread); + if (kconsumerd_pid != 0) { + pthread_cancel(kconsumerd_thread); } - while (1) { - /* Blocking call, waiting for transmission */ - DBG("Accepting client command ..."); - sock = lttcomm_accept_unix_sock(client_sock); - if (sock < 0) { - goto error; - } - - /* Allocate context command to process the client request */ - cmd_ctx = malloc(sizeof(struct command_ctx)); - - /* Allocate data buffer for reception */ - cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg)); - cmd_ctx->llm = NULL; - cmd_ctx->session = NULL; - - /* - * Data is received from the lttng client. The struct - * lttcomm_session_msg (lsm) contains the command and data request of - * the client. - */ - DBG("Receiving data from client ..."); - ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm, sizeof(struct lttcomm_session_msg)); - if (ret <= 0) { - continue; - } + DBG("Unlinking all unix socket"); + unlink(client_unix_sock_path); + unlink(apps_unix_sock_path); + unlink(kconsumerd_err_unix_sock_path); - /* - * This function dispatch the work to the kernel or userspace tracer - * libs and fill the lttcomm_lttng_msg data structure of all the needed - * informations for the client. The command context struct contains - * everything this function may needs. - */ - ret = process_client_msg(cmd_ctx); - if (ret < 0) { - /* TODO: Inform client somehow of the fatal error. At this point, - * ret < 0 means that a malloc failed (ENOMEM). */ - /* Error detected but still accept command */ - clean_command_ctx(cmd_ctx); - continue; - } + DBG("Removing %s directory", LTTNG_RUNDIR); + ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR); + if (ret < 0) { + ERR("asprintf failed. Something is really wrong!"); + } - DBG("Sending response (size: %d, retcode: %d)", - cmd_ctx->lttng_msg_size, 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"); - } + /* Remove lttng run directory */ + ret = system(cmd); + if (ret < 0) { + ERR("Unable to clean " LTTNG_RUNDIR); + } - clean_command_ctx(cmd_ctx); + DBG("Cleaning up all session"); + /* Cleanup ALL session */ + cds_list_for_each_entry(sess, <t_session_list.head, list) { + teardown_kernel_session(sess); + // TODO complete session cleanup (including UST) } -error: - return NULL; + close(kernel_tracer_fd); } /* @@ -459,20 +352,144 @@ error: return ret; } +/* + * thread_manage_kconsumerd + * + * This thread manage the kconsumerd error sent + * back to the session daemon. + */ +static void *thread_manage_kconsumerd(void *data) +{ + int sock, ret; + enum lttcomm_return_code code; + + DBG("[thread] Manage kconsumerd started"); + + ret = lttcomm_listen_unix_sock(kconsumerd_err_sock); + if (ret < 0) { + goto error; + } + + sock = lttcomm_accept_unix_sock(kconsumerd_err_sock); + if (sock < 0) { + goto error; + } + + ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); + if (ret <= 0) { + goto error; + } + + if (code == KCONSUMERD_COMMAND_SOCK_READY) { + kconsumerd_cmd_sock = lttcomm_connect_unix_sock(kconsumerd_cmd_unix_sock_path); + if (kconsumerd_cmd_sock < 0) { + perror("kconsumerd connect"); + goto error; + } + /* Signal condition to tell that the kconsumerd is ready */ + sem_post(&kconsumerd_sem); + DBG("Kconsumerd command socket ready"); + } else { + DBG("[sessiond] Kconsumerd error when waiting for SOCK_READY : %s", + lttcomm_get_readable_code(-code)); + goto error; + } + + /* Wait for any kconsumerd error */ + ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); + if (ret <= 0) { + ERR("[sessiond] Kconsumerd closed the command socket"); + goto error; + } + + ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code)); + +error: + kconsumerd_pid = 0; + return NULL; +} + +/* + * thread_manage_apps + * + * This thread manage the application socket communication + */ +static void *thread_manage_apps(void *data) +{ + int sock, ret; + + /* TODO: Something more elegant is needed but fine for now */ + /* FIXME: change all types to either uint8_t, uint32_t, uint64_t + * for 32-bit vs 64-bit compat processes. */ + /* replicate in ust with version number */ + struct { + int reg; /* 1:register, 0:unregister */ + pid_t pid; + uid_t uid; + } reg_msg; + + DBG("[thread] Manage apps started"); + + ret = lttcomm_listen_unix_sock(apps_sock); + if (ret < 0) { + goto error; + } + + /* Notify all applications to register */ + notify_apps(default_global_apps_pipe); + + while (1) { + DBG("Accepting application registration"); + /* Blocking call, waiting for transmission */ + sock = lttcomm_accept_unix_sock(apps_sock); + if (sock < 0) { + goto error; + } + + /* Basic recv here to handle the very simple data + * that the libust send to register (reg_msg). + */ + ret = recv(sock, ®_msg, sizeof(reg_msg), 0); + if (ret < 0) { + perror("recv"); + continue; + } + + /* Add application to the global traceable list */ + if (reg_msg.reg == 1) { + /* Registering */ + ret = register_traceable_app(reg_msg.pid, reg_msg.uid); + if (ret < 0) { + /* register_traceable_app only return an error with + * ENOMEM. At this point, we better stop everything. + */ + goto error; + } + } else { + /* Unregistering */ + unregister_traceable_app(reg_msg.pid); + } + } + +error: + + return NULL; +} + /* * start_kconsumerd_thread * * Start the thread_manage_kconsumerd. This must be done after a kconsumerd * exec or it will fails. */ -static int start_kconsumerd_thread(struct ltt_session *session) +static int start_kconsumerd_thread(void) { int ret; /* Setup semaphore */ sem_init(&kconsumerd_sem, 0, 0); - ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) session); + ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) NULL); if (ret != 0) { perror("pthread_create kconsumerd"); goto error; @@ -560,93 +577,56 @@ static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session) lkh.cmd_type = LTTCOMM_ADD_STREAM; DBG("Sending kconsumerd header"); - - ret = lttcomm_send_unix_sock(sock, &lkh, sizeof(struct lttcomm_kconsumerd_header)); - if (ret < 0) { - perror("send kconsumerd header"); - goto error; - } - - DBG("Sending all fds to kconsumerd"); - - ret = lttcomm_send_fds_unix_sock(sock, buf, fds, nb_fd, lkh.payload_size); - if (ret < 0) { - perror("send kconsumerd fds"); - goto error; - } - - DBG("Kconsumerd fds sent"); - - return 0; - -error: - return ret; -} - -/* - * free_kernel_session - * - * Free all data structure inside a kernel session and the session pointer. - */ -static void free_kernel_session(struct ltt_kernel_session *session) -{ - struct ltt_kernel_channel *chan; - struct ltt_kernel_stream *stream; - struct ltt_kernel_event *event; - - /* Clean metadata */ - close(session->metadata_stream_fd); - close(session->metadata->fd); - free(session->metadata->conf); - free(session->metadata); - - cds_list_for_each_entry(chan, &session->channel_list.head, list) { - /* Clean all event(s) */ - cds_list_for_each_entry(event, &chan->events_list.head, list) { - close(event->fd); - free(event->event); - free(event); - } - - /* Clean streams */ - cds_list_for_each_entry(stream, &chan->stream_list.head, list) { - close(stream->fd); - free(stream->pathname); - free(stream); - } - /* Clean channel */ - close(chan->fd); - free(chan->channel); - free(chan->pathname); - free(chan); + + ret = lttcomm_send_unix_sock(sock, &lkh, sizeof(struct lttcomm_kconsumerd_header)); + if (ret < 0) { + perror("send kconsumerd header"); + goto error; } - close(session->fd); - free(session); + DBG("Sending all fds to kconsumerd"); - DBG("All kernel session data structures freed"); + ret = lttcomm_send_fds_unix_sock(sock, buf, fds, nb_fd, lkh.payload_size); + if (ret < 0) { + perror("send kconsumerd fds"); + goto error; + } + + DBG("Kconsumerd fds sent"); + + return 0; + +error: + return ret; } /* - * teardown_kernel_session + * create_trace_dir * - * Complete teardown of a kernel session. This free all data structure - * related to a kernel session and update counter. + * Create the trace output directory. */ -static void teardown_kernel_session(struct ltt_session *session) +static int create_trace_dir(struct ltt_kernel_session *session) { - if (session->kernel_session != NULL) { - DBG("Tearing down kernel session"); - free_kernel_session(session->kernel_session); - /* Extra precaution */ - session->kernel_session = NULL; - /* Decrement session count */ - session->kern_session_count--; - /* Set kconsumerd pid to 0 (inactive) */ - session->kernel_consumer = 0; + int ret; + struct ltt_kernel_channel *chan; + + /* Create all channel directories */ + cds_list_for_each_entry(chan, &session->channel_list.head, list) { + ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG ); + if (ret < 0) { + perror("mkdir trace path"); + ret = -errno; + goto error; + } } + + return 0; + +error: + return ret; } + /* * process_client_msg * @@ -731,7 +711,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx) } pthread_mutex_unlock(&kconsumerd_pid_mutex); - ret = start_kconsumerd_thread(cmd_ctx->session); + ret = start_kconsumerd_thread(); if (ret < 0) { ERR("Fatal error : start_kconsumerd_thread()"); ret = LTTCOMM_FATAL; @@ -1071,6 +1051,88 @@ setup_error: return ret; } +/* + * thread_manage_clients + * + * This thread manage all clients request using the unix + * client socket for communication. + */ +static void *thread_manage_clients(void *data) +{ + int sock, ret; + struct command_ctx *cmd_ctx; + + DBG("[thread] Manage client started"); + + ret = lttcomm_listen_unix_sock(client_sock); + if (ret < 0) { + goto error; + } + + /* Notify parent pid that we are ready + * to accept command for client side. + */ + if (opt_sig_parent) { + kill(ppid, SIGCHLD); + } + + while (1) { + /* Blocking call, waiting for transmission */ + DBG("Accepting client command ..."); + sock = lttcomm_accept_unix_sock(client_sock); + if (sock < 0) { + goto error; + } + + /* Allocate context command to process the client request */ + cmd_ctx = malloc(sizeof(struct command_ctx)); + + /* Allocate data buffer for reception */ + cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg)); + cmd_ctx->llm = NULL; + cmd_ctx->session = NULL; + + /* + * Data is received from the lttng client. The struct + * lttcomm_session_msg (lsm) contains the command and data request of + * the client. + */ + DBG("Receiving data from client ..."); + ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm, sizeof(struct lttcomm_session_msg)); + if (ret <= 0) { + continue; + } + + /* + * This function dispatch the work to the kernel or userspace tracer + * libs and fill the lttcomm_lttng_msg data structure of all the needed + * informations for the client. The command context struct contains + * everything this function may needs. + */ + ret = process_client_msg(cmd_ctx); + if (ret < 0) { + /* TODO: Inform client somehow of the fatal error. At this point, + * ret < 0 means that a malloc failed (ENOMEM). */ + /* Error detected but still accept command */ + clean_command_ctx(cmd_ctx); + continue; + } + + DBG("Sending response (size: %d, retcode: %d)", + cmd_ctx->lttng_msg_size, 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"); + } + + clean_command_ctx(cmd_ctx); + } + +error: + return NULL; +} + + /* * usage function on stderr */ @@ -1308,32 +1370,6 @@ end: return ret; } -/* - * create_trace_dir - * - * Create the trace output directory. - */ -static int create_trace_dir(struct ltt_kernel_session *session) -{ - int ret; - struct ltt_kernel_channel *chan; - - /* Create all channel directories */ - cds_list_for_each_entry(chan, &session->channel_list.head, list) { - ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG ); - if (ret < 0) { - perror("mkdir trace path"); - ret = -errno; - goto error; - } - } - - return 0; - -error: - return ret; -} - /* * create_lttng_rundir * @@ -1416,46 +1452,6 @@ error: } /* - * set_signal_handler - * - * Setup signal handler for : - * SIGINT, SIGTERM, SIGPIPE - */ -static int set_signal_handler(void) -{ - int ret = 0; - struct sigaction sa; - sigset_t sigset; - - if ((ret = sigemptyset(&sigset)) < 0) { - perror("sigemptyset"); - return ret; - } - - sa.sa_handler = sighandler; - sa.sa_mask = sigset; - sa.sa_flags = 0; - if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) { - perror("sigaction"); - return ret; - } - - if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) { - perror("sigaction"); - return ret; - } - - if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) { - perror("sigaction"); - return ret; - } - - DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT"); - - return ret; -} - -/** * sighandler * * Signal handler for the daemon @@ -1482,46 +1478,43 @@ static void sighandler(int sig) } /* - * cleanup + * set_signal_handler * - * Cleanup the daemon on exit + * Setup signal handler for : + * SIGINT, SIGTERM, SIGPIPE */ -static void cleanup() +static int set_signal_handler(void) { - int ret; - char *cmd; - struct ltt_session *sess; - struct ltt_session_list *session_list = get_session_list(); - - DBG("Cleaning up"); - - /* */ - MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0); - MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0); - /* */ + int ret = 0; + struct sigaction sa; + sigset_t sigset; - unlink(client_unix_sock_path); - unlink(apps_unix_sock_path); - unlink(kconsumerd_err_unix_sock_path); + if ((ret = sigemptyset(&sigset)) < 0) { + perror("sigemptyset"); + return ret; + } - ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR); - if (ret < 0) { - ERR("asprintf failed. Something is really wrong!"); + sa.sa_handler = sighandler; + sa.sa_mask = sigset; + sa.sa_flags = 0; + if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) { + perror("sigaction"); + return ret; } - /* Remove lttng run directory */ - ret = system(cmd); - if (ret < 0) { - ERR("Unable to clean " LTTNG_RUNDIR); + if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) { + perror("sigaction"); + return ret; } - /* Cleanup ALL session */ - cds_list_for_each_entry(sess, &session_list->head, list) { - teardown_kernel_session(sess); - // TODO complete session cleanup (including UST) + if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) { + perror("sigaction"); + return ret; } - close(kernel_tracer_fd); + DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT"); + + return ret; } /* @@ -1529,10 +1522,8 @@ static void cleanup() */ int main(int argc, char **argv) { - int i; int ret = 0; void *status; - pthread_t threads[2]; /* Parse arguments */ progname = argv[0]; @@ -1624,25 +1615,23 @@ int main(int argc, char **argv) while (1) { /* Create thread to manage the client socket */ - ret = pthread_create(&threads[0], NULL, thread_manage_clients, (void *) NULL); + ret = pthread_create(&client_thread, NULL, thread_manage_clients, (void *) NULL); if (ret != 0) { perror("pthread_create"); goto error; } /* Create thread to manage application socket */ - ret = pthread_create(&threads[1], NULL, thread_manage_apps, (void *) NULL); + ret = pthread_create(&apps_thread, NULL, thread_manage_apps, (void *) NULL); if (ret != 0) { perror("pthread_create"); goto error; } - for (i = 0; i < 2; i++) { - ret = pthread_join(threads[i], &status); - if (ret != 0) { - perror("pthread_join"); - goto error; - } + ret = pthread_join(client_thread, &status); + if (ret != 0) { + perror("pthread_join"); + goto error; } } diff --git a/ltt-sessiond/session.c b/ltt-sessiond/session.c index 5764b71dc..ae09625a4 100644 --- a/ltt-sessiond/session.c +++ b/ltt-sessiond/session.c @@ -32,7 +32,7 @@ static unsigned int session_count; static void add_session_list(struct ltt_session *ls); static void del_session_list(struct ltt_session *ls); -/* Init session's list */ +/* Init global session list */ struct ltt_session_list ltt_session_list = { .head = CDS_LIST_HEAD_INIT(ltt_session_list.head), }; @@ -202,11 +202,15 @@ int create_session(char *name, uuid_t *session_id) uuid_generate(new_session->uuid); uuid_copy(*session_id, new_session->uuid); - /* Set consumer (identifier) to 0. This means that there is + /* + * Set consumer (identifier) to 0. This means that there is * NO consumer attach to that session yet. */ new_session->ust_consumer = 0; - new_session->kernel_consumer = 0; + + /* Init kernel session */ + new_session->kernel_session = NULL; + new_session->kern_session_count = 0; /* Init list */ CDS_INIT_LIST_HEAD(&new_session->ust_traces); diff --git a/ltt-sessiond/session.h b/ltt-sessiond/session.h index 16e6946a7..25ac3fb90 100644 --- a/ltt-sessiond/session.h +++ b/ltt-sessiond/session.h @@ -28,6 +28,8 @@ struct ltt_session_list { struct cds_list_head head; }; +extern struct ltt_session_list ltt_session_list; + /* ltt-session - This data structure contains information needed * to identify a tracing session for both LTTng and UST. */ @@ -40,7 +42,6 @@ struct ltt_session { unsigned int ust_trace_count; unsigned int kern_session_count; pid_t ust_consumer; - pid_t kernel_consumer; }; /* Prototypes */ -- 2.34.1