X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=14390f3ec3951e2b031226d4bb81740c16418b4b;hb=a5a2d0c25460639304b9bd3991d874774553a39c;hp=e5b2b7e3c8f606677d4bc03adfabf34691b20c52;hpb=9363801e2d2069022a05e67066d8f527538946d0;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index e5b2b7e3c..14390f3ec 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -850,6 +850,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->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } + + /* + * 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: { @@ -858,15 +877,6 @@ 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; @@ -890,15 +900,6 @@ 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; @@ -1583,6 +1584,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; @@ -1592,13 +1594,26 @@ 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) { + 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; + } /* Kernel tracing */ if (ksession != NULL) { @@ -1619,7 +1634,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; @@ -1643,13 +1660,12 @@ 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) { DBG("Stop kernel tracing"); @@ -1691,6 +1707,8 @@ int cmd_stop_trace(struct ltt_session *session) } } + /* Flag inactive after a successful stop. */ + session->active = 0; ret = LTTNG_OK; error: @@ -1712,8 +1730,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; } @@ -1753,6 +1771,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; @@ -1956,7 +1985,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; @@ -1968,7 +2004,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; @@ -2249,7 +2292,7 @@ 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; i++; } @@ -2268,9 +2311,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) { @@ -2623,12 +2681,17 @@ static int record_ust_snapshot(struct ltt_ust_session *usess, ret = ust_app_snapshot_record(usess, output, wait, nb_streams); if (ret < 0) { - if (ret == -EINVAL) { + switch (-ret) { + case EINVAL: ret = LTTNG_ERR_INVALID; - goto error_snapshot; + break; + case ENODATA: + ret = LTTNG_ERR_SNAPSHOT_NODATA; + break; + default: + ret = LTTNG_ERR_SNAPSHOT_FAIL; + break; } - - ret = LTTNG_ERR_SNAPSHOT_FAIL; goto error_snapshot; } @@ -2694,7 +2757,7 @@ 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; }