X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=c6913fa0a5fd41888507f576e6f8387b824e0f92;hb=8d5bb86ea2e1a863a5d0dd91249f32e1fcd29fd6;hp=46c98a5611b9e818c0c99e7e7a64bcd56a02b60e;hpb=133842876fe8a87ba184c9ac2b6e004eb388fb73;p=lttng-tools.git diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c index 46c98a561..c6913fa0a 100644 --- a/ltt-sessiond/main.c +++ b/ltt-sessiond/main.c @@ -55,6 +55,8 @@ #include "utils.h" #include "ust-ctl.h" +#include "benchmark.h" + /* Const values */ const char default_home_dir[] = DEFAULT_HOME_DIR; const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP; @@ -358,6 +360,25 @@ static void cleanup(void) close(thread_quit_pipe[0]); close(thread_quit_pipe[1]); + + /* OUTPUT BENCHMARK RESULTS */ + bench_init(); + + if (getenv("BENCH_UST_NOTIFY")) { + bench_print_ust_notification(); + } + + if (getenv("BENCH_UST_REGISTER")) { + bench_print_ust_register(); + bench_print_ust_unregister(); + } + + if (getenv("BENCH_BOOT_PROCESS")) { + bench_print_boot_process(); + } + + bench_close(); + /* END BENCHMARK */ } /* @@ -522,6 +543,8 @@ static int notify_ust_apps(int active) DBG("Notifying applications of session daemon state: %d", active); + tracepoint(ust_notify_apps_start); + /* See shm.c for this call implying mmap, shm and futex calls */ wait_shm_mmap = shm_ust_get_mmap(wait_shm_path, is_root); if (wait_shm_mmap == NULL) { @@ -531,6 +554,8 @@ static int notify_ust_apps(int active) /* Wake waiting process */ futex_wait_update((int32_t *) wait_shm_mmap, active); + tracepoint(ust_notify_apps_stop); + /* Apps notified successfully */ return 0; @@ -687,6 +712,8 @@ static void *thread_manage_kernel(void *data) char tmp; struct lttng_poll_event events; + tracepoint(sessiond_th_kern_start); + DBG("Thread manage kernel started"); ret = create_thread_poll_set(&events, 2); @@ -721,6 +748,8 @@ static void *thread_manage_kernel(void *data) /* Zeroed the poll events */ lttng_poll_reset(&events); + tracepoint(sessiond_th_kern_poll); + /* Poll infinite value of time */ ret = lttng_poll_wait(&events, -1); if (ret < 0) { @@ -788,6 +817,8 @@ static void *thread_manage_kconsumerd(void *data) enum lttcomm_return_code code; struct lttng_poll_event events; + tracepoint(sessiond_th_kcon_start); + DBG("[thread] Manage kconsumerd started"); ret = lttcomm_listen_unix_sock(kconsumerd_err_sock); @@ -811,6 +842,8 @@ static void *thread_manage_kconsumerd(void *data) nb_fd = LTTNG_POLL_GETNB(&events); + tracepoint(sessiond_th_kcon_poll); + /* Inifinite blocking call, waiting for transmission */ ret = lttng_poll_wait(&events, -1); if (ret < 0) { @@ -842,6 +875,8 @@ static void *thread_manage_kconsumerd(void *data) goto error; } + DBG2("Receiving code from kconsumerd_err_sock"); + /* Getting status code from kconsumerd */ ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code)); @@ -861,7 +896,7 @@ static void *thread_manage_kconsumerd(void *data) sem_post(&kconsumerd_sem); DBG("Kconsumerd command socket ready"); } else { - DBG("Kconsumerd error when waiting for SOCK_READY : %s", + ERR("Kconsumerd error when waiting for SOCK_READY : %s", lttcomm_get_readable_code(-code)); goto error; } @@ -941,6 +976,8 @@ static void *thread_manage_apps(void *data) struct ust_command ust_cmd; struct lttng_poll_event events; + tracepoint(sessiond_th_apps_start); + DBG("[thread] Manage application started"); ret = create_thread_poll_set(&events, 2); @@ -961,6 +998,8 @@ static void *thread_manage_apps(void *data) DBG("Apps thread polling on %d fds", nb_fd); + tracepoint(sessiond_th_apps_poll); + /* Inifinite blocking call, waiting for transmission */ ret = lttng_poll_wait(&events, -1); if (ret < 0) { @@ -984,13 +1023,16 @@ static void *thread_manage_apps(void *data) ERR("Apps command pipe error"); goto error; } else if (revents & LPOLLIN) { + tracepoint(ust_register_read_start); /* Empty pipe */ ret = read(apps_cmd_pipe[0], &ust_cmd, sizeof(ust_cmd)); if (ret < 0 || ret < sizeof(ust_cmd)) { perror("read apps cmd pipe"); goto error; } + tracepoint(ust_register_read_stop); + tracepoint(ust_register_add_start); /* Register applicaton to the session daemon */ ret = ust_app_register(&ust_cmd.reg_msg, ust_cmd.sock); @@ -998,7 +1040,9 @@ static void *thread_manage_apps(void *data) /* Only critical ENOMEM error can be returned here */ goto error; } + tracepoint(ust_register_add_stop); + tracepoint(ust_register_done_start); ret = ustctl_register_done(ust_cmd.sock); if (ret < 0) { /* @@ -1019,6 +1063,7 @@ static void *thread_manage_apps(void *data) DBG("Apps with sock %d added to poll set", ust_cmd.sock); } + tracepoint(ust_register_done_stop); break; } } else { @@ -1061,6 +1106,8 @@ static void *thread_dispatch_ust_registration(void *data) struct cds_wfq_node *node; struct ust_command *ust_cmd = NULL; + tracepoint(sessiond_th_dispatch_start); + DBG("[thread] Dispatch UST command started"); while (!dispatch_thread_exit) { @@ -1068,6 +1115,8 @@ static void *thread_dispatch_ust_registration(void *data) futex_nto1_prepare(&ust_cmd_queue.futex); do { + tracepoint(sessiond_th_dispatch_block); + /* Dequeue command for registration */ node = cds_wfq_dequeue_blocking(&ust_cmd_queue.queue); if (node == NULL) { @@ -1076,6 +1125,8 @@ static void *thread_dispatch_ust_registration(void *data) break; } + tracepoint(ust_dispatch_register_start); + ust_cmd = caa_container_of(node, struct ust_command, node); DBG("Dispatching UST registration pid:%d ppid:%d uid:%d" @@ -1106,6 +1157,8 @@ static void *thread_dispatch_ust_registration(void *data) free(ust_cmd); } while (node != NULL); + tracepoint(ust_dispatch_register_stop); + /* Futex wait on queue. Blocking call on futex() */ futex_nto1_wait(&ust_cmd_queue.futex); } @@ -1129,6 +1182,8 @@ static void *thread_registration_apps(void *data) */ struct ust_command *ust_cmd = NULL; + tracepoint(sessiond_th_reg_start); + DBG("[thread] Manage application registration started"); ret = lttcomm_listen_unix_sock(apps_sock); @@ -1162,6 +1217,8 @@ static void *thread_registration_apps(void *data) while (1) { DBG("Accepting application registration"); + tracepoint(sessiond_th_reg_poll); + nb_fd = LTTNG_POLL_GETNB(&events); /* Inifinite blocking call, waiting for transmission */ @@ -1187,6 +1244,9 @@ static void *thread_registration_apps(void *data) ERR("Register apps socket poll error"); goto error; } else if (revents & LPOLLIN) { + /* Registration starts here. Recording cycles */ + tracepoint(ust_register_start); + sock = lttcomm_accept_unix_sock(apps_sock); if (sock < 0) { goto error; @@ -1236,6 +1296,8 @@ static void *thread_registration_apps(void *data) * barrier with the exchange in cds_wfq_enqueue. */ futex_nto1_wake(&ust_cmd_queue.futex); + + tracepoint(ust_register_stop); } } } @@ -1263,29 +1325,66 @@ error: static int spawn_kconsumerd_thread(void) { int ret; + struct timespec timeout; + + timeout.tv_sec = DEFAULT_SEM_WAIT_TIMEOUT; + timeout.tv_nsec = 0; /* Setup semaphore */ - sem_init(&kconsumerd_sem, 0, 0); + ret = sem_init(&kconsumerd_sem, 0, 0); + if (ret < 0) { + PERROR("sem_init kconsumerd_sem"); + goto error; + } ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) NULL); if (ret != 0) { - perror("pthread_create kconsumerd"); + PERROR("pthread_create kconsumerd"); + ret = -1; goto error; } - /* Wait for the kconsumerd thread to be ready */ - sem_wait(&kconsumerd_sem); + /* Get time for sem_timedwait absolute timeout */ + ret = clock_gettime(CLOCK_REALTIME, &timeout); + if (ret < 0) { + PERROR("clock_gettime spawn kconsumerd"); + /* Infinite wait for the kconsumerd thread to be ready */ + ret = sem_wait(&kconsumerd_sem); + } else { + /* Normal timeout if the gettime was successful */ + timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT; + ret = sem_timedwait(&kconsumerd_sem, &timeout); + } + if (ret < 0) { + if (errno == ETIMEDOUT) { + /* + * Call has timed out so we kill the kconsumerd_thread and return + * an error. + */ + ERR("The kconsumerd thread was never ready. Killing it"); + ret = pthread_cancel(kconsumerd_thread); + if (ret < 0) { + PERROR("pthread_cancel kconsumerd_thread"); + } + } else { + PERROR("semaphore wait failed kconsumerd thread"); + } + goto error; + } + + pthread_mutex_lock(&kconsumerd_pid_mutex); if (kconsumerd_pid == 0) { ERR("Kconsumerd did not start"); + pthread_mutex_unlock(&kconsumerd_pid_mutex); goto error; } + pthread_mutex_unlock(&kconsumerd_pid_mutex); return 0; error: - ret = LTTCOMM_KERN_CONSUMER_FAIL; return ret; } @@ -1367,18 +1466,16 @@ static int start_kconsumerd(void) 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; + DBG2("Kconsumerd pid %d", kconsumerd_pid); pthread_mutex_unlock(&kconsumerd_pid_mutex); - DBG("Kconsumerd pid %d", ret); - - DBG("Spawning kconsumerd thread"); + DBG2("Spawning kconsumerd thread"); ret = spawn_kconsumerd_thread(); if (ret < 0) { ERR("Fatal error spawning kconsumerd thread"); @@ -2525,7 +2622,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx) break; default: DBG("Getting session %s by name", cmd_ctx->lsm->session.name); + session_lock_list(); cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name); + session_unlock_list(); if (cmd_ctx->session == NULL) { if (cmd_ctx->lsm->session.name != NULL) { ret = LTTCOMM_SESS_NOT_FOUND; @@ -2567,14 +2666,17 @@ static int process_client_msg(struct command_ctx *cmd_ctx) } /* Start the kernel consumer daemon */ + pthread_mutex_lock(&kconsumerd_pid_mutex); if (kconsumerd_pid == 0 && cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) { + pthread_mutex_unlock(&kconsumerd_pid_mutex); ret = start_kconsumerd(); if (ret < 0) { ret = LTTCOMM_KERN_CONSUMER_FAIL; goto error; } } + pthread_mutex_unlock(&kconsumerd_pid_mutex); } break; case LTTNG_DOMAIN_UST_PID: @@ -2696,14 +2798,18 @@ static int process_client_msg(struct command_ctx *cmd_ctx) } case LTTNG_CREATE_SESSION: { + tracepoint(create_session_start); ret = cmd_create_session(cmd_ctx->lsm->session.name, cmd_ctx->lsm->session.path); + tracepoint(create_session_end); break; } case LTTNG_DESTROY_SESSION: { + tracepoint(destroy_session_start); ret = cmd_destroy_session(cmd_ctx->session, cmd_ctx->lsm->session.name); + tracepoint(destroy_session_end); break; } case LTTNG_LIST_DOMAINS: @@ -2852,6 +2958,8 @@ static void *thread_manage_clients(void *data) struct command_ctx *cmd_ctx = NULL; struct lttng_poll_event events; + tracepoint(sessiond_th_cli_start); + DBG("[thread] Manage client started"); ret = lttcomm_listen_unix_sock(client_sock); @@ -2884,6 +2992,8 @@ static void *thread_manage_clients(void *data) while (1) { DBG("Accepting client command ..."); + tracepoint(sessiond_th_cli_poll); + nb_fd = LTTNG_POLL_GETNB(&events); /* Inifinite blocking call, waiting for transmission */ @@ -3398,6 +3508,8 @@ int main(int argc, char **argv) void *status; const char *home_path; + tracepoint(sessiond_boot_start); + /* Create thread quit pipe */ if ((ret = init_thread_quit_pipe()) < 0) { goto error; @@ -3586,6 +3698,8 @@ int main(int argc, char **argv) goto exit_kernel; } + tracepoint(sessiond_boot_end); + ret = pthread_join(kernel_thread, &status); if (ret != 0) { perror("pthread_join");