X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=4b8d82efe255d398d9e5eba605be42d96cec5421;hp=6f7c71d0549474746ef78243f3204cd9ba014ab2;hb=6b453b5e07e90591c955ae14c60c13b7c1ed28a0;hpb=6dc3064a30b0cc7cfa9fdd22da1963525dfb7388 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 6f7c71d05..4b8d82efe 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -25,11 +25,12 @@ #include #include #include +#include #include "channel.h" #include "consumer.h" #include "event.h" -#include "health.h" +#include "health-sessiond.h" #include "kernel.h" #include "kernel-consumer.h" #include "lttng-sessiond.h" @@ -181,6 +182,55 @@ static void list_lttng_channels(int domain, struct ltt_session *session, } } +/* + * Create a list of JUL domain events. + * + * Return number of events in list on success or else a negative value. + */ +static int list_lttng_jul_events(struct jul_domain *dom, + struct lttng_event **events) +{ + int i = 0, ret = 0; + unsigned int nb_event = 0; + struct jul_event *event; + struct lttng_event *tmp_events; + struct lttng_ht_iter iter; + + assert(dom); + assert(events); + + DBG3("Listing JUL events"); + + nb_event = lttng_ht_get_count(dom->events); + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + tmp_events = zmalloc(nb_event * sizeof(*tmp_events)); + if (!tmp_events) { + PERROR("zmalloc JUL events session"); + ret = -LTTNG_ERR_FATAL; + goto error; + } + + rcu_read_lock(); + cds_lfht_for_each_entry(dom->events->ht, &iter.iter, event, node.node) { + strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name)); + tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0'; + tmp_events[i].enabled = event->enabled; + i++; + } + rcu_read_unlock(); + + *events = tmp_events; + ret = nb_event; + +error: + assert(nb_event == i); + return ret; +} + /* * Create a list of ust global domain events. */ @@ -255,6 +305,9 @@ static int list_lttng_ust_global_events(char *channel_name, if (uevent->filter) { tmp[i].filter = 1; } + if (uevent->exclusion) { + tmp[i].exclusion = 1; + } i++; } @@ -461,9 +514,6 @@ static int init_kernel_tracing(struct ltt_kernel_session *session) if (session->consumer_fds_sent == 0 && session->consumer != NULL) { cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter, socket, node.node) { - /* Code flow error */ - assert(socket->fd >= 0); - pthread_mutex_lock(socket->lock); ret = kernel_consumer_send_session(socket, session); pthread_mutex_unlock(socket->lock); @@ -549,7 +599,8 @@ error: */ static int send_consumer_relayd_socket(int domain, unsigned int session_id, struct lttng_uri *relayd_uri, struct consumer_output *consumer, - struct consumer_socket *consumer_sock) + struct consumer_socket *consumer_sock, + char *session_name, char *hostname, int session_live_timer) { int ret; struct lttcomm_relayd_sock *rsock = NULL; @@ -575,7 +626,8 @@ static int send_consumer_relayd_socket(int domain, unsigned int session_id, /* Send relayd socket to consumer. */ ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer, - relayd_uri->stype, session_id); + relayd_uri->stype, session_id, + session_name, hostname, session_live_timer); if (ret < 0) { ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL; goto close_sock; @@ -617,7 +669,8 @@ error: * session. */ static int send_consumer_relayd_sockets(int domain, unsigned int session_id, - struct consumer_output *consumer, struct consumer_socket *sock) + struct consumer_output *consumer, struct consumer_socket *sock, + char *session_name, char *hostname, int session_live_timer) { int ret = LTTNG_OK; @@ -627,7 +680,8 @@ static int send_consumer_relayd_sockets(int domain, unsigned int session_id, /* Sending control relayd socket. */ if (!sock->control_sock_sent) { ret = send_consumer_relayd_socket(domain, session_id, - &consumer->dst.net.control, consumer, sock); + &consumer->dst.net.control, consumer, sock, + session_name, hostname, session_live_timer); if (ret != LTTNG_OK) { goto error; } @@ -636,7 +690,8 @@ static int send_consumer_relayd_sockets(int domain, unsigned int session_id, /* Sending data relayd socket. */ if (!sock->data_sock_sent) { ret = send_consumer_relayd_socket(domain, session_id, - &consumer->dst.net.data, consumer, sock); + &consumer->dst.net.data, consumer, sock, + session_name, hostname, session_live_timer); if (ret != LTTNG_OK) { goto error; } @@ -673,12 +728,11 @@ int cmd_setup_relayd(struct ltt_session *session) /* For each consumer socket, send relayd sockets */ cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter, socket, node.node) { - /* Code flow error */ - assert(socket->fd >= 0); - pthread_mutex_lock(socket->lock); ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id, - usess->consumer, socket); + usess->consumer, socket, + session->name, session->hostname, + session->live_timer); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -692,12 +746,11 @@ int cmd_setup_relayd(struct ltt_session *session) && ksess->consumer->enabled) { cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter, socket, node.node) { - /* Code flow error */ - assert(socket->fd >= 0); - pthread_mutex_lock(socket->lock); ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id, - ksess->consumer, socket); + ksess->consumer, socket, + session->name, session->hostname, + session->live_timer); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -721,7 +774,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) struct ltt_kernel_channel *kchan; /* Open kernel metadata */ - if (ksess->metadata == NULL) { + if (ksess->metadata == NULL && ksess->output_traces) { ret = kernel_open_metadata(ksess); if (ret < 0) { ret = LTTNG_ERR_KERN_META_FAIL; @@ -730,7 +783,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) } /* Open kernel metadata stream */ - if (ksess->metadata_stream_fd < 0) { + if (ksess->metadata && ksess->metadata_stream_fd < 0) { ret = kernel_open_metadata_stream(ksess); if (ret < 0) { ERR("Kernel create metadata stream failed"); @@ -856,6 +909,8 @@ int cmd_enable_channel(struct ltt_session *session, DBG("Enabling channel %s for session %s", attr->name, session->name); + rcu_read_lock(); + /* * Don't try to enable a channel if the session has been started at * some point in time before. The tracer does not allow it. @@ -865,7 +920,15 @@ int cmd_enable_channel(struct ltt_session *session, goto error; } - rcu_read_lock(); + /* + * If the session is a live session, remove the switch timer, the + * live timer does the same thing but sends also synchronisation + * beacons for inactive streams. + */ + if (session->live_timer > 0) { + attr->attr.live_timer_interval = session->live_timer; + attr->attr.switch_timer_interval = 0; + } switch (domain->type) { case LTTNG_DOMAIN_KERNEL: @@ -875,7 +938,19 @@ int cmd_enable_channel(struct ltt_session *session, kchan = trace_kernel_get_channel_by_name(attr->name, session->kernel_session); if (kchan == NULL) { + /* + * Don't try to create a channel if the session + * has been started at some point in time + * before. The tracer does not allow it. + */ + if (session->started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } ret = channel_kernel_create(session->kernel_session, attr, wpipe); + if (attr->name[0] != '\0') { + session->kernel_session->has_non_default_channel = 1; + } } else { ret = channel_kernel_enable(session->kernel_session, kchan); } @@ -895,7 +970,19 @@ int cmd_enable_channel(struct ltt_session *session, uchan = trace_ust_find_channel_by_name(chan_ht, attr->name); if (uchan == NULL) { + /* + * Don't try to create a channel if the session + * has been started at some point in time + * before. The tracer does not allow it. + */ + if (session->started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } ret = channel_ust_create(usess, attr, domain->buf_type); + if (attr->name[0] != '\0') { + usess->has_non_default_channel = 1; + } } else { ret = channel_ust_enable(usess, uchan); } @@ -930,6 +1017,16 @@ int cmd_disable_event(struct ltt_session *session, int domain, ksess = session->kernel_session; + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (ksess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + kchan = trace_kernel_get_channel_by_name(channel_name, ksess); if (kchan == NULL) { ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; @@ -951,6 +1048,16 @@ int cmd_disable_event(struct ltt_session *session, int domain, usess = session->ust_session; + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (usess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name); if (uchan == NULL) { @@ -967,6 +1074,19 @@ int cmd_disable_event(struct ltt_session *session, int domain, channel_name); break; } + case LTTNG_DOMAIN_JUL: + { + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + ret = event_jul_disable(usess, event_name); + if (ret != LTTNG_OK) { + goto error; + } + + break; + } #if 0 case LTTNG_DOMAIN_UST_EXEC_NAME: case LTTNG_DOMAIN_UST_PID: @@ -1002,6 +1122,16 @@ int cmd_disable_event_all(struct ltt_session *session, int domain, ksess = session->kernel_session; + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (ksess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + kchan = trace_kernel_get_channel_by_name(channel_name, ksess); if (kchan == NULL) { ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; @@ -1023,6 +1153,16 @@ int cmd_disable_event_all(struct ltt_session *session, int domain, usess = session->ust_session; + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (usess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name); if (uchan == NULL) { @@ -1037,6 +1177,19 @@ int cmd_disable_event_all(struct ltt_session *session, int domain, DBG3("Disable all UST events in channel %s completed", channel_name); + break; + } + case LTTNG_DOMAIN_JUL: + { + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + ret = event_jul_disable_all(usess); + if (ret != LTTNG_OK) { + goto error; + } + break; } #if 0 @@ -1076,7 +1229,6 @@ int cmd_add_context(struct ltt_session *session, int domain, } chan_kern_created = 1; } - /* Add kernel context to kernel tracer */ ret = context_kernel_add(session->kernel_session, ctx, channel_name); if (ret != LTTNG_OK) { @@ -1086,10 +1238,11 @@ int cmd_add_context(struct ltt_session *session, int domain, case LTTNG_DOMAIN_UST: { struct ltt_ust_session *usess = session->ust_session; + unsigned int chan_count; + assert(usess); - unsigned int chan_count = - lttng_ht_get_count(usess->domain_global.channels); + chan_count = lttng_ht_get_count(usess->domain_global.channels); if (chan_count == 0) { struct lttng_channel *attr; /* Create default channel */ @@ -1156,7 +1309,10 @@ error: */ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, char *channel_name, struct lttng_event *event, - struct lttng_filter_bytecode *filter, int wpipe) + char *filter_expression, + struct lttng_filter_bytecode *filter, + struct lttng_event_exclusion *exclusion, + int wpipe) { int ret, channel_created = 0; struct lttng_channel *attr; @@ -1172,6 +1328,17 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, { struct ltt_kernel_channel *kchan; + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (session->kernel_session->has_non_default_channel + && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + kchan = trace_kernel_get_channel_by_name(channel_name, session->kernel_session); if (kchan == NULL) { @@ -1221,6 +1388,16 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(usess); + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (usess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + /* Get channel from global UST domain */ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name); @@ -1248,12 +1425,60 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, } /* At this point, the session and channel exist on the tracer */ - ret = event_ust_enable_tracepoint(usess, uchan, event, filter); + ret = event_ust_enable_tracepoint(usess, uchan, event, + filter_expression, filter, exclusion); if (ret != LTTNG_OK) { goto error; } break; } + case LTTNG_DOMAIN_JUL: + { + struct lttng_event uevent; + struct lttng_domain tmp_dom; + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + /* Create the default JUL tracepoint. */ + memset(&uevent, 0, sizeof(uevent)); + uevent.type = LTTNG_EVENT_TRACEPOINT; + uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + if (is_root) { + strncpy(uevent.name, DEFAULT_SYS_JUL_EVENT_NAME, + sizeof(uevent.name)); + } else { + strncpy(uevent.name, DEFAULT_USER_JUL_EVENT_NAME, + sizeof(uevent.name)); + } + uevent.name[sizeof(uevent.name) - 1] = '\0'; + + /* + * The domain type is changed because we are about to enable the + * default channel and event for the JUL domain that are hardcoded. + * This happens in the UST domain. + */ + memcpy(&tmp_dom, domain, sizeof(tmp_dom)); + tmp_dom.type = LTTNG_DOMAIN_UST; + + ret = cmd_enable_event(session, &tmp_dom, DEFAULT_JUL_CHANNEL_NAME, + &uevent, NULL, NULL, NULL, wpipe); + if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) { + goto error; + } + + /* The wild card * means that everything should be enabled. */ + if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) { + ret = event_jul_enable_all(usess, event); + } else { + ret = event_jul_enable(usess, event); + } + if (ret != LTTNG_OK) { + goto error; + } + + break; + } #if 0 case LTTNG_DOMAIN_UST_EXEC_NAME: case LTTNG_DOMAIN_UST_PID: @@ -1276,6 +1501,7 @@ error: */ int cmd_enable_event_all(struct ltt_session *session, struct lttng_domain *domain, char *channel_name, int event_type, + char *filter_expression, struct lttng_filter_bytecode *filter, int wpipe) { int ret; @@ -1293,6 +1519,17 @@ int cmd_enable_event_all(struct ltt_session *session, assert(session->kernel_session); + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (session->kernel_session->has_non_default_channel + && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + kchan = trace_kernel_get_channel_by_name(channel_name, session->kernel_session); if (kchan == NULL) { @@ -1357,6 +1594,16 @@ int cmd_enable_event_all(struct ltt_session *session, assert(usess); + /* + * If a non-default channel has been created in the + * session, explicitely require that -c chan_name needs + * to be provided. + */ + if (usess->has_non_default_channel && channel_name[0] == '\0') { + ret = LTTNG_ERR_NEED_CHANNEL_NAME; + goto error; + } + /* Get channel from global UST domain */ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name); @@ -1388,7 +1635,8 @@ int cmd_enable_event_all(struct ltt_session *session, switch (event_type) { case LTTNG_EVENT_ALL: case LTTNG_EVENT_TRACEPOINT: - ret = event_ust_enable_all_tracepoints(usess, uchan, filter); + ret = event_ust_enable_all_tracepoints(usess, uchan, + filter_expression, filter); if (ret != LTTNG_OK) { goto error; } @@ -1403,6 +1651,52 @@ int cmd_enable_event_all(struct ltt_session *session, goto error; } + break; + } + case LTTNG_DOMAIN_JUL: + { + struct lttng_event uevent, event; + struct lttng_domain tmp_dom; + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + /* Create the default JUL tracepoint. */ + uevent.type = LTTNG_EVENT_TRACEPOINT; + uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + if (is_root) { + strncpy(uevent.name, DEFAULT_SYS_JUL_EVENT_NAME, + sizeof(uevent.name)); + } else { + strncpy(uevent.name, DEFAULT_USER_JUL_EVENT_NAME, + sizeof(uevent.name)); + } + uevent.name[sizeof(uevent.name) - 1] = '\0'; + + /* + * The domain type is changed because we are about to enable the + * default channel and event for the JUL domain that are hardcoded. + * This happens in the UST domain. + */ + memcpy(&tmp_dom, domain, sizeof(tmp_dom)); + tmp_dom.type = LTTNG_DOMAIN_UST; + + ret = cmd_enable_event(session, &tmp_dom, DEFAULT_JUL_CHANNEL_NAME, + &uevent, NULL, NULL, NULL, wpipe); + if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) { + goto error; + } + + event.loglevel = LTTNG_LOGLEVEL_JUL_ALL; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + strncpy(event.name, "*", sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; + + ret = event_jul_enable_all(usess, &event); + if (ret != LTTNG_OK) { + goto error; + } + break; } #if 0 @@ -1446,6 +1740,13 @@ ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) goto error; } break; + case LTTNG_DOMAIN_JUL: + nb_events = jul_list_events(events); + if (nb_events < 0) { + ret = LTTNG_ERR_UST_LIST_FAIL; + goto error; + } + break; default: ret = LTTNG_ERR_UND; goto error; @@ -1494,6 +1795,7 @@ error: int cmd_start_trace(struct ltt_session *session) { int ret; + unsigned long nb_chan = 0; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; @@ -1509,6 +1811,21 @@ int cmd_start_trace(struct ltt_session *session) goto error; } + /* + * Starting a session without channel is useless since after that it's not + * possible to enable channel thus inform the client. + */ + if (usess && usess->domain_global.channels) { + nb_chan += lttng_ht_get_count(usess->domain_global.channels); + } + if (ksession) { + nb_chan += ksession->channel_count; + } + if (!nb_chan) { + ret = LTTNG_ERR_NO_CHANNEL; + goto error; + } + session->enabled = 1; /* Kernel tracing */ @@ -1675,18 +1992,13 @@ error: * Command LTTNG_CREATE_SESSION processed by the client thread. */ int cmd_create_session_uri(char *name, struct lttng_uri *uris, - size_t nb_uri, lttng_sock_cred *creds) + size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer) { int ret; struct ltt_session *session; assert(name); - - /* No URIs is not possible. */ - if (uris == NULL) { - ret = LTTNG_ERR_SESSION_FAIL; - goto session_error; - } + assert(creds); /* * Verify if the session already exist @@ -1718,6 +2030,7 @@ int cmd_create_session_uri(char *name, struct lttng_uri *uris, session = session_find_by_name(name); assert(session); + session->live_timer = live_timer; /* Create default consumer output for the session not yet created. */ session->consumer = consumer_create_output(CONSUMER_DST_LOCAL); if (session->consumer == NULL) { @@ -1725,9 +2038,15 @@ int cmd_create_session_uri(char *name, struct lttng_uri *uris, goto consumer_error; } - ret = cmd_set_consumer_uri(0, session, nb_uri, uris); - if (ret != LTTNG_OK) { - goto consumer_error; + if (uris) { + ret = cmd_set_consumer_uri(0, session, nb_uri, uris); + if (ret != LTTNG_OK) { + goto consumer_error; + } + session->output_traces = 1; + } else { + session->output_traces = 0; + DBG2("Session %s created with no output", session->name); } session->consumer->enabled = 1; @@ -1741,6 +2060,72 @@ find_error: return ret; } +/* + * Command LTTNG_CREATE_SESSION_SNAPSHOT processed by the client thread. + */ +int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, + size_t nb_uri, lttng_sock_cred *creds) +{ + int ret; + struct ltt_session *session; + struct snapshot_output *new_output = NULL; + + assert(name); + assert(creds); + + /* + * Create session in no output mode with URIs set to NULL. The uris we've + * received are for a default snapshot output if one. + */ + ret = cmd_create_session_uri(name, NULL, 0, creds, -1); + if (ret != LTTNG_OK) { + goto error; + } + + /* Get the newly created session pointer back. This should NEVER fail. */ + session = session_find_by_name(name); + assert(session); + + /* Flag session for snapshot mode. */ + session->snapshot_mode = 1; + + /* Skip snapshot output creation if no URI is given. */ + if (nb_uri == 0) { + goto end; + } + + new_output = snapshot_output_alloc(); + if (!new_output) { + ret = LTTNG_ERR_NOMEM; + goto error_snapshot_alloc; + } + + ret = snapshot_output_init_with_uri(DEFAULT_SNAPSHOT_MAX_SIZE, NULL, + uris, nb_uri, session->consumer, new_output, &session->snapshot); + if (ret < 0) { + if (ret == -ENOMEM) { + ret = LTTNG_ERR_NOMEM; + } else { + ret = LTTNG_ERR_INVALID; + } + goto error_snapshot; + } + + rcu_read_lock(); + snapshot_add_output(&session->snapshot, new_output); + rcu_read_unlock(); + +end: + return LTTNG_OK; + +error_snapshot: + snapshot_output_destroy(new_output); +error_snapshot_alloc: + session_destroy(session); +error: + return ret; +} + /* * Command LTTNG_DESTROY_SESSION processed by the client thread. */ @@ -1800,7 +2185,14 @@ int cmd_calibrate(int domain, struct lttng_calibrate *calibrate) { struct lttng_kernel_calibrate kcalibrate; - kcalibrate.type = calibrate->type; + switch (calibrate->type) { + case LTTNG_CALIBRATE_FUNCTION: + default: + /* Default and only possible calibrate option. */ + kcalibrate.type = LTTNG_KERNEL_CALIBRATE_KRETPROBE; + break; + } + ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate); if (ret < 0) { ret = LTTNG_ERR_KERN_ENABLE_FAIL; @@ -1812,7 +2204,14 @@ int cmd_calibrate(int domain, struct lttng_calibrate *calibrate) { struct lttng_ust_calibrate ucalibrate; - ucalibrate.type = calibrate->type; + switch (calibrate->type) { + case LTTNG_CALIBRATE_FUNCTION: + default: + /* Default and only possible calibrate option. */ + ucalibrate.type = LTTNG_UST_CALIBRATE_TRACEPOINT; + break; + } + ret = ust_app_calibrate_glb(&ucalibrate); if (ret < 0) { ret = LTTNG_ERR_UST_CALIBRATE_FAIL; @@ -1862,13 +2261,15 @@ int cmd_register_consumer(struct ltt_session *session, int domain, ret = LTTNG_ERR_CONNECT_FAIL; goto error; } + cdata->cmd_sock = sock; - socket = consumer_allocate_socket(sock); + socket = consumer_allocate_socket(&cdata->cmd_sock); if (socket == NULL) { ret = close(sock); if (ret < 0) { PERROR("close register consumer"); } + cdata->cmd_sock = -1; ret = LTTNG_ERR_FATAL; goto error; } @@ -1924,6 +2325,10 @@ ssize_t cmd_list_domains(struct ltt_session *session, if (session->ust_session != NULL) { DBG3("Listing domains found UST global domain"); nb_dom++; + + if (session->ust_session->domain_jul.being_used) { + nb_dom++; + } } *domains = zmalloc(nb_dom * sizeof(struct lttng_domain)); @@ -1941,6 +2346,12 @@ ssize_t cmd_list_domains(struct ltt_session *session, (*domains)[index].type = LTTNG_DOMAIN_UST; (*domains)[index].buf_type = session->ust_session->buffer_type; index++; + + if (session->ust_session->domain_jul.being_used) { + (*domains)[index].type = LTTNG_DOMAIN_JUL; + (*domains)[index].buf_type = session->ust_session->buffer_type; + index++; + } } return nb_dom; @@ -2031,6 +2442,12 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session, } break; } + case LTTNG_DOMAIN_JUL: + if (session->ust_session) { + nb_event = list_lttng_jul_events( + &session->ust_session->domain_jul, events); + } + break; default: ret = LTTNG_ERR_UND; goto error; @@ -2092,13 +2509,15 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, strncpy(sessions[i].name, session->name, NAME_MAX); sessions[i].name[NAME_MAX - 1] = '\0'; sessions[i].enabled = session->enabled; + sessions[i].snapshot_mode = session->snapshot_mode; + sessions[i].live_timer_interval = session->live_timer; i++; } } /* * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning - * ready for trace analysis (or anykind of reader) or else 1 for pending data. + * ready for trace analysis (or any kind of reader) or else 1 for pending data. */ int cmd_data_pending(struct ltt_session *session) { @@ -2154,8 +2573,8 @@ int cmd_snapshot_add_output(struct ltt_session *session, DBG("Cmd snapshot add output for session %s", session->name); /* - * Persmission denied to create an output if the session is not set in no - * output mode. + * Permission denied to create an output if the session is not + * set in no output mode. */ if (session->output_traces) { ret = LTTNG_ERR_EPERM; @@ -2186,27 +2605,6 @@ int cmd_snapshot_add_output(struct ltt_session *session, goto free_error; } - /* - * Copy sockets so the snapshot output can use them on destroy. - */ - - if (session->ust_session) { - ret = consumer_copy_sockets(new_output->consumer, - session->ust_session->consumer); - if (ret < 0) { - goto free_error; - } - new_output->ust_sockets_copied = 1; - } - if (session->kernel_session) { - ret = consumer_copy_sockets(new_output->consumer, - session->kernel_session->consumer); - if (ret < 0) { - goto free_error; - } - new_output->kernel_sockets_copied = 1; - } - rcu_read_lock(); snapshot_add_output(&session->snapshot, new_output); if (id) { @@ -2231,26 +2629,31 @@ int cmd_snapshot_del_output(struct ltt_session *session, struct lttng_snapshot_output *output) { int ret; - struct snapshot_output *sout; + struct snapshot_output *sout = NULL; assert(session); assert(output); - DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id, - session->name); - rcu_read_lock(); /* - * Persmission denied to create an output if the session is not set in no - * output mode. + * Permission denied to create an output if the session is not + * set in no output mode. */ if (session->output_traces) { ret = LTTNG_ERR_EPERM; goto error; } - sout = snapshot_find_output_by_id(output->id, &session->snapshot); + if (output->id) { + DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id, + session->name); + sout = snapshot_find_output_by_id(output->id, &session->snapshot); + } else if (*output->name != '\0') { + DBG("Cmd snapshot del output name %s for session %s", output->name, + session->name); + sout = snapshot_find_output_by_name(output->name, &session->snapshot); + } if (!sout) { ret = LTTNG_ERR_INVALID; goto error; @@ -2286,8 +2689,8 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, DBG("Cmd snapshot list outputs for session %s", session->name); /* - * Persmission denied to create an output if the session is not set in no - * output mode. + * Permission denied to create an output if the session is not + * set in no output mode. */ if (session->output_traces) { ret = LTTNG_ERR_EPERM; @@ -2348,12 +2751,12 @@ error: * Send relayd sockets from snapshot output to consumer. Ignore request if the * snapshot output is *not* set with a remote destination. * - * Return 0 on success or else a negative value. + * Return 0 on success or a LTTNG_ERR code. */ static int set_relayd_for_snapshot(struct consumer_output *consumer, struct snapshot_output *snap_output, struct ltt_session *session) { - int ret = 0; + int ret = LTTNG_OK; struct lttng_ht_iter iter; struct consumer_socket *socket; @@ -2373,11 +2776,13 @@ static int set_relayd_for_snapshot(struct consumer_output *consumer, * snapshot output. */ rcu_read_lock(); - cds_lfht_for_each_entry(consumer->socks->ht, &iter.iter, socket, - node.node) { + cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, + socket, node.node) { ret = send_consumer_relayd_sockets(0, session->id, - snap_output->consumer, socket); - if (ret < 0) { + snap_output->consumer, socket, + session->name, session->hostname, + session->live_timer); + if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; } @@ -2391,10 +2796,11 @@ error: /* * Record a kernel snapshot. * - * Return 0 on success or else a negative value. + * Return LTTNG_OK on success or a LTTNG_ERR code. */ static int record_kernel_snapshot(struct ltt_kernel_session *ksess, - struct snapshot_output *output, struct ltt_session *session, int wait) + struct snapshot_output *output, struct ltt_session *session, + int wait, int nb_streams) { int ret; @@ -2402,24 +2808,39 @@ static int record_kernel_snapshot(struct ltt_kernel_session *ksess, assert(output); assert(session); - if (!output->kernel_sockets_copied) { - ret = consumer_copy_sockets(output->consumer, ksess->consumer); - if (ret < 0) { - goto error; - } - output->kernel_sockets_copied = 1; + /* Get the datetime for the snapshot output directory. */ + ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime, + sizeof(output->datetime)); + if (!ret) { + ret = LTTNG_ERR_INVALID; + goto error; } - ret = set_relayd_for_snapshot(ksess->consumer, output, session); + /* + * Copy kernel session sockets so we can communicate with the right + * consumer for the snapshot record command. + */ + ret = consumer_copy_sockets(output->consumer, ksess->consumer); if (ret < 0) { + ret = LTTNG_ERR_NOMEM; goto error; } - ret = kernel_snapshot_record(ksess, output, wait); - if (ret < 0) { - goto error; + ret = set_relayd_for_snapshot(ksess->consumer, output, session); + if (ret != LTTNG_OK) { + goto error_snapshot; } + ret = kernel_snapshot_record(ksess, output, wait, nb_streams); + if (ret != LTTNG_OK) { + goto error_snapshot; + } + + ret = LTTNG_OK; + +error_snapshot: + /* Clean up copied sockets so this output can use some other later on. */ + consumer_destroy_output_sockets(output->consumer); error: return ret; } @@ -2427,10 +2848,11 @@ error: /* * Record a UST snapshot. * - * Return 0 on success or else a negative value. + * Return 0 on success or a LTTNG_ERR error code. */ static int record_ust_snapshot(struct ltt_ust_session *usess, - struct snapshot_output *output, struct ltt_session *session, int wait) + struct snapshot_output *output, struct ltt_session *session, + int wait, int nb_streams) { int ret; @@ -2438,28 +2860,77 @@ static int record_ust_snapshot(struct ltt_ust_session *usess, assert(output); assert(session); - if (!output->ust_sockets_copied) { - ret = consumer_copy_sockets(output->consumer, usess->consumer); - if (ret < 0) { - goto error; - } - output->ust_sockets_copied = 1; + /* Get the datetime for the snapshot output directory. */ + ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime, + sizeof(output->datetime)); + if (!ret) { + ret = LTTNG_ERR_INVALID; + goto error; } - ret = set_relayd_for_snapshot(usess->consumer, output, session); + /* + * Copy UST session sockets so we can communicate with the right + * consumer for the snapshot record command. + */ + ret = consumer_copy_sockets(output->consumer, usess->consumer); if (ret < 0) { + ret = LTTNG_ERR_NOMEM; goto error; } - ret = ust_app_snapshot_record(usess, output, wait); + ret = set_relayd_for_snapshot(usess->consumer, output, session); + if (ret != LTTNG_OK) { + goto error_snapshot; + } + + ret = ust_app_snapshot_record(usess, output, wait, nb_streams); if (ret < 0) { - goto error; + switch (-ret) { + case EINVAL: + ret = LTTNG_ERR_INVALID; + break; + case ENODATA: + ret = LTTNG_ERR_SNAPSHOT_NODATA; + break; + default: + ret = LTTNG_ERR_SNAPSHOT_FAIL; + break; + } + goto error_snapshot; } + ret = LTTNG_OK; + +error_snapshot: + /* Clean up copied sockets so this output can use some other later on. */ + consumer_destroy_output_sockets(output->consumer); error: return ret; } +/* + * Returns the total number of streams for a session or a negative value + * on error. + */ +static unsigned int get_total_nb_stream(struct ltt_session *session) +{ + unsigned int total_streams = 0; + + if (session->kernel_session) { + struct ltt_kernel_session *ksess = session->kernel_session; + + total_streams += ksess->stream_count_global; + } + + if (session->ust_session) { + struct ltt_ust_session *usess = session->ust_session; + + total_streams += ust_app_get_nb_stream(usess); + } + + return total_streams; +} + /* * Command LTTNG_SNAPSHOT_RECORD from lib lttng ctl. * @@ -2472,15 +2943,17 @@ int cmd_snapshot_record(struct ltt_session *session, struct lttng_snapshot_output *output, int wait) { int ret = LTTNG_OK; - struct snapshot_output *tmp_sout = NULL; + unsigned int use_tmp_output = 0; + struct snapshot_output tmp_output; + unsigned int nb_streams, snapshot_success = 0; assert(session); DBG("Cmd snapshot record for session %s", session->name); /* - * Persmission denied to create an output if the session is not set in no - * output mode. + * Permission denied to create an output if the session is not + * set in no output mode. */ if (session->output_traces) { ret = LTTNG_ERR_EPERM; @@ -2495,15 +2968,9 @@ int cmd_snapshot_record(struct ltt_session *session, /* Use temporary output for the session. */ if (output && *output->ctrl_url != '\0') { - tmp_sout = snapshot_output_alloc(); - if (!tmp_sout) { - ret = LTTNG_ERR_NOMEM; - goto error; - } - ret = snapshot_output_init(output->max_size, output->name, output->ctrl_url, output->data_url, session->consumer, - tmp_sout, NULL); + &tmp_output, NULL); if (ret < 0) { if (ret == -ENOMEM) { ret = LTTNG_ERR_NOMEM; @@ -2512,16 +2979,27 @@ int cmd_snapshot_record(struct ltt_session *session, } goto error; } + /* Use the global session count for the temporary snapshot. */ + tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + use_tmp_output = 1; } + /* + * Get the total number of stream of that session which is used by the + * maximum size of the snapshot feature. + */ + nb_streams = get_total_nb_stream(session); + if (session->kernel_session) { struct ltt_kernel_session *ksess = session->kernel_session; - if (tmp_sout) { - ret = record_kernel_snapshot(ksess, tmp_sout, session, wait); - if (ret < 0) { + if (use_tmp_output) { + ret = record_kernel_snapshot(ksess, &tmp_output, session, + wait, nb_streams); + if (ret != LTTNG_OK) { goto error; } + snapshot_success = 1; } else { struct snapshot_output *sout; struct lttng_ht_iter iter; @@ -2529,11 +3007,33 @@ int cmd_snapshot_record(struct ltt_session *session, rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, sout, node.node) { - ret = record_kernel_snapshot(ksess, sout, session, wait); - if (ret < 0) { + /* + * Make a local copy of the output and assign the possible + * temporary value given by the caller. + */ + memset(&tmp_output, 0, sizeof(tmp_output)); + memcpy(&tmp_output, sout, sizeof(tmp_output)); + + /* Use temporary max size. */ + if (output->max_size != (uint64_t) -1ULL) { + tmp_output.max_size = output->max_size; + } + + /* Use temporary name. */ + if (*output->name != '\0') { + strncpy(tmp_output.name, output->name, + sizeof(tmp_output.name)); + } + + tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + + ret = record_kernel_snapshot(ksess, &tmp_output, + session, wait, nb_streams); + if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; } + snapshot_success = 1; } rcu_read_unlock(); } @@ -2542,11 +3042,13 @@ int cmd_snapshot_record(struct ltt_session *session, if (session->ust_session) { struct ltt_ust_session *usess = session->ust_session; - if (tmp_sout) { - ret = record_ust_snapshot(usess, tmp_sout, session, wait); - if (ret < 0) { + if (use_tmp_output) { + ret = record_ust_snapshot(usess, &tmp_output, session, + wait, nb_streams); + if (ret != LTTNG_OK) { goto error; } + snapshot_success = 1; } else { struct snapshot_output *sout; struct lttng_ht_iter iter; @@ -2554,20 +3056,45 @@ int cmd_snapshot_record(struct ltt_session *session, rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, sout, node.node) { - ret = record_ust_snapshot(usess, tmp_sout, session, wait); - if (ret < 0) { + /* + * Make a local copy of the output and assign the possible + * temporary value given by the caller. + */ + memset(&tmp_output, 0, sizeof(tmp_output)); + memcpy(&tmp_output, sout, sizeof(tmp_output)); + + /* Use temporary max size. */ + if (output->max_size != (uint64_t) -1ULL) { + tmp_output.max_size = output->max_size; + } + + /* Use temporary name. */ + if (*output->name != '\0') { + strncpy(tmp_output.name, output->name, + sizeof(tmp_output.name)); + } + + tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + + ret = record_ust_snapshot(usess, &tmp_output, session, + wait, nb_streams); + if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; } + snapshot_success = 1; } rcu_read_unlock(); } } -error: - if (tmp_sout) { - snapshot_output_destroy(tmp_sout); + if (snapshot_success) { + session->snapshot.nb_snapshot++; + } else { + ret = LTTNG_ERR_SNAPSHOT_FAIL; } + +error: return ret; }