X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=d0dcda171e7588bac957cc5c5fada29b799e1a9f;hp=eb516d3b10c7cbf724c7f7b4c4090db24a510274;hb=fefd409b002735b415c5f653cdb2587be454f145;hpb=2f785fe7ec15872168aeff467103d3b39c02a46c diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index eb516d3b1..d0dcda171 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -185,25 +185,25 @@ static void list_lttng_channels(int domain, struct ltt_session *session, } /* - * Create a list of JUL domain events. + * Create a list of agent 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, +static int list_lttng_agent_events(struct agent *agt, struct lttng_event **events) { int i = 0, ret = 0; unsigned int nb_event = 0; - struct jul_event *event; + struct agent_event *event; struct lttng_event *tmp_events; struct lttng_ht_iter iter; - assert(dom); + assert(agt); assert(events); - DBG3("Listing JUL events"); + DBG3("Listing agent events"); - nb_event = lttng_ht_get_count(dom->events); + nb_event = lttng_ht_get_count(agt->events); if (nb_event == 0) { ret = nb_event; goto error; @@ -211,16 +211,18 @@ static int list_lttng_jul_events(struct jul_domain *dom, tmp_events = zmalloc(nb_event * sizeof(*tmp_events)); if (!tmp_events) { - PERROR("zmalloc JUL events session"); + PERROR("zmalloc agent events session"); ret = -LTTNG_ERR_FATAL; goto error; } rcu_read_lock(); - cds_lfht_for_each_entry(dom->events->ht, &iter.iter, event, node.node) { + 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(); @@ -933,6 +935,16 @@ int cmd_enable_channel(struct ltt_session *session, 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: { @@ -1061,11 +1073,18 @@ int cmd_disable_event(struct ltt_session *session, int domain, } case LTTNG_DOMAIN_JUL: { + struct agent *agt; struct ltt_ust_session *usess = session->ust_session; assert(usess); - ret = event_jul_disable(usess, event_name); + agt = trace_ust_find_agent(usess, LTTNG_DOMAIN_JUL); + if (!agt) { + ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND; + goto error; + } + + ret = event_agent_disable(usess, agt, event_name); if (ret != LTTNG_OK) { goto error; } @@ -1166,11 +1185,18 @@ int cmd_disable_event_all(struct ltt_session *session, int domain, } case LTTNG_DOMAIN_JUL: { + struct agent *agt; struct ltt_ust_session *usess = session->ust_session; assert(usess); - ret = event_jul_disable_all(usess); + agt = trace_ust_find_agent(usess, LTTNG_DOMAIN_JUL); + if (!agt) { + ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND; + goto error; + } + + ret = event_agent_disable_all(usess, agt); if (ret != LTTNG_OK) { goto error; } @@ -1289,6 +1315,38 @@ 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. */ @@ -1306,6 +1364,11 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(event); assert(channel_name); + ret = validate_event_name(event->name); + if (ret) { + goto error; + } + rcu_read_lock(); switch (domain->type) { @@ -1419,13 +1482,24 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, } case LTTNG_DOMAIN_JUL: { + struct agent *agt; struct lttng_event uevent; struct lttng_domain tmp_dom; struct ltt_ust_session *usess = session->ust_session; assert(usess); - /* Create the default JUL tracepoint. */ + agt = trace_ust_find_agent(usess, LTTNG_DOMAIN_JUL); + if (!agt) { + agt = agent_create(LTTNG_DOMAIN_JUL); + 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; @@ -1454,9 +1528,9 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, /* 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); + ret = event_agent_enable_all(usess, agt, event, filter); } else { - ret = event_jul_enable(usess, event); + ret = event_agent_enable(usess, agt, event, filter); } if (ret != LTTNG_OK) { goto error; @@ -1640,13 +1714,24 @@ int cmd_enable_event_all(struct ltt_session *session, } case LTTNG_DOMAIN_JUL: { + struct agent *agt; 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. */ + agt = trace_ust_find_agent(usess, LTTNG_DOMAIN_JUL); + if (!agt) { + agt = agent_create(LTTNG_DOMAIN_JUL); + if (!agt) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + agent_add(agt, usess->agents); + } + + /* Create the default tracepoint. */ uevent.type = LTTNG_EVENT_TRACEPOINT; uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; if (is_root) { @@ -1677,7 +1762,7 @@ int cmd_enable_event_all(struct ltt_session *session, strncpy(event.name, "*", sizeof(event.name)); event.name[sizeof(event.name) - 1] = '\0'; - ret = event_jul_enable_all(usess, &event); + ret = event_agent_enable_all(usess, agt, &event, filter); if (ret != LTTNG_OK) { goto error; } @@ -1726,7 +1811,7 @@ ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) } break; case LTTNG_DOMAIN_JUL: - nb_events = jul_list_events(events); + nb_events = agent_list_events(events); if (nb_events < 0) { ret = LTTNG_ERR_UST_LIST_FAIL; goto error; @@ -1975,6 +2060,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; @@ -2310,6 +2406,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"); @@ -2320,8 +2418,11 @@ ssize_t cmd_list_domains(struct ltt_session *session, DBG3("Listing domains found UST global domain"); nb_dom++; - if (session->ust_session->domain_jul.being_used) { - nb_dom++; + cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, + agt, node.node) { + if (agt->being_used) { + nb_dom++; + } } } @@ -2341,10 +2442,13 @@ ssize_t cmd_list_domains(struct ltt_session *session, (*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++; + 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++; + } } } @@ -2438,8 +2542,13 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session, } case LTTNG_DOMAIN_JUL: if (session->ust_session) { - nb_event = list_lttng_jul_events( - &session->ust_session->domain_jul, events); + struct lttng_ht_iter iter; + struct agent *agt; + + cds_lfht_for_each_entry(session->ust_session->agents->ht, + &iter.iter, agt, node.node) { + nb_event = list_lttng_agent_events(agt, events); + } } break; default: @@ -2809,7 +2918,7 @@ error: */ static int record_kernel_snapshot(struct ltt_kernel_session *ksess, struct snapshot_output *output, struct ltt_session *session, - int wait, int nb_streams) + int wait, uint64_t max_stream_size) { int ret; @@ -2840,7 +2949,7 @@ static int record_kernel_snapshot(struct ltt_kernel_session *ksess, goto error_snapshot; } - ret = kernel_snapshot_record(ksess, output, wait, nb_streams); + ret = kernel_snapshot_record(ksess, output, wait, max_stream_size); if (ret != LTTNG_OK) { goto error_snapshot; } @@ -2861,7 +2970,7 @@ error: */ static int record_ust_snapshot(struct ltt_ust_session *usess, struct snapshot_output *output, struct ltt_session *session, - int wait, int nb_streams) + int wait, uint64_t max_stream_size) { int ret; @@ -2892,7 +3001,7 @@ static int record_ust_snapshot(struct ltt_ust_session *usess, goto error_snapshot; } - ret = ust_app_snapshot_record(usess, output, wait, nb_streams); + ret = ust_app_snapshot_record(usess, output, wait, max_stream_size); if (ret < 0) { switch (-ret) { case EINVAL: @@ -2917,11 +3026,51 @@ 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; + + 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; + } + } + } + + return max_size; +} + /* * 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) +static unsigned int get_session_nb_streams(struct ltt_session *session) { unsigned int total_streams = 0; @@ -2955,6 +3104,7 @@ int cmd_snapshot_record(struct ltt_session *session, 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); @@ -2994,17 +3144,43 @@ int cmd_snapshot_record(struct ltt_session *session, } /* - * Get the total number of stream of that session which is used by the - * maximum size of the snapshot feature. + * Get the session maximum size for a snapshot meaning it will compute the + * size of all streams from all domain. */ - nb_streams = get_total_nb_stream(session); + 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 (use_tmp_output) { ret = record_kernel_snapshot(ksess, &tmp_output, session, - wait, nb_streams); + wait, max_stream_size); if (ret != LTTNG_OK) { goto error; } @@ -3028,6 +3204,13 @@ int cmd_snapshot_record(struct ltt_session *session, 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, @@ -3037,7 +3220,7 @@ int cmd_snapshot_record(struct ltt_session *session, tmp_output.nb_snapshot = session->snapshot.nb_snapshot; ret = record_kernel_snapshot(ksess, &tmp_output, - session, wait, nb_streams); + session, wait, max_stream_size); if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; @@ -3053,7 +3236,7 @@ int cmd_snapshot_record(struct ltt_session *session, if (use_tmp_output) { ret = record_ust_snapshot(usess, &tmp_output, session, - wait, nb_streams); + wait, max_stream_size); if (ret != LTTNG_OK) { goto error; } @@ -3077,6 +3260,13 @@ int cmd_snapshot_record(struct ltt_session *session, 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, @@ -3086,7 +3276,7 @@ int cmd_snapshot_record(struct ltt_session *session, tmp_output.nb_snapshot = session->snapshot.nb_snapshot; ret = record_ust_snapshot(usess, &tmp_output, session, - wait, nb_streams); + wait, max_stream_size); if (ret != LTTNG_OK) { rcu_read_unlock(); goto error;