X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fmain.c;h=adf8ea99458235c7d4c042588c3d82288ffafbd4;hb=097e97d5b5b6a20d4aab4f66dce4f0bae5c0a689;hp=4d81896bfd121cbe8163bafcc62fe65f3c134c08;hpb=6b453b5e07e90591c955ae14c60c13b7c1ed28a0;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/main.c b/src/bin/lttng-sessiond/main.c index 4d81896bf..adf8ea994 100644 --- a/src/bin/lttng-sessiond/main.c +++ b/src/bin/lttng-sessiond/main.c @@ -68,6 +68,8 @@ #include "testpoint.h" #include "ust-thread.h" #include "jul-thread.h" +#include "save.h" +#include "load-session-thread.h" #define CONSUMERD_FILE "lttng-consumerd" @@ -79,9 +81,11 @@ static int opt_sig_parent; static int opt_verbose_consumer; static int opt_daemon, opt_background; static int opt_no_kernel; +static char *opt_load_session_path; static pid_t ppid; /* Parent PID for --sig-parent option */ static pid_t child_ppid; /* Internal parent PID use with daemonize. */ static char *rundir; +static int lockfile_fd = -1; /* Set to 1 when a SIGUSR1 signal is received. */ static int recv_child_signal; @@ -151,6 +155,8 @@ static const struct option long_options[] = { { "pidfile", 1, 0, 'p' }, { "jul-tcp-port", 1, 0, 'J' }, { "config", 1, 0, 'f' }, + { "load", 1, 0, 'l' }, + { "kmod-probes", 1, 0, 'P' }, { NULL, 0, 0, 0 } }; @@ -199,13 +205,16 @@ static pthread_t dispatch_thread; static pthread_t health_thread; static pthread_t ht_cleanup_thread; static pthread_t jul_reg_thread; +static pthread_t load_session_thread; /* * UST registration command queue. This queue is tied with a futex and uses a N * wakers / 1 waiter implemented and detailed in futex.c/.h * - * The thread_manage_apps and thread_dispatch_ust_registration interact with - * this queue and the wait/wake scheme. + * The thread_registration_apps and thread_dispatch_ust_registration uses this + * queue along with the wait/wake scheme. The thread_manage_apps receives down + * the line new application socket and monitors it for any I/O error or clean + * close that triggers an unregistration of the application. */ static struct ust_cmd_queue ust_cmd_queue; @@ -288,17 +297,20 @@ int is_root; /* Set to 1 if the daemon is running as root */ const char * const config_section_name = "sessiond"; +/* Load session thread information to operate. */ +struct load_session_thread_data *load_info; + /* * Whether sessiond is ready for commands/health check requests. * NR_LTTNG_SESSIOND_READY must match the number of calls to - * lttng_sessiond_notify_ready(). + * sessiond_notify_ready(). */ -#define NR_LTTNG_SESSIOND_READY 2 +#define NR_LTTNG_SESSIOND_READY 3 int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY; /* Notify parents that we are ready for cmd and health check */ -static -void lttng_sessiond_notify_ready(void) +LTTNG_HIDDEN +void sessiond_notify_ready(void) { if (uatomic_sub_return(<tng_sessiond_ready, 1) == 0) { /* @@ -500,6 +512,27 @@ static void close_consumer_sockets(void) } } +/* + * Generate the full lock file path using the rundir. + * + * Return the snprintf() return value thus a negative value is an error. + */ +static int generate_lock_file_path(char *path, size_t len) +{ + int ret; + + assert(path); + assert(rundir); + + /* Build lockfile path from rundir. */ + ret = snprintf(path, len, "%s/" DEFAULT_LTTNG_SESSIOND_LOCKFILE, rundir); + if (ret < 0) { + PERROR("snprintf lockfile path"); + } + + return ret; +} + /* * Cleanup the daemon */ @@ -581,14 +614,6 @@ static void cleanup(void) DBG("Removing directory %s", path); (void) rmdir(path); - /* - * We do NOT rmdir rundir because there are other processes - * using it, for instance lttng-relayd, which can start in - * parallel with this teardown. - */ - - free(rundir); - DBG("Cleaning up all sessions"); /* Destroy session list mutex */ @@ -644,6 +669,43 @@ static void cleanup(void) free(opt_pidfile); } + if (opt_load_session_path) { + free(opt_load_session_path); + } + + if (load_info) { + load_session_destroy_data(load_info); + free(load_info); + } + + /* + * Cleanup lock file by deleting it and finaly closing it which will + * release the file system lock. + */ + if (lockfile_fd >= 0) { + char lockfile_path[PATH_MAX]; + + ret = generate_lock_file_path(lockfile_path, sizeof(lockfile_path)); + if (ret > 0) { + ret = remove(lockfile_path); + if (ret < 0) { + PERROR("remove lock file"); + } + ret = close(lockfile_fd); + if (ret < 0) { + PERROR("close lock file"); + } + } + } + + /* + * We do NOT rmdir rundir because there are other processes + * using it, for instance lttng-relayd, which can start in + * parallel with this teardown. + */ + + free(rundir); + /* */ DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm" "Matthew, BEET driven development works!%c[%dm", @@ -1051,7 +1113,7 @@ static void signal_consumer_condition(struct consumer_data *data, int state) */ static void *thread_manage_consumer(void *data) { - int sock = -1, i, ret, pollfd, err = -1; + int sock = -1, i, ret, pollfd, err = -1, should_quit = 0; uint32_t revents, nb_fd; enum lttcomm_return_code code; struct lttng_poll_event events; @@ -1209,6 +1271,15 @@ restart: /* Infinite blocking call, waiting for transmission */ restart_poll: while (1) { + health_code_update(); + + /* Exit the thread because the thread quit pipe has been triggered. */ + if (should_quit) { + /* Not a health error. */ + err = 0; + goto exit; + } + health_poll_entry(); ret = lttng_poll_wait(&events, -1); health_poll_exit(); @@ -1231,12 +1302,12 @@ restart_poll: health_code_update(); - /* Thread quit pipe has been closed. Killing thread. */ - ret = sessiond_check_thread_quit_pipe(pollfd, revents); - if (ret) { - err = 0; - goto exit; - } + /* + * Thread quit pipe has been triggered, flag that we should stop + * but continue the current loop to handle potential data from + * consumer. + */ + should_quit = sessiond_check_thread_quit_pipe(pollfd, revents); if (pollfd == sock) { /* Event on the consumerd socket */ @@ -1265,11 +1336,8 @@ restart_poll: ERR("Handling metadata request"); goto error; } - break; - } else { - ERR("Unknown pollfd"); - goto error; } + /* No need for an else branch all FDs are tested prior. */ } health_code_update(); } @@ -2230,9 +2298,12 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) */ if (opt_verbose_consumer) { verbosity = "--verbose"; - } else { + } else if (lttng_opt_quiet) { verbosity = "--quiet"; + } else { + verbosity = ""; } + switch (consumer_data->type) { case LTTNG_CONSUMER_KERNEL: /* @@ -2718,6 +2789,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, case LTTNG_SNAPSHOT_DEL_OUTPUT: case LTTNG_SNAPSHOT_LIST_OUTPUT: case LTTNG_SNAPSHOT_RECORD: + case LTTNG_SAVE_SESSION: need_domain = 0; break; default: @@ -2776,6 +2848,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, case LTTNG_LIST_SESSIONS: case LTTNG_LIST_TRACEPOINTS: case LTTNG_LIST_TRACEPOINT_FIELDS: + case LTTNG_SAVE_SESSION: need_tracing_session = 0; break; default: @@ -2797,6 +2870,38 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, break; } + /* + * Commands that need a valid session but should NOT create one if none + * exists. Instead of creating one and destroying it when the command is + * handled, process that right before so we save some round trip in useless + * code path. + */ + switch (cmd_ctx->lsm->cmd_type) { + case LTTNG_DISABLE_CHANNEL: + case LTTNG_DISABLE_EVENT: + case LTTNG_DISABLE_ALL_EVENT: + switch (cmd_ctx->lsm->domain.type) { + case LTTNG_DOMAIN_KERNEL: + if (!cmd_ctx->session->kernel_session) { + ret = LTTNG_ERR_NO_CHANNEL; + goto error; + } + break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_UST: + if (!cmd_ctx->session->ust_session) { + ret = LTTNG_ERR_NO_CHANNEL; + goto error; + } + break; + default: + ret = LTTNG_ERR_UNKNOWN_DOMAIN; + goto error; + } + default: + break; + } + if (!need_domain) { goto skip_domain; } @@ -2917,6 +3022,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, } /* 32-bit */ + pthread_mutex_lock(&ustconsumer32_data.pid_mutex); if (consumerd32_bin[0] != '\0' && ustconsumer32_data.pid == 0 && cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) { @@ -3103,12 +3209,14 @@ skip_domain: if (bytecode_len > LTTNG_FILTER_MAX_LEN) { ret = LTTNG_ERR_FILTER_INVAL; + free(filter_expression); free(exclusion); goto error; } bytecode = zmalloc(bytecode_len); if (!bytecode) { + free(filter_expression); free(exclusion); ret = LTTNG_ERR_FILTER_NOMEM; goto error; @@ -3120,6 +3228,7 @@ skip_domain: if (ret <= 0) { DBG("Nothing recv() from client car len data... continuing"); *sock_error = 1; + free(filter_expression); free(bytecode); free(exclusion); ret = LTTNG_ERR_FILTER_INVAL; @@ -3127,6 +3236,7 @@ skip_domain: } if ((bytecode->len + sizeof(*bytecode)) != bytecode_len) { + free(filter_expression); free(bytecode); free(exclusion); ret = LTTNG_ERR_FILTER_INVAL; @@ -3156,7 +3266,9 @@ skip_domain: struct lttng_event *events; ssize_t nb_events; + session_lock_list(); nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events); + session_unlock_list(); if (nb_events < 0) { /* Return value is a negative lttng_error_code. */ ret = -nb_events; @@ -3187,8 +3299,10 @@ skip_domain: struct lttng_event_field *fields; ssize_t nb_fields; + session_lock_list(); nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm->domain.type, &fields); + session_unlock_list(); if (nb_fields < 0) { /* Return value is a negative lttng_error_code. */ ret = -nb_fields; @@ -3362,7 +3476,7 @@ skip_domain: case LTTNG_LIST_CHANNELS: { int nb_chan; - struct lttng_channel *channels; + struct lttng_channel *channels = NULL; nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type, cmd_ctx->session, &channels); @@ -3607,6 +3721,12 @@ skip_domain: free(uris); break; } + case LTTNG_SAVE_SESSION: + { + ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr, + &cmd_ctx->creds); + break; + } default: ret = LTTNG_ERR_UND; break; @@ -3705,7 +3825,7 @@ static void *thread_manage_health(void *data) goto error; } - lttng_sessiond_notify_ready(); + sessiond_notify_ready(); while (1) { DBG("Health check ready"); @@ -3857,7 +3977,12 @@ static void *thread_manage_clients(void *data) goto error; } - lttng_sessiond_notify_ready(); + sessiond_notify_ready(); + ret = sem_post(&load_info->message_thread_ready); + if (ret) { + PERROR("sem_post message_thread_ready"); + goto error; + } /* This testpoint is after we signal readiness to the parent. */ if (testpoint(sessiond_thread_manage_clients)) { @@ -4091,7 +4216,9 @@ static void usage(void) fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n"); fprintf(stderr, " --no-kernel Disable kernel tracer\n"); fprintf(stderr, " --jul-tcp-port JUL application registration TCP port\n"); - fprintf(stderr, " -f --config Load daemon configuration file\n"); + fprintf(stderr, " -f --config PATH Load daemon configuration file\n"); + fprintf(stderr, " -l --load PATH Load session configuration\n"); + fprintf(stderr, " --kmod-probes Specify kernel module probes to load\n"); } /* @@ -4124,7 +4251,20 @@ static int set_option(int opt, const char *arg, const char *optname) opt_background = 1; break; case 'g': + /* + * If the override option is set, the pointer points to a + * *non* const thus freeing it even though the variable type is + * set to const. + */ + if (tracing_group_name_override) { + free((void *) tracing_group_name); + } tracing_group_name = strdup(arg); + if (!tracing_group_name) { + perror("strdup"); + ret = -ENOMEM; + } + tracing_group_name_override = 1; break; case 'h': usage(); @@ -4162,10 +4302,15 @@ static int set_option(int opt, const char *arg, const char *optname) case 'v': /* Verbose level can increase using multiple -v */ if (arg) { + /* Value obtained from config file */ lttng_opt_verbose = config_parse_value(arg); } else { - lttng_opt_verbose += 1; + /* -v used on command line */ + lttng_opt_verbose++; } + /* Clamp value to [0, 3] */ + lttng_opt_verbose = lttng_opt_verbose < 0 ? 0 : + (lttng_opt_verbose <= 3 ? lttng_opt_verbose : 3); break; case 'Z': if (arg) { @@ -4175,23 +4320,56 @@ static int set_option(int opt, const char *arg, const char *optname) } break; case 'u': + if (consumerd32_bin_override) { + free((void *) consumerd32_bin); + } consumerd32_bin = strdup(arg); + if (!consumerd32_bin) { + perror("strdup"); + ret = -ENOMEM; + } consumerd32_bin_override = 1; break; case 'U': + if (consumerd32_libdir_override) { + free((void *) consumerd32_libdir); + } consumerd32_libdir = strdup(arg); + if (!consumerd32_libdir) { + perror("strdup"); + ret = -ENOMEM; + } consumerd32_libdir_override = 1; break; case 't': + if (consumerd64_bin_override) { + free((void *) consumerd64_bin); + } consumerd64_bin = strdup(arg); + if (!consumerd64_bin) { + perror("strdup"); + ret = -ENOMEM; + } consumerd64_bin_override = 1; break; case 'T': + if (consumerd64_libdir_override) { + free((void *) consumerd64_libdir); + } consumerd64_libdir = strdup(arg); + if (!consumerd64_libdir) { + perror("strdup"); + ret = -ENOMEM; + } consumerd64_libdir_override = 1; break; case 'p': + free(opt_pidfile); opt_pidfile = strdup(arg); + if (!opt_pidfile) { + perror("strdup"); + ret = -ENOMEM; + } break; case 'J': /* JUL TCP port. */ { @@ -4211,6 +4389,25 @@ static int set_option(int opt, const char *arg, const char *optname) DBG3("JUL TCP port set to non default: %u", jul_tcp_port); break; } + case 'l': + free(opt_load_session_path); + opt_load_session_path = strdup(arg); + if (!opt_load_session_path) { + perror("strdup"); + ret = -ENOMEM; + } + break; + case 'P': /* probe modules list */ + free(kmod_probes_list); + kmod_probes_list = strdup(arg); + if (!kmod_probes_list) { + perror("strdup"); + ret = -ENOMEM; + } + break; + case 'f': + /* This is handled in set_options() thus silent break. */ + break; default: /* Unknown option or other error. * Error is printed by getopt, just return */ @@ -4710,6 +4907,24 @@ error: return; } +/* + * Create lockfile using the rundir and return its fd. + */ +static int create_lockfile(void) +{ + int ret; + char lockfile_path[PATH_MAX]; + + ret = generate_lock_file_path(lockfile_path, sizeof(lockfile_path)); + if (ret < 0) { + goto error; + } + + ret = utils_create_lock_file(lockfile_path); +error: + return ret; +} + /* * Write JUL TCP port using the rundir. */ @@ -4738,6 +4953,35 @@ error: return; } +/* + * Start the load session thread and dettach from it so the main thread can + * continue. This does not return a value since whatever the outcome, the main + * thread will continue. + */ +static void start_load_session_thread(void) +{ + int ret; + + /* Create session loading thread. */ + ret = pthread_create(&load_session_thread, NULL, thread_load_session, + load_info); + if (ret != 0) { + PERROR("pthread_create load_session_thread"); + goto error_create; + } + + ret = pthread_detach(load_session_thread); + if (ret != 0) { + PERROR("pthread_detach load_session_thread"); + } + + /* Everything went well so don't cleanup anything. */ + +error_create: + /* The cleanup() function will destroy the load_info data. */ + return; +} + /* * main */ @@ -4800,6 +5044,10 @@ int main(int argc, char **argv) if (is_root) { rundir = strdup(DEFAULT_LTTNG_RUNDIR); + if (!rundir) { + ret = -ENOMEM; + goto error; + } /* Create global run dir with root access */ ret = create_lttng_rundir(rundir); @@ -4886,6 +5134,11 @@ int main(int argc, char **argv) } } + lockfile_fd = create_lockfile(); + if (lockfile_fd < 0) { + goto error; + } + /* Set consumer initial state */ kernel_consumerd_state = CONSUMER_STOPPED; ust_consumerd_state = CONSUMER_STOPPED; @@ -5047,6 +5300,11 @@ int main(int argc, char **argv) /* This is to get the TCP timeout value. */ lttcomm_inet_init(); + if (load_session_init_data(&load_info) < 0) { + goto exit; + } + load_info->path = opt_load_session_path; + /* * Initialize the health check subsystem. This call should set the * appropriate time values. @@ -5109,7 +5367,7 @@ int main(int argc, char **argv) ret = pthread_create(&apps_notify_thread, NULL, ust_thread_manage_notify, (void *) NULL); if (ret != 0) { - PERROR("pthread_create apps"); + PERROR("pthread_create notify"); goto exit_apps_notify; } @@ -5117,7 +5375,7 @@ int main(int argc, char **argv) ret = pthread_create(&jul_reg_thread, NULL, jul_thread_manage_registration, (void *) NULL); if (ret != 0) { - PERROR("pthread_create apps"); + PERROR("pthread_create JUL"); goto exit_jul_reg; } @@ -5130,7 +5388,12 @@ int main(int argc, char **argv) PERROR("pthread_create kernel"); goto exit_kernel; } + } + /* Load possible session(s). */ + start_load_session_thread(); + + if (is_root && !opt_no_kernel) { ret = pthread_join(kernel_thread, &status); if (ret != 0) { PERROR("pthread_join");