X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=69dfda6a3bf384813cc62189c2299348e12929b5;hp=e5b2b7e3c8f606677d4bc03adfabf34691b20c52;hb=f1613f52941de629d913f7945cac7447d164728a;hpb=9363801e2d2069022a05e67066d8f527538946d0 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index e5b2b7e3c..69dfda6a3 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -30,7 +30,7 @@ #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" @@ -182,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. */ @@ -547,7 +596,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; @@ -573,7 +623,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; @@ -615,7 +666,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; @@ -625,7 +677,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; } @@ -634,7 +687,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,7 +727,9 @@ int cmd_setup_relayd(struct ltt_session *session) socket, node.node) { 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; @@ -689,7 +745,9 @@ int cmd_setup_relayd(struct ltt_session *session) socket, node.node) { 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; @@ -850,6 +908,25 @@ int cmd_enable_channel(struct ltt_session *session, 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) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } + + /* + * 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: { @@ -994,6 +1071,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: @@ -1084,6 +1174,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 @@ -1203,7 +1306,9 @@ 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) + struct lttng_filter_bytecode *filter, + struct lttng_event_exclusion *exclusion, + int wpipe) { int ret, channel_created = 0; struct lttng_channel *attr; @@ -1316,10 +1421,50 @@ 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, 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. */ + uevent.type = LTTNG_EVENT_TRACEPOINT; + uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + strncpy(uevent.name, DEFAULT_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, 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); + } else { + ret = event_jul_enable(usess, event); + } if (ret != LTTNG_OK) { goto error; } + break; } #if 0 @@ -1492,6 +1637,41 @@ int cmd_enable_event_all(struct ltt_session *session, 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. */ + uevent.type = LTTNG_EVENT_TRACEPOINT; + uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + strncpy(uevent.name, DEFAULT_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, wpipe); + if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) { + goto error; + } + + ret = event_jul_enable_all(usess); + if (ret != LTTNG_OK) { + goto error; + } + break; } #if 0 @@ -1535,6 +1715,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; @@ -1764,7 +1951,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; @@ -1802,6 +1989,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) { @@ -1848,7 +2036,7 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, * 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); + ret = cmd_create_session_uri(name, NULL, 0, creds, -1); if (ret != LTTNG_OK) { goto error; } @@ -2082,6 +2270,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)); @@ -2099,6 +2291,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; @@ -2189,6 +2387,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; @@ -2519,7 +2723,9 @@ 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); + snap_output->consumer, socket, + session->name, session->hostname, + session->live_timer); if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; @@ -2534,7 +2740,7 @@ error: /* * Record a kernel snapshot. * - * Return 0 on success or a LTTNG_ERR code. + * 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,