X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fbin%2Flttng-relayd%2Fmain.c;h=fdfe73ccc913ee8e9674f2ac73325f0c0bc22d1c;hb=2a174661a1e0ab551b41ff1cae7191688525fc1f;hp=5782175e6e7f15b57753cc29dedebd54db7a51da;hpb=6b6b9a5a667d6713eb7bcf22daf4f9bbeef00fb1;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c index 5782175e6..fdfe73ccc 100644 --- a/src/bin/lttng-relayd/main.c +++ b/src/bin/lttng-relayd/main.c @@ -1,6 +1,7 @@ /* * Copyright (C) 2012 - Julien Desfossez * David Goulet + * 2013 - Jérémie Galarneau * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2 only, @@ -44,12 +45,14 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include "cmd.h" #include "ctf-trace.h" @@ -58,10 +61,24 @@ #include "lttng-relayd.h" #include "live.h" #include "health-relayd.h" +#include "testpoint.h" +#include "viewer-stream.h" +#include "session.h" +#include "stream.h" /* command line options */ char *opt_output_path; -static int opt_daemon; +static int opt_daemon, opt_background; + +/* + * We need to wait for listener and live listener threads, as well as + * health check thread, before being ready to signal readiness. + */ +#define NR_LTTNG_RELAY_READY 3 +static int lttng_relay_ready = NR_LTTNG_RELAY_READY; +static int recv_child_signal; /* Set to 1 when a SIGUSR1 signal is received. */ +static pid_t child_ppid; /* Internal parent PID use with daemonize. */ + static struct lttng_uri *control_uri; static struct lttng_uri *data_uri; static struct lttng_uri *live_uri; @@ -69,12 +86,15 @@ static struct lttng_uri *live_uri; const char *progname; const char *tracing_group_name = DEFAULT_TRACING_GROUP; +static int tracing_group_name_override; + +const char * const config_section_name = "relayd"; /* * Quit pipe for all threads. This permits a single cancellation point * for all threads when receiving an event on the pipe. */ -static int thread_quit_pipe[2] = { -1, -1 }; +int thread_quit_pipe[2] = { -1, -1 }; /* * This pipe is used to inform the worker thread that a command is queued and @@ -91,7 +111,6 @@ static pthread_t worker_thread; static pthread_t health_thread; static uint64_t last_relay_stream_id; -static uint64_t last_relay_session_id; /* * Relay command queue. @@ -121,6 +140,22 @@ struct lttng_ht *indexes_ht; /* Relayd health monitoring */ struct health_app *health_relayd; +static struct option long_options[] = { + { "control-port", 1, 0, 'C', }, + { "data-port", 1, 0, 'D', }, + { "live-port", 1, 0, 'L', }, + { "daemonize", 0, 0, 'd', }, + { "background", 0, 0, 'b', }, + { "group", 1, 0, 'g', }, + { "help", 0, 0, 'h', }, + { "output", 1, 0, 'o', }, + { "verbose", 0, 0, 'v', }, + { "config", 1, 0, 'f' }, + { NULL, 0, 0, 0, }, +}; + +static const char *config_ignore_options[] = { "help", "config" }; + /* * usage function on stderr */ @@ -130,90 +165,216 @@ void usage(void) fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname); fprintf(stderr, " -h, --help Display this usage.\n"); fprintf(stderr, " -d, --daemonize Start as a daemon.\n"); + fprintf(stderr, " -b, --background Start as a daemon, keeping console open.\n"); fprintf(stderr, " -C, --control-port URL Control port listening.\n"); fprintf(stderr, " -D, --data-port URL Data port listening.\n"); + fprintf(stderr, " -L, --live-port URL Live view port listening.\n"); fprintf(stderr, " -o, --output PATH Output path for traces. Must use an absolute path.\n"); fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n"); fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n"); + fprintf(stderr, " -f --config Load daemon configuration file\n"); } +/* + * Take an option from the getopt output and set it in the right variable to be + * used later. + * + * Return 0 on success else a negative value. + */ static -int parse_args(int argc, char **argv) +int set_option(int opt, const char *arg, const char *optname) { - int c; - int ret = 0; - char *default_address; - - static struct option long_options[] = { - { "control-port", 1, 0, 'C', }, - { "data-port", 1, 0, 'D', }, - { "daemonize", 0, 0, 'd', }, - { "group", 1, 0, 'g', }, - { "help", 0, 0, 'h', }, - { "output", 1, 0, 'o', }, - { "verbose", 0, 0, 'v', }, - { NULL, 0, 0, 0, }, - }; + int ret; + switch (opt) { + case 0: + fprintf(stderr, "option %s", optname); + if (arg) { + fprintf(stderr, " with arg %s\n", arg); + } + break; + case 'C': + ret = uri_parse(arg, &control_uri); + if (ret < 0) { + ERR("Invalid control URI specified"); + goto end; + } + if (control_uri->port == 0) { + control_uri->port = DEFAULT_NETWORK_CONTROL_PORT; + } + break; + case 'D': + ret = uri_parse(arg, &data_uri); + if (ret < 0) { + ERR("Invalid data URI specified"); + goto end; + } + if (data_uri->port == 0) { + data_uri->port = DEFAULT_NETWORK_DATA_PORT; + } + break; + case 'L': + ret = uri_parse(arg, &live_uri); + if (ret < 0) { + ERR("Invalid live URI specified"); + goto end; + } + if (live_uri->port == 0) { + live_uri->port = DEFAULT_NETWORK_VIEWER_PORT; + } + break; + case 'd': + opt_daemon = 1; + break; + case 'b': + opt_background = 1; + break; + case 'g': + tracing_group_name = strdup(arg); + tracing_group_name_override = 1; + break; + case 'h': + usage(); + exit(EXIT_FAILURE); + case 'o': + ret = asprintf(&opt_output_path, "%s", arg); + if (ret < 0) { + ret = -errno; + PERROR("asprintf opt_output_path"); + goto end; + } + break; + case 'v': + /* Verbose level can increase using multiple -v */ + if (arg) { + lttng_opt_verbose = config_parse_value(arg); + } else { + lttng_opt_verbose += 1; + } + break; + default: + /* Unknown option or other error. + * Error is printed by getopt, just return */ + ret = -1; + goto end; + } + + /* All good. */ + ret = 0; + +end: + return ret; +} + +/* + * config_entry_handler_cb used to handle options read from a config file. + * See config_entry_handler_cb comment in common/config/config.h for the + * return value conventions. + */ +static +int config_entry_handler(const struct config_entry *entry, void *unused) +{ + int ret = 0, i; + + if (!entry || !entry->name || !entry->value) { + ret = -EINVAL; + goto end; + } + + /* Check if the option is to be ignored */ + for (i = 0; i < sizeof(config_ignore_options) / sizeof(char *); i++) { + if (!strcmp(entry->name, config_ignore_options[i])) { + goto end; + } + } + + for (i = 0; i < (sizeof(long_options) / sizeof(struct option)) - 1; i++) { + /* Ignore if entry name is not fully matched. */ + if (strcmp(entry->name, long_options[i].name)) { + continue; + } + + /* + * If the option takes no argument on the command line, we have to + * check if the value is "true". We support non-zero numeric values, + * true, on and yes. + */ + if (!long_options[i].has_arg) { + ret = config_parse_value(entry->value); + if (ret <= 0) { + if (ret) { + WARN("Invalid configuration value \"%s\" for option %s", + entry->value, entry->name); + } + /* False, skip boolean config option. */ + goto end; + } + } + + ret = set_option(long_options[i].val, entry->value, entry->name); + goto end; + } + + WARN("Unrecognized option \"%s\" in daemon configuration file.", + entry->name); + +end: + return ret; +} + +static +int set_options(int argc, char **argv) +{ + int c, ret = 0, option_index = 0; + int orig_optopt = optopt, orig_optind = optind; + char *default_address, *optstring; + const char *config_path = NULL; + + optstring = utils_generate_optstring(long_options, + sizeof(long_options) / sizeof(struct option)); + if (!optstring) { + ret = -ENOMEM; + goto exit; + } + + /* Check for the --config option */ + + while ((c = getopt_long(argc, argv, optstring, long_options, + &option_index)) != -1) { + if (c == '?') { + ret = -EINVAL; + goto exit; + } else if (c != 'f') { + continue; + } + + config_path = utils_expand_path(optarg); + if (!config_path) { + ERR("Failed to resolve path: %s", optarg); + } + } + + ret = config_get_section_entries(config_path, config_section_name, + config_entry_handler, NULL); + if (ret) { + if (ret > 0) { + ERR("Invalid configuration option at line %i", ret); + ret = -1; + } + goto exit; + } + + /* Reset getopt's global state */ + optopt = orig_optopt; + optind = orig_optind; while (1) { - int option_index = 0; - c = getopt_long(argc, argv, "dhv" "C:D:o:g:", - long_options, &option_index); + c = getopt_long(argc, argv, optstring, long_options, &option_index); if (c == -1) { break; } - switch (c) { - case 0: - fprintf(stderr, "option %s", long_options[option_index].name); - if (optarg) { - fprintf(stderr, " with arg %s\n", optarg); - } - break; - case 'C': - ret = uri_parse(optarg, &control_uri); - if (ret < 0) { - ERR("Invalid control URI specified"); - goto exit; - } - if (control_uri->port == 0) { - control_uri->port = DEFAULT_NETWORK_CONTROL_PORT; - } - break; - case 'D': - ret = uri_parse(optarg, &data_uri); - if (ret < 0) { - ERR("Invalid data URI specified"); - goto exit; - } - if (data_uri->port == 0) { - data_uri->port = DEFAULT_NETWORK_DATA_PORT; - } - break; - case 'd': - opt_daemon = 1; - break; - case 'g': - tracing_group_name = optarg; - break; - case 'h': - usage(); - exit(EXIT_FAILURE); - case 'o': - ret = asprintf(&opt_output_path, "%s", optarg); - if (ret < 0) { - PERROR("asprintf opt_output_path"); - goto exit; - } - break; - case 'v': - /* Verbose level can increase using multiple -v */ - lttng_opt_verbose += 1; - break; - default: - /* Unknown option or other error. - * Error is printed by getopt, just return */ - ret = -1; + ret = set_option(c, optarg, long_options[option_index].name); + if (ret < 0) { goto exit; } } @@ -266,6 +427,7 @@ int parse_args(int argc, char **argv) } exit: + free(optstring); return ret; } @@ -285,6 +447,11 @@ void cleanup(void) uri_free(control_uri); uri_free(data_uri); + /* Live URI is freed in the live thread. */ + + if (tracing_group_name_override) { + free((void *) tracing_group_name); + } } /* @@ -356,6 +523,9 @@ void sighandler(int sig) DBG("SIGTERM caught"); stop_threads(); break; + case SIGUSR1: + CMM_STORE_SHARED(recv_child_signal, 1); + break; default: break; } @@ -395,11 +565,26 @@ int set_signal_handler(void) return ret; } - DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT"); + if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) { + PERROR("sigaction"); + return ret; + } + + DBG("Signal handler set for SIGTERM, SIGUSR1, SIGPIPE and SIGINT"); return ret; } +void lttng_relay_notify_ready(void) +{ + /* Notify the parent of the fork() process that we are ready. */ + if (opt_daemon || opt_background) { + if (uatomic_sub_return(<tng_relay_ready, 1) == 0) { + kill(child_ppid, SIGUSR1); + } + } +} + /* * Init thread quit pipe. * @@ -434,7 +619,7 @@ int create_thread_poll_set(struct lttng_poll_event *events, int size) } /* Add quit pipe */ - ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN); + ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN | LPOLLERR); if (ret < 0) { goto error; } @@ -507,7 +692,6 @@ error: static int close_stream_check(struct relay_stream *stream) { - if (stream->close_flag && stream->prev_seq == stream->last_net_seq_num) { /* * We are about to close the stream so set the data pending flag to 1 @@ -521,6 +705,40 @@ int close_stream_check(struct relay_stream *stream) return 0; } +static void try_close_stream(struct relay_session *session, + struct relay_stream *stream) +{ + int ret; + struct ctf_trace *ctf_trace; + + assert(session); + assert(stream); + + if (!close_stream_check(stream)) { + /* Can't close it, not ready for that. */ + goto end; + } + + ctf_trace = ctf_trace_find_by_path(session->ctf_traces_ht, + stream->path_name); + assert(ctf_trace); + + pthread_mutex_lock(&session->viewer_ready_lock); + ctf_trace->invalid_flag = 1; + pthread_mutex_unlock(&session->viewer_ready_lock); + + ret = stream_close(session, stream); + if (!ret) { + /* Already close thus the ctf trace is being or has been destroyed. */ + goto end; + } + + ctf_trace_try_destroy(session, ctf_trace); + +end: + return; +} + /* * This thread manages the listening for new connections on the network */ @@ -569,6 +787,12 @@ void *relay_thread_listener(void *data) goto error_poll_add; } + lttng_relay_notify_ready(); + + if (testpoint(relayd_thread_listener)) { + goto error_testpoint; + } + while (1) { health_code_update(); @@ -669,6 +893,7 @@ restart: exit: error: error_poll_add: +error_testpoint: lttng_poll_clean(&events); error_create_poll: if (data_sock->fd >= 0) { @@ -712,6 +937,10 @@ void *relay_thread_dispatcher(void *data) health_register(health_relayd, HEALTH_RELAYD_TYPE_DISPATCHER); + if (testpoint(relayd_thread_dispatcher)) { + goto error_testpoint; + } + health_code_update(); while (!CMM_LOAD_SHARED(dispatch_thread_exit)) { @@ -758,6 +987,7 @@ void *relay_thread_dispatcher(void *data) err = 0; error: +error_testpoint: if (err) { health_error(); ERR("Health error occurred in %s", __func__); @@ -768,142 +998,51 @@ error: return NULL; } -/* - * Get stream from stream id. - * Need to be called with RCU read-side lock held. - */ -struct relay_stream *relay_stream_find_by_id(uint64_t stream_id) +static void try_close_streams(struct relay_session *session) { - struct lttng_ht_node_ulong *node; + struct ctf_trace *ctf_trace; struct lttng_ht_iter iter; - struct relay_stream *ret; - - lttng_ht_lookup(relay_streams_ht, - (void *)((unsigned long) stream_id), - &iter); - node = lttng_ht_iter_get_node_ulong(&iter); - if (node == NULL) { - DBG("Relay stream %" PRIu64 " not found", stream_id); - ret = NULL; - goto end; - } - ret = caa_container_of(node, struct relay_stream, stream_n); + assert(session); -end: - return ret; -} - -static -void deferred_free_stream(struct rcu_head *head) -{ - struct relay_stream *stream = - caa_container_of(head, struct relay_stream, rcu_node); - - ctf_trace_try_destroy(stream->ctf_trace); - - free(stream->path_name); - free(stream->channel_name); - free(stream); -} - -static -void deferred_free_session(struct rcu_head *head) -{ - struct relay_session *session = - caa_container_of(head, struct relay_session, rcu_node); - free(session); -} - -/* - * Close a given stream. The stream is freed using a call RCU. - * - * RCU read side lock MUST be acquired. If NO close_stream_check() was called - * BEFORE the stream lock MUST be acquired. - */ -static void destroy_stream(struct relay_stream *stream) -{ - int delret; - struct relay_viewer_stream *vstream; - struct lttng_ht_iter iter; - - assert(stream); - - delret = close(stream->fd); - if (delret < 0) { - PERROR("close stream"); - } + pthread_mutex_lock(&session->viewer_ready_lock); + rcu_read_lock(); + cds_lfht_for_each_entry(session->ctf_traces_ht->ht, &iter.iter, ctf_trace, + node.node) { + struct relay_stream *stream; - if (stream->index_fd >= 0) { - delret = close(stream->index_fd); - if (delret < 0) { - PERROR("close stream index_fd"); + /* Close streams. */ + cds_list_for_each_entry(stream, &ctf_trace->stream_list, trace_list) { + stream_close(session, stream); } - } - vstream = live_find_viewer_stream_by_id(stream->stream_handle); - if (vstream) { - /* - * Set the last good value into the viewer stream. This is done - * right before the stream gets deleted from the hash table. The - * lookup failure on the live thread side of a stream indicates - * that the viewer stream index received value should be used. - */ - vstream->total_index_received = stream->total_index_received; + ctf_trace->invalid_flag = 1; + ctf_trace_try_destroy(session, ctf_trace); } - - /* Cleanup index of that stream. */ - relay_index_destroy_by_stream_id(stream->stream_handle); - - iter.iter.node = &stream->stream_n.node; - delret = lttng_ht_del(relay_streams_ht, &iter); - assert(!delret); - iter.iter.node = &stream->ctf_trace_node.node; - delret = lttng_ht_del(stream->ctf_traces_ht, &iter); - assert(!delret); - call_rcu(&stream->rcu_node, deferred_free_stream); - DBG("Closed tracefile %d from close stream", stream->fd); + rcu_read_unlock(); + pthread_mutex_unlock(&session->viewer_ready_lock); } /* - * relay_delete_session: Free all memory associated with a session and - * close all the FDs + * Try to destroy a session within a connection. */ static void relay_delete_session(struct relay_command *cmd, struct lttng_ht *sessions_ht) { - struct lttng_ht_iter iter; - struct lttng_ht_node_ulong *node; - struct relay_stream *stream; - int ret; - - if (!cmd->session) { - return; - } + assert(cmd); + assert(sessions_ht); - DBG("Relay deleting session %" PRIu64, cmd->session->id); + /* Indicate that this session can be destroyed from now on. */ + cmd->session->close_flag = 1; - rcu_read_lock(); - cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, node, node) { - node = lttng_ht_iter_get_node_ulong(&iter); - if (!node) { - continue; - } - stream = caa_container_of(node, struct relay_stream, stream_n); - if (stream->session == cmd->session) { - destroy_stream(stream); - cmd->session->stream_count--; - assert(cmd->session->stream_count >= 0); - } - } + try_close_streams(cmd->session); - /* Make this session not visible anymore. */ - iter.iter.node = &cmd->session->session_n.node; - ret = lttng_ht_del(sessions_ht, &iter); - assert(!ret); - call_rcu(&cmd->session->rcu_node, deferred_free_session); - rcu_read_unlock(); + /* + * This will try to delete and destroy the session if no viewer is attached + * to it meaning the refcount is down to zero. + */ + session_try_destroy(sessions_ht, cmd->session); } /* @@ -947,33 +1086,30 @@ int relay_create_session(struct lttcomm_relayd_hdr *recv_hdr, memset(&reply, 0, sizeof(reply)); - session = zmalloc(sizeof(struct relay_session)); - if (session == NULL) { - PERROR("relay session zmalloc"); + session = session_create(); + if (!session) { ret = -1; goto error; } - - session->id = ++last_relay_session_id; - session->sock = cmd->sock; session->minor = cmd->minor; session->major = cmd->major; + cmd->session_id = session->id; cmd->session = session; reply.session_id = htobe64(session->id); switch (cmd->minor) { - case 4: /* LTTng sessiond 2.4 */ - default: - ret = cmd_create_session_2_4(cmd, session); - break; + case 1: + case 2: + case 3: + break; + case 4: /* LTTng sessiond 2.4 */ + default: + ret = cmd_create_session_2_4(cmd, session); + break; } - lttng_ht_node_init_ulong(&session->session_n, - (unsigned long) session->id); - lttng_ht_add_unique_ulong(sessions_ht, - &session->session_n); - + lttng_ht_add_unique_u64(sessions_ht, &session->session_n); DBG("Created session %" PRIu64, session->id); error: @@ -992,6 +1128,38 @@ error: return ret; } +/* + * When we have received all the streams and the metadata for a channel, + * we make them visible to the viewer threads. + */ +static +void set_viewer_ready_flag(struct relay_command *cmd) +{ + struct relay_stream *stream, *tmp_stream; + + pthread_mutex_lock(&cmd->session->viewer_ready_lock); + cds_list_for_each_entry_safe(stream, tmp_stream, &cmd->recv_head, + recv_list) { + stream->viewer_ready = 1; + cds_list_del(&stream->recv_list); + } + pthread_mutex_unlock(&cmd->session->viewer_ready_lock); + return; +} + +/* + * Add a recv handle node to the connection recv list with the given stream + * handle. A new node is allocated thus must be freed when the node is deleted + * from the list. + */ +static void queue_stream(struct relay_stream *stream, struct relay_command *cmd) +{ + assert(cmd); + assert(stream); + + cds_list_add(&stream->recv_list, &cmd->recv_head); +} + /* * relay_add_stream: allocate a new stream for a session */ @@ -999,10 +1167,11 @@ static int relay_add_stream(struct lttcomm_relayd_hdr *recv_hdr, struct relay_command *cmd, struct lttng_ht *sessions_ht) { + int ret, send_ret; struct relay_session *session = cmd->session; struct relay_stream *stream = NULL; struct lttcomm_relayd_status_stream reply; - int ret, send_ret; + struct ctf_trace *trace; if (!session || cmd->version_check_done == 0) { ERR("Trying to add a stream before version check"); @@ -1033,10 +1202,10 @@ int relay_add_stream(struct lttcomm_relayd_hdr *recv_hdr, rcu_read_lock(); stream->stream_handle = ++last_relay_stream_id; stream->prev_seq = -1ULL; - stream->session = session; + stream->session_id = session->id; stream->index_fd = -1; stream->read_index_fd = -1; - stream->ctf_trace = NULL; + lttng_ht_node_init_u64(&stream->node, stream->stream_handle); pthread_mutex_init(&stream->lock, NULL); ret = utils_mkdir_recursive(stream->path_name, S_IRWXU | S_IRWXG); @@ -1062,35 +1231,37 @@ int relay_add_stream(struct lttcomm_relayd_hdr *recv_hdr, DBG("Tracefile %s/%s created", stream->path_name, stream->channel_name); } - if (!strncmp(stream->channel_name, DEFAULT_METADATA_NAME, NAME_MAX)) { - stream->metadata_flag = 1; - /* - * When we receive a new metadata stream, we create a new - * ctf_trace and we assign this ctf_trace to all streams with - * the same path. - * - * If later on we receive a new stream for the same ctf_trace, - * we copy the information from the first hit in the HT to the - * new stream. - */ - stream->ctf_trace = ctf_trace_create(); - if (!stream->ctf_trace) { + trace = ctf_trace_find_by_path(session->ctf_traces_ht, stream->path_name); + if (!trace) { + trace = ctf_trace_create(stream->path_name); + if (!trace) { ret = -1; goto end; } - stream->ctf_trace->refcount++; - stream->ctf_trace->metadata_stream = stream; + ctf_trace_add(session->ctf_traces_ht, trace); + } + ctf_trace_get_ref(trace); + + if (!strncmp(stream->channel_name, DEFAULT_METADATA_NAME, NAME_MAX)) { + stream->metadata_flag = 1; + /* Assign quick reference to the metadata stream in the trace. */ + trace->metadata_stream = stream; } - ctf_trace_assign(cmd->ctf_traces_ht, stream); - stream->ctf_traces_ht = cmd->ctf_traces_ht; - lttng_ht_node_init_ulong(&stream->stream_n, - (unsigned long) stream->stream_handle); - lttng_ht_add_unique_ulong(relay_streams_ht, - &stream->stream_n); + /* + * Add the stream in the recv list of the connection. Once the end stream + * message is received, this list is emptied and streams are set with the + * viewer ready flag. + */ + queue_stream(stream, cmd); + + /* + * Both in the ctf_trace object and the global stream ht since the data + * side of the relayd does not have the concept of session. + */ + lttng_ht_add_unique_u64(relay_streams_ht, &stream->node); + cds_list_add_tail(&stream->trace_list, &trace->stream_list); - lttng_ht_node_init_str(&stream->ctf_trace_node, stream->path_name); - lttng_ht_add_str(cmd->ctf_traces_ht, &stream->ctf_trace_node); session->stream_count++; DBG("Relay new stream added %s with ID %" PRIu64, stream->channel_name, @@ -1160,7 +1331,8 @@ int relay_close_stream(struct lttcomm_relayd_hdr *recv_hdr, } rcu_read_lock(); - stream = relay_stream_find_by_id(be64toh(stream_info.stream_id)); + stream = stream_find_by_id(relay_streams_ht, + be64toh(stream_info.stream_id)); if (!stream) { ret = -1; goto end_unlock; @@ -1171,9 +1343,8 @@ int relay_close_stream(struct lttcomm_relayd_hdr *recv_hdr, session->stream_count--; assert(session->stream_count >= 0); - if (close_stream_check(stream)) { - destroy_stream(stream); - } + /* Check if we can close it or else the data will do it. */ + try_close_stream(session, stream); end_unlock: rcu_read_unlock(); @@ -1281,6 +1452,7 @@ int relay_recv_metadata(struct lttcomm_relayd_hdr *recv_hdr, struct lttcomm_relayd_metadata_payload *metadata_struct; struct relay_stream *metadata_stream; uint64_t data_size, payload_size; + struct ctf_trace *ctf_trace; if (!session) { ERR("Metadata sent before version check"); @@ -1326,7 +1498,7 @@ int relay_recv_metadata(struct lttcomm_relayd_hdr *recv_hdr, metadata_struct = (struct lttcomm_relayd_metadata_payload *) data_buffer; rcu_read_lock(); - metadata_stream = relay_stream_find_by_id( + metadata_stream = stream_find_by_id(relay_streams_ht, be64toh(metadata_struct->stream_id)); if (!metadata_stream) { ret = -1; @@ -1346,7 +1518,11 @@ int relay_recv_metadata(struct lttcomm_relayd_hdr *recv_hdr, if (ret < 0) { goto end_unlock; } - metadata_stream->ctf_trace->metadata_received += + + ctf_trace = ctf_trace_find_by_path(session->ctf_traces_ht, + metadata_stream->path_name); + assert(ctf_trace); + ctf_trace->metadata_received += payload_size + be32toh(metadata_struct->padding_size); DBG2("Relay metadata written"); @@ -1458,7 +1634,7 @@ int relay_data_pending(struct lttcomm_relayd_hdr *recv_hdr, last_net_seq_num = be64toh(msg.last_net_seq_num); rcu_read_lock(); - stream = relay_stream_find_by_id(stream_id); + stream = stream_find_by_id(relay_streams_ht, stream_id); if (stream == NULL) { ret = -1; goto end_unlock; @@ -1536,7 +1712,7 @@ int relay_quiescent_control(struct lttcomm_relayd_hdr *recv_hdr, rcu_read_lock(); cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, stream, - stream_n.node) { + node.node) { if (stream->stream_handle == stream_id) { stream->data_pending_check_done = 1; DBG("Relay quiescent control pending flag set to %" PRIu64, @@ -1607,8 +1783,8 @@ int relay_begin_data_pending(struct lttcomm_relayd_hdr *recv_hdr, */ rcu_read_lock(); cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, stream, - stream_n.node) { - if (stream->session->id == session_id) { + node.node) { + if (stream->session_id == session_id) { stream->data_pending_check_done = 0; DBG("Set begin data pending flag to stream %" PRIu64, stream->stream_handle); @@ -1678,8 +1854,8 @@ int relay_end_data_pending(struct lttcomm_relayd_hdr *recv_hdr, /* Iterate over all streams to see if the begin data pending flag is set. */ rcu_read_lock(); cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, stream, - stream_n.node) { - if (stream->session->id == session_id && + node.node) { + if (stream->session_id == session_id && !stream->data_pending_check_done) { is_data_inflight = 1; DBG("Data is still in flight for stream %" PRIu64, @@ -1744,7 +1920,8 @@ int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, net_seq_num = be64toh(index_info.net_seq_num); rcu_read_lock(); - stream = relay_stream_find_by_id(be64toh(index_info.relay_stream_id)); + stream = stream_find_by_id(relay_streams_ht, + be64toh(index_info.relay_stream_id)); if (!stream) { ret = -1; goto end_rcu_unlock; @@ -1832,6 +2009,53 @@ end_no_session: return ret; } +/* + * Receive the streams_sent message. + * + * Return 0 on success else a negative value. + */ +static +int relay_streams_sent(struct lttcomm_relayd_hdr *recv_hdr, + struct relay_command *cmd) +{ + int ret, send_ret; + struct lttcomm_relayd_generic_reply reply; + + assert(cmd); + + DBG("Relay receiving streams_sent"); + + if (!cmd->session || cmd->version_check_done == 0) { + ERR("Trying to close a stream before version check"); + ret = -1; + goto end_no_session; + } + + /* + * Flag every pending stream in the connection recv list that they are + * ready to be used by the viewer. + */ + set_viewer_ready_flag(cmd); + + /* + * Inform the viewer that there are new streams in the session. + */ + uatomic_set(&cmd->session->new_streams, 1); + + reply.ret_code = htobe32(LTTNG_OK); + send_ret = cmd->sock->ops->sendmsg(cmd->sock, &reply, sizeof(reply), 0); + if (send_ret < 0) { + ERR("Relay sending sent_stream reply"); + ret = send_ret; + } else { + /* Success. */ + ret = 0; + } + +end_no_session: + return ret; +} + /* * Process the commands received on the control socket */ @@ -1875,6 +2099,9 @@ int relay_process_control(struct lttcomm_relayd_hdr *recv_hdr, case RELAYD_SEND_INDEX: ret = relay_recv_index(recv_hdr, cmd); break; + case RELAYD_STREAMS_SENT: + ret = relay_streams_sent(recv_hdr, cmd); + break; case RELAYD_UPDATE_SYNC_INFO: default: ERR("Received unknown command (%u)", be32toh(recv_hdr->cmd)); @@ -1973,7 +2200,7 @@ error: * relay_process_data: Process the data received on the data socket */ static -int relay_process_data(struct relay_command *cmd) +int relay_process_data(struct relay_command *cmd, struct lttng_ht *sessions_ht) { int ret = 0, rotate_index = 0; ssize_t size_ret; @@ -1982,6 +2209,7 @@ int relay_process_data(struct relay_command *cmd) uint64_t stream_id; uint64_t net_seq_num; uint32_t data_size; + struct relay_session *session; ret = cmd->sock->ops->recvmsg(cmd->sock, &data_hdr, sizeof(struct lttcomm_relayd_data_hdr), 0); @@ -1999,12 +2227,15 @@ int relay_process_data(struct relay_command *cmd) stream_id = be64toh(data_hdr.stream_id); rcu_read_lock(); - stream = relay_stream_find_by_id(stream_id); + stream = stream_find_by_id(relay_streams_ht, stream_id); if (!stream) { ret = -1; goto end_rcu_unlock; } + session = session_find_by_id(sessions_ht, stream->session_id); + assert(session); + data_size = be32toh(data_hdr.data_size); if (data_buffer_size < data_size) { char *tmp_data_ptr; @@ -2057,7 +2288,7 @@ int relay_process_data(struct relay_command *cmd) (stream->oldest_tracefile_id + 1) % stream->tracefile_count; } - vstream = live_find_viewer_stream_by_id(stream->stream_handle); + vstream = viewer_stream_find_by_id(stream->stream_handle); if (vstream) { /* * The viewer is reading a file about to be @@ -2065,18 +2296,9 @@ int relay_process_data(struct relay_command *cmd) * currently using and let it handle the fault. */ if (vstream->tracefile_count_current == new_id) { + pthread_mutex_lock(&vstream->overwrite_lock); vstream->abort_flag = 1; - vstream->close_write_flag = 1; - - ret = close(vstream->read_fd); - if (ret < 0) { - PERROR("close index"); - } - - ret = close(vstream->index_read_fd); - if (ret < 0) { - PERROR("close tracefile"); - } + pthread_mutex_unlock(&vstream->overwrite_lock); DBG("Streaming side setting abort_flag on stream %s_%lu\n", stream->channel_name, new_id); } else if (vstream->tracefile_count_current == @@ -2094,6 +2316,7 @@ int relay_process_data(struct relay_command *cmd) stream->tracefile_size, stream->tracefile_count, relayd_uid, relayd_gid, stream->fd, &(stream->tracefile_count_current), &stream->fd); + stream->total_index_received = 0; pthread_mutex_unlock(&stream->viewer_stream_rotation_lock); if (ret < 0) { ERR("Rotating stream output file"); @@ -2108,7 +2331,7 @@ int relay_process_data(struct relay_command *cmd) * Index are handled in protocol version 2.4 and above. Also, snapshot and * index are NOT supported. */ - if (stream->session->minor >= 4 && !stream->session->snapshot) { + if (session->minor >= 4 && !session->snapshot) { ret = handle_index_data(stream, net_seq_num, rotate_index); if (ret < 0) { goto end_rcu_unlock; @@ -2134,10 +2357,7 @@ int relay_process_data(struct relay_command *cmd) stream->prev_seq = net_seq_num; - /* Check if we need to close the FD */ - if (close_stream_check(stream)) { - destroy_stream(stream); - } + try_close_stream(session, stream); end_rcu_unlock: rcu_read_unlock(); @@ -2175,19 +2395,7 @@ int relay_add_connection(int fd, struct lttng_poll_event *events, PERROR("read relay cmd pipe"); goto error_read; } - - /* - * Only used by the control side and the reference is copied inside each - * stream from that connection. Thus a destroy HT must be done after every - * stream has been destroyed. - */ - if (relay_connection->type == RELAY_CONTROL) { - relay_connection->ctf_traces_ht = lttng_ht_new(0, - LTTNG_HT_TYPE_STRING); - if (!relay_connection->ctf_traces_ht) { - goto error_read; - } - } + CDS_INIT_LIST_HEAD(&relay_connection->recv_head); lttng_ht_node_init_ulong(&relay_connection->sock_n, (unsigned long) relay_connection->sock->fd); @@ -2226,8 +2434,16 @@ void relay_del_connection(struct lttng_ht *relay_connections_ht, assert(!ret); if (relay_connection->type == RELAY_CONTROL) { + struct relay_stream *stream, *tmp_stream; + + /* Clean up recv list. */ + cds_list_for_each_entry_safe(stream, tmp_stream, + &relay_connection->recv_head, recv_list) { + cds_list_del(&stream->recv_list); + } + relay_delete_session(relay_connection, sessions_ht); - lttng_ht_destroy(relay_connection->ctf_traces_ht); + } call_rcu(&relay_connection->rcu_node, deferred_free_connection); @@ -2256,6 +2472,10 @@ void *relay_thread_worker(void *data) health_register(health_relayd, HEALTH_RELAYD_TYPE_WORKER); + if (testpoint(relayd_thread_worker)) { + goto error_testpoint; + } + health_code_update(); /* table of connections indexed on socket */ @@ -2459,7 +2679,8 @@ restart: continue; } - ret = relay_process_data(relay_connection); + ret = relay_process_data(relay_connection, + sessions_ht); /* connection closed */ if (ret < 0) { relay_cleanup_poll_connection(&events, pollfd); @@ -2517,6 +2738,7 @@ relay_connections_ht_error: } DBG("Worker thread cleanup complete"); free(data_buffer); +error_testpoint: if (err) { health_error(); ERR("Health error occurred in %s", __func__); @@ -2549,14 +2771,9 @@ int main(int argc, char **argv) void *status; struct relay_local_data *relay_ctx; - /* Create thread quit pipe */ - if ((ret = init_thread_quit_pipe()) < 0) { - goto error; - } - /* Parse arguments */ progname = argv[0]; - if ((ret = parse_args(argc, argv)) < 0) { + if ((ret = set_options(argc, argv)) < 0) { goto exit; } @@ -2579,12 +2796,28 @@ int main(int argc, char **argv) } /* Daemonize */ - if (opt_daemon) { - ret = daemon(0, 0); + if (opt_daemon || opt_background) { + int i; + + ret = lttng_daemonize(&child_ppid, &recv_child_signal, + !opt_background); if (ret < 0) { - PERROR("daemon"); goto exit; } + + /* + * We are in the child. Make sure all other file + * descriptors are closed, in case we are called with + * more opened file descriptors than the standard ones. + */ + for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) { + (void) close(i); + } + } + + /* Create thread quit pipe */ + if ((ret = init_thread_quit_pipe()) < 0) { + goto error; } /* We need those values for the file/dir creation. */ @@ -2593,7 +2826,7 @@ int main(int argc, char **argv) /* Check if daemon is UID = 0 */ if (relayd_uid == 0) { - if (control_uri->port < 1024 || data_uri->port < 1024) { + if (control_uri->port < 1024 || data_uri->port < 1024 || live_uri->port < 1024) { ERR("Need to be root to use ports < 1024"); ret = -1; goto exit; @@ -2613,6 +2846,7 @@ int main(int argc, char **argv) /* Initialize communication library */ lttcomm_init(); + lttcomm_inet_init(); relay_ctx = zmalloc(sizeof(struct relay_local_data)); if (!relay_ctx) { @@ -2621,13 +2855,13 @@ int main(int argc, char **argv) } /* tables of sessions indexed by session ID */ - relay_ctx->sessions_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + relay_ctx->sessions_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!relay_ctx->sessions_ht) { goto exit_relay_ctx_sessions; } /* tables of streams indexed by stream ID */ - relay_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + relay_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!relay_streams_ht) { goto exit_relay_ctx_streams; } @@ -2682,7 +2916,7 @@ int main(int argc, char **argv) goto exit_listener; } - ret = live_start_threads(live_uri, relay_ctx, thread_quit_pipe); + ret = live_start_threads(live_uri, relay_ctx); if (ret != 0) { ERR("Starting live viewer threads"); goto exit_live;