X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=33ab492daf330eacacc239646b866b612d5975e8;hp=ed4d6c86f1a0b569892b0144c6f055a73983fbb1;hb=b11feea58d73a097e4e1447473798822da28a70d;hpb=5eecee74ccdce343ccf1504174eef7c03d859fb0 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index ed4d6c86f..33ab492da 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -16,6 +16,7 @@ */ #define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -25,15 +26,17 @@ #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" #include "utils.h" +#include "syscall.h" #include "cmd.h" @@ -46,6 +49,21 @@ static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER; static uint64_t relayd_net_seq_idx; +/* + * Both functions below are special case for the Kernel domain when + * enabling/disabling all events. + */ +static +int enable_kevent_all(struct ltt_session *session, + struct lttng_domain *domain, char *channel_name, + struct lttng_event *event, + char *filter_expression, + struct lttng_filter_bytecode *filter, int wpipe); +static +int disable_kevent_all(struct ltt_session *session, int domain, + char *channel_name, + struct lttng_event *event); + /* * Create a session path used by list_lttng_sessions for the case that the * session consumer is on the network. @@ -165,6 +183,8 @@ static void list_lttng_channels(int domain, struct ltt_session *session, channels[i].attr.read_timer_interval = uchan->attr.read_timer_interval; channels[i].enabled = uchan->enabled; + channels[i].attr.tracefile_size = uchan->tracefile_size; + channels[i].attr.tracefile_count = uchan->tracefile_count; switch (uchan->attr.output) { case LTTNG_UST_MMAP: default: @@ -181,6 +201,59 @@ static void list_lttng_channels(int domain, struct ltt_session *session, } } +/* + * Create a list of agent domain events. + * + * Return number of events in list on success or else a negative value. + */ +static int list_lttng_agent_events(struct agent *agt, + struct lttng_event **events) +{ + int i = 0, ret = 0; + unsigned int nb_event = 0; + struct agent_event *event; + struct lttng_event *tmp_events; + struct lttng_ht_iter iter; + + assert(agt); + assert(events); + + DBG3("Listing agent events"); + + rcu_read_lock(); + nb_event = lttng_ht_get_count(agt->events); + rcu_read_unlock(); + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + tmp_events = zmalloc(nb_event * sizeof(*tmp_events)); + if (!tmp_events) { + PERROR("zmalloc agent events session"); + ret = -LTTNG_ERR_FATAL; + goto error; + } + + rcu_read_lock(); + cds_lfht_for_each_entry(agt->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; + tmp_events[i].loglevel = event->loglevel; + tmp_events[i].loglevel_type = event->loglevel_type; + 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 +328,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++; } @@ -288,7 +364,8 @@ static int list_lttng_kernel_events(char *channel_name, DBG("Listing events for channel %s", kchan->channel->name); if (nb_event == 0) { - goto end; + *events = NULL; + goto syscall; } *events = zmalloc(nb_event * sizeof(struct lttng_event)); @@ -335,7 +412,19 @@ static int list_lttng_kernel_events(char *channel_name, i++; } -end: +syscall: + if (syscall_table) { + ssize_t new_size; + + new_size = syscall_list_channel(kchan, events, nb_event); + if (new_size < 0) { + free(events); + ret = -new_size; + goto error; + } + nb_event = new_size; + } + return nb_event; error: @@ -405,6 +494,7 @@ static int add_uri_to_consumer(struct consumer_output *consumer, * URI was the same in the consumer so we do not append the subdir * again so to not duplicate output dir. */ + ret = LTTNG_OK; goto error; } @@ -461,9 +551,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 +636,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 +663,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 +706,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 +717,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 +727,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 +765,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 +783,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; @@ -769,7 +859,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) /* Quiescent wait after starting trace */ kernel_wait_quiescent(kernel_tracer_fd); - ksess->started = 1; + ksess->active = 1; ret = LTTNG_OK; @@ -856,16 +946,36 @@ 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. */ - if (session->started) { + if (session->has_been_started) { ret = LTTNG_ERR_TRACE_ALREADY_STARTED; 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; + } + + /* + * The ringbuffer (both in user space and kernel) behave badly in overwrite + * mode and with less than 2 subbuf so block it right away and send back an + * invalid attribute error. + */ + if (attr->attr.overwrite && attr->attr.num_subbuf < 2) { + ret = LTTNG_ERR_INVALID; + goto error; + } switch (domain->type) { case LTTNG_DOMAIN_KERNEL: @@ -876,6 +986,9 @@ int cmd_enable_channel(struct ltt_session *session, session->kernel_session); if (kchan == NULL) { 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); } @@ -896,6 +1009,9 @@ int cmd_enable_channel(struct ltt_session *session, uchan = trace_ust_find_channel_by_name(chan_ht, attr->name); if (uchan == NULL) { 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); } @@ -916,9 +1032,24 @@ error: * Command LTTNG_DISABLE_EVENT processed by the client thread. */ int cmd_disable_event(struct ltt_session *session, int domain, - char *channel_name, char *event_name) + char *channel_name, + struct lttng_event *event) { int ret; + char *event_name; + + DBG("Disable event command for event \'%s\'", event->name); + + event_name = event->name; + + if (event->loglevel_type || event->loglevel || event->enabled + || event->pid || event->filter || event->exclusion) { + return LTTNG_ERR_UNK; + } + /* Special handling for kernel domain all events. */ + if (domain == LTTNG_DOMAIN_KERNEL && !strcmp(event_name, "*")) { + return disable_kevent_all(session, domain, channel_name, event); + } rcu_read_lock(); @@ -930,14 +1061,38 @@ 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; goto error; } - ret = event_kernel_disable_tracepoint(kchan, event_name); - if (ret != LTTNG_OK) { + switch (event->type) { + case LTTNG_EVENT_ALL: + case LTTNG_EVENT_TRACEPOINT: + ret = event_kernel_disable_tracepoint(kchan, event_name); + if (ret != LTTNG_OK) { + goto error; + } + break; + case LTTNG_EVENT_SYSCALL: + ret = event_kernel_disable_syscall(kchan, event_name); + if (ret != LTTNG_OK) { + goto error; + } + break; + default: + ret = LTTNG_ERR_UNK; goto error; } @@ -951,6 +1106,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) { @@ -958,8 +1123,15 @@ int cmd_disable_event(struct ltt_session *session, int domain, goto error; } - ret = event_ust_disable_tracepoint(usess, uchan, event_name); - if (ret != LTTNG_OK) { + switch (event->type) { + case LTTNG_EVENT_ALL: + ret = event_ust_disable_tracepoint(usess, uchan, event_name); + if (ret != LTTNG_OK) { + goto error; + } + break; + default: + ret = LTTNG_ERR_UNK; goto error; } @@ -967,6 +1139,40 @@ int cmd_disable_event(struct ltt_session *session, int domain, channel_name); break; } + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: + { + struct agent *agt; + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + switch (event->type) { + case LTTNG_EVENT_ALL: + break; + default: + ret = LTTNG_ERR_UNK; + goto error; + } + + agt = trace_ust_find_agent(usess, domain); + if (!agt) { + ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND; + goto error; + } + /* The wild card * means that everything should be disabled. */ + if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) { + ret = event_agent_disable_all(usess, agt); + } else { + ret = event_agent_disable(usess, agt, event_name); + } + if (ret != LTTNG_OK) { + goto error; + } + + break; + } #if 0 case LTTNG_DOMAIN_UST_EXEC_NAME: case LTTNG_DOMAIN_UST_PID: @@ -985,10 +1191,12 @@ error: } /* - * Command LTTNG_DISABLE_ALL_EVENT processed by the client thread. + * Command LTTNG_DISABLE_EVENT for event "*" processed by the client thread. */ -int cmd_disable_event_all(struct ltt_session *session, int domain, - char *channel_name) +static +int disable_kevent_all(struct ltt_session *session, int domain, + char *channel_name, + struct lttng_event *event) { int ret; @@ -1002,48 +1210,43 @@ 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; goto error; } - ret = event_kernel_disable_all(kchan); - if (ret != LTTNG_OK) { + switch (event->type) { + case LTTNG_EVENT_ALL: + ret = event_kernel_disable_all(kchan); + if (ret != LTTNG_OK) { + goto error; + } + break; + case LTTNG_EVENT_SYSCALL: + ret = event_kernel_disable_syscall(kchan, ""); + if (ret != LTTNG_OK) { + goto error; + } + break; + default: + ret = LTTNG_ERR_UNK; goto error; } kernel_wait_quiescent(kernel_tracer_fd); break; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - struct ltt_ust_channel *uchan; - - usess = session->ust_session; - - uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, - channel_name); - if (uchan == NULL) { - ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto error; - } - - ret = event_ust_disable_all_tracepoints(usess, uchan); - if (ret != 0) { - goto error; - } - - DBG3("Disable all UST events in channel %s completed", channel_name); - - break; - } -#if 0 - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: -#endif default: ret = LTTNG_ERR_UND; goto error; @@ -1076,7 +1279,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 +1288,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 */ @@ -1151,12 +1354,48 @@ error: return ret; } +static int validate_event_name(const char *name) +{ + int ret = 0; + const char *c = name; + const char *event_name_end = c + LTTNG_SYMBOL_NAME_LEN; + + /* + * Make sure that unescaped wildcards are only used as the last + * character of the event name. + */ + while (c < event_name_end) { + switch (*c) { + case '\0': + goto end; + case '\\': + c++; + break; + case '*': + if ((c + 1) < event_name_end && *(c + 1)) { + /* Wildcard is not the last character */ + ret = LTTNG_ERR_INVALID_EVENT_NAME; + goto end; + } + default: + break; + } + c++; + } +end: + return ret; +} + /* * Command LTTNG_ENABLE_EVENT processed by the client thread. + * We own filter, exclusion, and filter_expression. */ 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; @@ -1165,6 +1404,19 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(event); assert(channel_name); + DBG("Enable event command for event \'%s\'", event->name); + + /* Special handling for kernel domain all events. */ + if (domain->type == LTTNG_DOMAIN_KERNEL && !strcmp(event->name, "*")) { + return enable_kevent_all(session, domain, channel_name, event, + filter_expression, filter, wpipe); + } + + ret = validate_event_name(event->name); + if (ret) { + goto error; + } + rcu_read_lock(); switch (domain->type) { @@ -1172,6 +1424,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) { @@ -1202,12 +1465,29 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, goto error; } - ret = event_kernel_enable_tracepoint(kchan, event); - if (ret != LTTNG_OK) { - if (channel_created) { - /* Let's not leak a useless channel. */ - kernel_destroy_channel(kchan); + switch (event->type) { + case LTTNG_EVENT_ALL: + case LTTNG_EVENT_PROBE: + case LTTNG_EVENT_FUNCTION: + case LTTNG_EVENT_FUNCTION_ENTRY: + case LTTNG_EVENT_TRACEPOINT: + ret = event_kernel_enable_tracepoint(kchan, event); + if (ret != LTTNG_OK) { + if (channel_created) { + /* Let's not leak a useless channel. */ + kernel_destroy_channel(kchan); + } + goto error; + } + break; + case LTTNG_EVENT_SYSCALL: + ret = event_kernel_enable_syscall(kchan, event->name); + if (ret != LTTNG_OK) { + goto error; } + break; + default: + ret = LTTNG_ERR_UNK; goto error; } @@ -1221,6 +1501,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,10 +1538,114 @@ 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); + /* We have passed ownership */ + filter_expression = NULL; + filter = NULL; + exclusion = NULL; + if (ret != LTTNG_OK) { + goto error; + } + break; + } + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: + { + const char *default_event_name, *default_chan_name; + struct agent *agt; + struct lttng_event uevent; + struct lttng_domain tmp_dom; + struct ltt_ust_session *usess = session->ust_session; + + assert(usess); + + agt = trace_ust_find_agent(usess, domain->type); + if (!agt) { + agt = agent_create(domain->type); + if (!agt) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + agent_add(agt, usess->agents); + } + + /* Create the default tracepoint. */ + memset(&uevent, 0, sizeof(uevent)); + uevent.type = LTTNG_EVENT_TRACEPOINT; + uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + default_event_name = event_get_default_agent_ust_name(domain->type); + if (!default_event_name) { + ret = -LTTNG_ERR_FATAL; + goto error; + } + strncpy(uevent.name, default_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; + + switch (domain->type) { + case LTTNG_DOMAIN_LOG4J: + default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME; + break; + case LTTNG_DOMAIN_JUL: + default_chan_name = DEFAULT_JUL_CHANNEL_NAME; + break; + case LTTNG_DOMAIN_PYTHON: + default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME; + break; + default: + /* The switch/case we are in should avoid this else big problem */ + assert(0); + } + + { + struct lttng_filter_bytecode *filter_copy = NULL; + + if (filter) { + filter_copy = zmalloc( + sizeof(struct lttng_filter_bytecode) + + filter->len); + if (!filter_copy) { + goto error; + } + + memcpy(filter_copy, filter, + sizeof(struct lttng_filter_bytecode) + + filter->len); + } + + ret = cmd_enable_event(session, &tmp_dom, + (char *) default_chan_name, + &uevent, filter_expression, filter_copy, + NULL, wpipe); + /* We have passed ownership */ + filter_expression = NULL; + } + + 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_agent_enable_all(usess, agt, event, filter); + filter = NULL; + } else { + ret = event_agent_enable(usess, agt, event, filter); + filter = NULL; + } if (ret != LTTNG_OK) { goto error; } + break; } #if 0 @@ -1267,15 +1661,21 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, ret = LTTNG_OK; error: + free(filter_expression); + free(filter); + free(exclusion); rcu_read_unlock(); return ret; } /* - * Command LTTNG_ENABLE_ALL_EVENT processed by the client thread. + * Command LTTNG_ENABLE_EVENT for event "*" processed by the client thread. */ -int cmd_enable_event_all(struct ltt_session *session, - struct lttng_domain *domain, char *channel_name, int event_type, +static +int enable_kevent_all(struct ltt_session *session, + struct lttng_domain *domain, char *channel_name, + struct lttng_event *event, + char *filter_expression, struct lttng_filter_bytecode *filter, int wpipe) { int ret; @@ -1293,6 +1693,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) { @@ -1318,9 +1729,12 @@ int cmd_enable_event_all(struct ltt_session *session, assert(kchan); } - switch (event_type) { + switch (event->type) { case LTTNG_EVENT_SYSCALL: - ret = event_kernel_enable_all_syscalls(kchan, kernel_tracer_fd); + ret = event_kernel_enable_syscall(kchan, ""); + if (ret != LTTNG_OK) { + goto error; + } break; case LTTNG_EVENT_TRACEPOINT: /* @@ -1350,66 +1764,6 @@ int cmd_enable_event_all(struct ltt_session *session, kernel_wait_quiescent(kernel_tracer_fd); break; } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_channel *uchan; - struct ltt_ust_session *usess = session->ust_session; - - assert(usess); - - /* Get channel from global UST domain */ - uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, - channel_name); - if (uchan == NULL) { - /* Create default channel */ - attr = channel_new_default_attr(LTTNG_DOMAIN_UST, - usess->buffer_type); - if (attr == NULL) { - ret = LTTNG_ERR_FATAL; - goto error; - } - strncpy(attr->name, channel_name, sizeof(attr->name)); - - ret = cmd_enable_channel(session, domain, attr, wpipe); - if (ret != LTTNG_OK) { - free(attr); - goto error; - } - free(attr); - - /* Get the newly created channel reference back */ - uchan = trace_ust_find_channel_by_name( - usess->domain_global.channels, channel_name); - assert(uchan); - } - - /* At this point, the session and channel exist on the tracer */ - - switch (event_type) { - case LTTNG_EVENT_ALL: - case LTTNG_EVENT_TRACEPOINT: - ret = event_ust_enable_all_tracepoints(usess, uchan, filter); - if (ret != LTTNG_OK) { - goto error; - } - break; - default: - ret = LTTNG_ERR_UST_ENABLE_FAIL; - goto error; - } - - /* Manage return value */ - if (ret != LTTNG_OK) { - goto error; - } - - break; - } -#if 0 - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: -#endif default: ret = LTTNG_ERR_UND; goto error; @@ -1446,6 +1800,15 @@ ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) goto error; } break; + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: + nb_events = agent_list_events(events, domain); + if (nb_events < 0) { + ret = LTTNG_ERR_UST_LIST_FAIL; + goto error; + } + break; default: ret = LTTNG_ERR_UND; goto error; @@ -1488,12 +1851,18 @@ error: return -ret; } +ssize_t cmd_list_syscalls(struct lttng_event **events) +{ + return syscall_table_list(events); +} + /* * Command LTTNG_START_TRACE processed by the client thread. */ 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; @@ -1503,13 +1872,28 @@ int cmd_start_trace(struct ltt_session *session) ksession = session->kernel_session; usess = session->ust_session; - if (session->enabled) { - /* Already started. */ + /* Is the session already started? */ + if (session->active) { ret = LTTNG_ERR_TRACE_ALREADY_STARTED; goto error; } - session->enabled = 1; + /* + * 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) { + rcu_read_lock(); + nb_chan += lttng_ht_get_count(usess->domain_global.channels); + rcu_read_unlock(); + } + if (ksession) { + nb_chan += ksession->channel_count; + } + if (!nb_chan) { + ret = LTTNG_ERR_NO_CHANNEL; + goto error; + } /* Kernel tracing */ if (ksession != NULL) { @@ -1521,7 +1905,11 @@ int cmd_start_trace(struct ltt_session *session) /* Flag session that trace should start automatically */ if (usess) { - usess->start_trace = 1; + /* + * Even though the start trace might fail, flag this session active so + * other application coming in are started by default. + */ + usess->active = 1; ret = ust_app_start_trace_all(usess); if (ret < 0) { @@ -1530,7 +1918,9 @@ int cmd_start_trace(struct ltt_session *session) } } - session->started = 1; + /* Flag this after a successful start. */ + session->has_been_started = 1; + session->active = 1; ret = LTTNG_OK; @@ -1554,15 +1944,14 @@ int cmd_stop_trace(struct ltt_session *session) ksession = session->kernel_session; usess = session->ust_session; - if (!session->enabled) { + /* Session is not active. Skip everythong and inform the client. */ + if (!session->active) { ret = LTTNG_ERR_TRACE_ALREADY_STOPPED; goto error; } - session->enabled = 0; - /* Kernel tracer */ - if (ksession && ksession->started) { + if (ksession && ksession->active) { DBG("Stop kernel tracing"); /* Flush metadata if exist */ @@ -1589,11 +1978,15 @@ int cmd_stop_trace(struct ltt_session *session) kernel_wait_quiescent(kernel_tracer_fd); - ksession->started = 0; + ksession->active = 0; } - if (usess && usess->start_trace) { - usess->start_trace = 0; + if (usess && usess->active) { + /* + * Even though the stop trace might fail, flag this session inactive so + * other application coming in are not started by default. + */ + usess->active = 0; ret = ust_app_stop_trace_all(usess); if (ret < 0) { @@ -1602,6 +1995,8 @@ int cmd_stop_trace(struct ltt_session *session) } } + /* Flag inactive after a successful stop. */ + session->active = 0; ret = LTTNG_OK; error: @@ -1623,8 +2018,8 @@ int cmd_set_consumer_uri(int domain, struct ltt_session *session, assert(uris); assert(nb_uri > 0); - /* Can't enable consumer after session started. */ - if (session->enabled) { + /* Can't set consumer URI if the session is active. */ + if (session->active) { ret = LTTNG_ERR_TRACE_ALREADY_STARTED; goto error; } @@ -1664,6 +2059,17 @@ int cmd_set_consumer_uri(int domain, struct ltt_session *session, } } + /* + * Make sure to set the session in output mode after we set URI since a + * session can be created without URL (thus flagged in no output mode). + */ + session->output_traces = 1; + if (ksess) { + ksess->output_traces = 1; + } else if (usess) { + usess->output_traces = 1; + } + /* All good! */ ret = LTTNG_OK; @@ -1675,7 +2081,7 @@ 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; @@ -1713,6 +2119,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) { @@ -1742,6 +2149,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. */ @@ -1801,7 +2274,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; @@ -1813,7 +2293,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; @@ -1863,13 +2350,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; } @@ -1916,6 +2405,8 @@ ssize_t cmd_list_domains(struct ltt_session *session, { int ret, index = 0; ssize_t nb_dom = 0; + struct agent *agt; + struct lttng_ht_iter iter; if (session->kernel_session != NULL) { DBG3("Listing domains found kernel domain"); @@ -1925,6 +2416,19 @@ ssize_t cmd_list_domains(struct ltt_session *session, if (session->ust_session != NULL) { DBG3("Listing domains found UST global domain"); nb_dom++; + + rcu_read_lock(); + cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, + agt, node.node) { + if (agt->being_used) { + nb_dom++; + } + } + rcu_read_unlock(); + } + + if (!nb_dom) { + goto end; } *domains = zmalloc(nb_dom * sizeof(struct lttng_domain)); @@ -1942,8 +2446,19 @@ 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++; - } + rcu_read_lock(); + cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, + agt, node.node) { + if (agt->being_used) { + (*domains)[index].type = agt->domain; + (*domains)[index].buf_type = session->ust_session->buffer_type; + index++; + } + } + rcu_read_unlock(); + } +end: return nb_dom; error: @@ -1973,16 +2488,18 @@ ssize_t cmd_list_channels(int domain, struct ltt_session *session, break; case LTTNG_DOMAIN_UST: if (session->ust_session != NULL) { + rcu_read_lock(); nb_chan = lttng_ht_get_count( - session->ust_session->domain_global.channels); + session->ust_session->domain_global.channels); + rcu_read_unlock(); } DBG3("Number of UST global channels %zd", nb_chan); - if (nb_chan <= 0) { + if (nb_chan < 0) { ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; } break; default: - *channels = NULL; ret = LTTNG_ERR_UND; goto error; } @@ -1995,10 +2512,6 @@ ssize_t cmd_list_channels(int domain, struct ltt_session *session, } list_lttng_channels(domain, session, *channels); - } else { - *channels = NULL; - /* Ret value was set in the domain switch case */ - goto error; } return nb_chan; @@ -2032,6 +2545,21 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session, } break; } + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: + if (session->ust_session) { + struct lttng_ht_iter iter; + struct agent *agt; + + rcu_read_lock(); + cds_lfht_for_each_entry(session->ust_session->agents->ht, + &iter.iter, agt, node.node) { + nb_event = list_lttng_agent_events(agt, events); + } + rcu_read_unlock(); + } + break; default: ret = LTTNG_ERR_UND; goto error; @@ -2092,14 +2620,16 @@ 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].enabled = session->active; + 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) { @@ -2110,9 +2640,24 @@ int cmd_data_pending(struct ltt_session *session) assert(session); /* Session MUST be stopped to ask for data availability. */ - if (session->enabled) { + if (session->active) { ret = LTTNG_ERR_SESSION_STARTED; goto error; + } else { + /* + * If stopped, just make sure we've started before else the above call + * will always send that there is data pending. + * + * The consumer assumes that when the data pending command is received, + * the trace has been started before or else no output data is written + * by the streams which is a condition for data pending. So, this is + * *VERY* important that we don't ask the consumer before a start + * trace. + */ + if (!session->has_been_started) { + ret = 0; + goto error; + } } if (ksess && ksess->consumer) { @@ -2155,8 +2700,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; @@ -2187,27 +2732,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) { @@ -2232,26 +2756,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; @@ -2277,7 +2806,7 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, struct lttng_snapshot_output **outputs) { int ret, idx = 0; - struct lttng_snapshot_output *list; + struct lttng_snapshot_output *list = NULL; struct lttng_ht_iter iter; struct snapshot_output *output; @@ -2287,11 +2816,11 @@ 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; + ret = -LTTNG_ERR_EPERM; goto error; } @@ -2302,11 +2831,12 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, list = zmalloc(session->snapshot.nb_output * sizeof(*list)); if (!list) { - ret = LTTNG_ERR_NOMEM; + ret = -LTTNG_ERR_NOMEM; goto error; } /* Copy list from session to the new list object. */ + rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, output, node.node) { assert(output->consumer); @@ -2321,40 +2851,40 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, ret = uri_to_str_url(&output->consumer->dst.net.control, list[idx].ctrl_url, sizeof(list[idx].ctrl_url)); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto free_error; + ret = -LTTNG_ERR_NOMEM; + goto error; } /* Data URI. */ ret = uri_to_str_url(&output->consumer->dst.net.data, list[idx].data_url, sizeof(list[idx].data_url)); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto free_error; + ret = -LTTNG_ERR_NOMEM; + goto error; } } idx++; } *outputs = list; - return session->snapshot.nb_output; - -free_error: - free(list); + list = NULL; + ret = session->snapshot.nb_output; error: - return -ret; + free(list); + rcu_read_unlock(); + return ret; } /* * 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; @@ -2377,8 +2907,10 @@ static int set_relayd_for_snapshot(struct consumer_output *consumer, 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; } @@ -2392,10 +2924,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, uint64_t max_stream_size) { int ret; @@ -2403,24 +2936,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, max_stream_size); + 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; } @@ -2428,10 +2976,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, uint64_t max_stream_size) { int ret; @@ -2439,28 +2988,119 @@ 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, max_stream_size); 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; } +/* + * Return the biggest subbuffer size of all channels in the given session. + */ +static uint64_t get_session_max_subbuf_size(struct ltt_session *session) +{ + uint64_t max_size = 0; + + assert(session); + + if (session->kernel_session) { + struct ltt_kernel_channel *chan; + struct ltt_kernel_session *ksess = session->kernel_session; + + /* + * For each channel, add to the max size the size of each subbuffer + * multiplied by their sized. + */ + cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { + if (chan->channel->attr.subbuf_size > max_size) { + max_size = chan->channel->attr.subbuf_size; + } + } + } + + if (session->ust_session) { + struct lttng_ht_iter iter; + struct ltt_ust_channel *uchan; + struct ltt_ust_session *usess = session->ust_session; + + rcu_read_lock(); + cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter, + uchan, node.node) { + if (uchan->attr.subbuf_size > max_size) { + max_size = uchan->attr.subbuf_size; + } + } + rcu_read_unlock(); + } + + return max_size; +} + +/* + * Returns the total number of streams for a session or a negative value + * on error. + */ +static unsigned int get_session_nb_streams(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. * @@ -2473,15 +3113,19 @@ 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; + uint64_t session_max_size = 0, max_stream_size = 0; assert(session); + assert(output); 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; @@ -2489,22 +3133,16 @@ int cmd_snapshot_record(struct ltt_session *session, } /* The session needs to be started at least once. */ - if (!session->started) { + if (!session->has_been_started) { ret = LTTNG_ERR_START_SESSION_ONCE; goto error; } /* 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; - } - + if (*output->ctrl_url != '\0') { 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; @@ -2513,16 +3151,53 @@ 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 session maximum size for a snapshot meaning it will compute the + * size of all streams from all domain. + */ + max_stream_size = get_session_max_subbuf_size(session); + + nb_streams = get_session_nb_streams(session); + if (nb_streams) { + /* + * The maximum size of the snapshot is the number of streams multiplied + * by the biggest subbuf size of all channels in a session which is the + * maximum stream size available for each stream. The session max size + * is now checked against the snapshot max size value given by the user + * and if lower, an error is returned. + */ + session_max_size = max_stream_size * nb_streams; + } + + DBG3("Snapshot max size is %" PRIu64 " for max stream size of %" PRIu64, + session_max_size, max_stream_size); + + /* + * If we use a temporary output, check right away if the max size fits else + * for each output the max size will be checked. + */ + if (use_tmp_output && + (tmp_output.max_size != 0 && + tmp_output.max_size < session_max_size)) { + ret = LTTNG_ERR_MAX_SIZE_INVALID; + goto error; } 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, max_stream_size); + if (ret != LTTNG_OK) { goto error; } + snapshot_success = 1; } else { struct snapshot_output *sout; struct lttng_ht_iter iter; @@ -2530,11 +3205,40 @@ 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; + } + + if (tmp_output.max_size != 0 && + tmp_output.max_size < session_max_size) { rcu_read_unlock(); + ret = LTTNG_ERR_MAX_SIZE_INVALID; goto error; } + + /* 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, max_stream_size); + if (ret != LTTNG_OK) { + rcu_read_unlock(); + goto error; + } + snapshot_success = 1; } rcu_read_unlock(); } @@ -2543,11 +3247,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, max_stream_size); + if (ret != LTTNG_OK) { goto error; } + snapshot_success = 1; } else { struct snapshot_output *sout; struct lttng_ht_iter iter; @@ -2555,20 +3261,52 @@ 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; + } + + if (tmp_output.max_size != 0 && + tmp_output.max_size < session_max_size) { + rcu_read_unlock(); + ret = LTTNG_ERR_MAX_SIZE_INVALID; + goto error; + } + + /* 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, max_stream_size); + 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; }