X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=4b2fb52c2dd256e5a68809af7107d1dc78631c29;hp=5337d6df44781980c7cc77fd4211932fcf540de0;hb=64a23ac4e22093a782b87fe615fabf20edacedd2;hpb=1d4b027abdef2dc52b41b05ec56c5046c5000c4c diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c index 5337d6df4..4b2fb52c2 100644 --- a/ltt-sessiond/main.c +++ b/ltt-sessiond/main.c @@ -55,7 +55,7 @@ /* Const values */ const char default_home_dir[] = DEFAULT_HOME_DIR; -const char default_tracing_group[] = DEFAULT_TRACING_GROUP; +const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP; const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR; const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE; @@ -90,50 +90,6 @@ static sem_t kconsumerd_sem; static pthread_mutex_t kconsumerd_pid_mutex; /* Mutex to control kconsumerd pid assignation */ -/* - * 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); - } - - close(session->fd); - free(session); - - DBG("All kernel session data structures freed"); -} - /* * teardown_kernel_session * @@ -144,7 +100,7 @@ static void teardown_kernel_session(struct ltt_session *session) { if (session->kernel_session != NULL) { DBG("Tearing down kernel session"); - free_kernel_session(session->kernel_session); + trace_destroy_kernel_session(session->kernel_session); /* Extra precaution */ session->kernel_session = NULL; /* Decrement session count */ @@ -390,22 +346,28 @@ static void *thread_manage_kconsumerd(void *data) sem_post(&kconsumerd_sem); DBG("Kconsumerd command socket ready"); } else { - DBG("[sessiond] Kconsumerd error when waiting for SOCK_READY : %s", + DBG("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; - } + while (1) { + /* Wait for any kconsumerd error */ + ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); + if (ret <= 0) { + ERR("Kconsumerd closed the command socket"); + goto error; + } - ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code)); + ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code)); + if (code != KCONSUMERD_POLL_HUP) { + goto error; + } + } error: kconsumerd_pid = 0; + DBG("Kconsumerd thread dying"); return NULL; } @@ -477,12 +439,12 @@ error: } /* - * start_kconsumerd_thread + * spawn_kconsumerd_thread * * Start the thread_manage_kconsumerd. This must be done after a kconsumerd * exec or it will fails. */ -static int start_kconsumerd_thread(void) +static int spawn_kconsumerd_thread(void) { int ret; @@ -495,6 +457,7 @@ static int start_kconsumerd_thread(void) goto error; } + /* Wait for the kconsumerd thread to be ready */ sem_wait(&kconsumerd_sem); return 0; @@ -504,13 +467,17 @@ error: } /* - * kernel_start_consumer + * spawn_kconsumerd * - * Start a kernel consumer daemon (kconsumerd). + * Fork and exec a kernel consumer daemon (kconsumerd). + * + * NOTE: It is very important to fork a kconsumerd BEFORE opening any kernel + * file descriptor using the libkernelctl or kernel-ctl functions. So, a + * kernel consumer MUST only be spawned before creating a kernel session. * * Return pid if successful else -1. */ -pid_t kernel_start_consumer(void) +static pid_t spawn_kconsumerd(void) { int ret; pid_t pid; @@ -538,6 +505,49 @@ error: return ret; } +/* + * start_kconsumerd + * + * Spawn the kconsumerd daemon and session daemon thread. + */ +static int start_kconsumerd(void) +{ + int ret; + + DBG("Spawning kconsumerd"); + + pthread_mutex_lock(&kconsumerd_pid_mutex); + if (kconsumerd_pid == 0) { + ret = spawn_kconsumerd(); + if (ret < 0) { + ERR("Spawning kconsumerd failed"); + ret = LTTCOMM_KERN_CONSUMER_FAIL; + pthread_mutex_unlock(&kconsumerd_pid_mutex); + goto error; + } + + /* Setting up the global kconsumerd_pid */ + kconsumerd_pid = ret; + } + pthread_mutex_unlock(&kconsumerd_pid_mutex); + + DBG("Kconsumerd pid %d", ret); + + DBG("Spawning kconsumerd thread"); + + ret = spawn_kconsumerd_thread(); + if (ret < 0) { + ERR("Fatal error spawning kconsumerd thread"); + ret = LTTCOMM_FATAL; + goto error; + } + + return 0; + +error: + return ret; +} + /* * send_kconsumerd_fds * @@ -612,6 +622,7 @@ static int create_trace_dir(struct ltt_kernel_session *session) /* Create all channel directories */ cds_list_for_each_entry(chan, &session->channel_list.head, list) { + DBG("Creating trace directory at %s", chan->pathname); ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG ); if (ret < 0) { perror("mkdir trace path"); @@ -626,7 +637,6 @@ error: return ret; } - /* * process_client_msg * @@ -695,26 +705,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx) goto setup_error; } - DBG("Checking if kconsumerd is alive"); - pthread_mutex_lock(&kconsumerd_pid_mutex); - if (kconsumerd_pid == 0) { - ret = kernel_start_consumer(); - if (ret < 0) { - ERR("Kernel start kconsumerd failed"); - ret = LTTCOMM_KERN_CONSUMER_FAIL; - pthread_mutex_unlock(&kconsumerd_pid_mutex); - goto error; - } - - /* Setting up the global kconsumerd_pid */ - kconsumerd_pid = ret; - } - pthread_mutex_unlock(&kconsumerd_pid_mutex); - - ret = start_kconsumerd_thread(); + ret = start_kconsumerd(); if (ret < 0) { - ERR("Fatal error : start_kconsumerd_thread()"); - ret = LTTCOMM_FATAL; goto error; } @@ -864,6 +856,11 @@ static int process_client_msg(struct command_ctx *cmd_ctx) goto setup_error; } + if (cmd_ctx->session->kernel_session == NULL) { + ret = LTTCOMM_KERN_NO_SESSION; + goto error; + } + DBG("Stop kernel tracing"); ret = kernel_stop_session(cmd_ctx->session->kernel_session);