}
/*
- * Create stream onto the UST tracer for a UST session.
+ * Create metadata stream onto the UST tracer for a given session.
*/
-static int create_ust_stream(struct ust_app *app,
+static int create_ust_metadata_stream(struct ust_app *app,
struct ust_app_session *ua_sess)
{
int ret;
ret = ustctl_create_stream(app->sock, ua_sess->metadata->obj,
&ua_sess->metadata->stream_obj);
if (ret < 0) {
+ lttng_fd_put(LTTNG_FD_APPS, 2);
ERR("UST create metadata stream failed");
goto error;
}
return ret;
}
+/*
+ * Create stream onto the UST tracer for a given channel.
+ *
+ * Return -ENOENT if no more stream is available for this channel.
+ * On success, return 0.
+ * On error, return a negative value.
+ */
+static int create_ust_stream(struct ust_app *app,
+ struct ust_app_channel *ua_chan, struct ltt_ust_stream *stream)
+{
+ int ret;
+
+ assert(app);
+ assert(ua_chan);
+ assert(ua_chan->obj);
+ assert(stream);
+
+ health_code_update(&health_thread_cmd);
+
+ /* We are going to receive 2 fds, we need to reserve them. */
+ ret = lttng_fd_get(LTTNG_FD_APPS, 2);
+ if (ret < 0) {
+ ERR("Exhausted number of available FD on stream creation");
+ /* Just to make sure we never return -ENOENT. */
+ ret = -1;
+ goto error;
+ }
+
+ /*
+ * Set the stream name before creating it. On error, we don't have to
+ * delete it on the tracer side.
+ */
+ ret = snprintf(stream->name, sizeof(stream->name), "%s_%u",
+ ua_chan->name, ua_chan->streams.count);
+ if (ret < 0) {
+ /* Without the stream name we can't continue using it. */
+ PERROR("snprintf UST create stream");
+ /* Just to make sure we never return -ENOENT. */
+ ret = -1;
+ goto error;
+ }
+
+ ret = ustctl_create_stream(app->sock, ua_chan->obj, &stream->obj);
+ if (ret < 0) {
+ lttng_fd_put(LTTNG_FD_APPS, 2);
+ /* Indicates that there is no more stream for that channel. */
+ if (ret != -LTTNG_UST_ERR_NOENT) {
+ ERR("UST create metadata stream failed (ret: %d)", ret);
+ }
+ goto error;
+ }
+
+ /* Set stream handle with the returned value. */
+ stream->handle = stream->obj->handle;
+
+error:
+ health_code_update(&health_thread_cmd);
+ return ret;
+}
+
/*
* Create the specified channel onto the UST tracer for a UST session.
*/
}
/*
- * Create a UST session onto the tracer of app and add it the session
- * hashtable.
+ * Create a session on the tracer side for the given app.
+ *
+ * On success, ua_sess_ptr is populated with the session pointer or else left
+ * untouched. If the session was created, is_created is set to 1. On error,
+ * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
+ * be NULL.
*
- * Return ust app session or NULL on error.
+ * Returns 0 on success or else a negative code which is either -ENOMEM or
+ * -ENOTCONN which is the default code if the ustctl_create_session fails.
*/
-static struct ust_app_session *create_ust_app_session(
- struct ltt_ust_session *usess, struct ust_app *app)
+static int create_ust_app_session(struct ltt_ust_session *usess,
+ struct ust_app *app, struct ust_app_session **ua_sess_ptr,
+ int *is_created)
{
+ int ret, created = 0;
struct ust_app_session *ua_sess;
+ assert(usess);
+ assert(app);
+ assert(ua_sess_ptr);
+
health_code_update(&health_thread_cmd);
ua_sess = lookup_session_by_app(usess, app);
ua_sess = alloc_ust_app_session();
if (ua_sess == NULL) {
/* Only malloc can failed so something is really wrong */
- goto end;
+ ret = -ENOMEM;
+ goto error;
}
shadow_copy_session(ua_sess, usess, app);
+ created = 1;
}
health_code_update(&health_thread_cmd);
if (ua_sess->handle == -1) {
- int ret;
-
ret = ustctl_create_session(app->sock);
if (ret < 0) {
ERR("Creating session for app pid %d", app->pid);
delete_ust_app_session(-1, ua_sess);
- /* This means that the tracer is gone... */
- ua_sess = (void*) -1UL;
- goto end;
+ if (ret != -ENOMEM) {
+ /*
+ * Tracer is probably gone or got an internal error so let's
+ * behave like it will soon unregister or not usable.
+ */
+ ret = -ENOTCONN;
+ }
+ goto error;
}
ua_sess->handle = ret;
DBG2("UST app session created successfully with handle %d", ret);
}
-end:
+ *ua_sess_ptr = ua_sess;
+ if (is_created) {
+ *is_created = created;
+ }
+ /* Everything went well. */
+ ret = 0;
+
+error:
health_code_update(&health_thread_cmd);
- return ua_sess;
+ return ret;
}
/*
/* Open UST metadata stream */
if (ua_sess->metadata->stream_obj == NULL) {
- ret = create_ust_stream(app, ua_sess);
+ ret = create_ust_metadata_stream(app, ua_sess);
if (ret < 0) {
goto error;
}
int ust_app_create_channel_glb(struct ltt_ust_session *usess,
struct ltt_ust_channel *uchan)
{
- int ret = 0;
+ int ret = 0, created;
struct lttng_ht_iter iter;
struct ust_app *app;
- struct ust_app_session *ua_sess;
+ struct ust_app_session *ua_sess = NULL;
/* Very wrong code flow */
assert(usess);
* that if session exist, it will simply return a pointer to the ust
* app session.
*/
- ua_sess = create_ust_app_session(usess, app);
- if (ua_sess == NULL) {
- /* The malloc() failed. */
- ret = -ENOMEM;
- goto error_rcu_unlock;
- } else if (ua_sess == (void *) -1UL) {
- /*
- * The application's socket is not valid. Either a bad socket or a
- * timeout on it. We can't inform yet the caller that for a
- * specific app, the session failed so we continue here.
- */
- continue;
+ ret = create_ust_app_session(usess, app, &ua_sess, &created);
+ if (ret < 0) {
+ switch (ret) {
+ case -ENOTCONN:
+ /*
+ * The application's socket is not valid. Either a bad socket
+ * or a timeout on it. We can't inform the caller that for a
+ * specific app, the session failed so lets continue here.
+ */
+ continue;
+ case -ENOMEM:
+ default:
+ goto error_rcu_unlock;
+ }
}
+ assert(ua_sess);
/* Create channel onto application. We don't need the chan ref. */
ret = create_ust_app_channel(ua_sess, uchan, app, NULL);
- if (ret < 0 && ret == -ENOMEM) {
- /* No more memory is a fatal error. Stop right now. */
- goto error_rcu_unlock;
+ if (ret < 0) {
+ if (ret == -ENOMEM) {
+ /* No more memory is a fatal error. Stop right now. */
+ goto error_rcu_unlock;
+ }
+ /* Cleanup the created session if it's the case. */
+ if (created) {
+ delete_ust_app_session(app->sock, ua_sess);
+ }
}
}
goto error_rcu_unlock;
}
- /* We are going to receive 2 fds, we need to reserve them. */
- ret = lttng_fd_get(LTTNG_FD_APPS, 2);
- if (ret < 0) {
- ERR("Exhausted number of available FD upon stream create");
- free(ustream);
- goto error_rcu_unlock;
- }
-
health_code_update(&health_thread_cmd);
- ret = ustctl_create_stream(app->sock, ua_chan->obj,
- &ustream->obj);
+ ret = create_ust_stream(app, ua_chan, ustream);
if (ret < 0) {
- /* Got all streams */
- lttng_fd_put(LTTNG_FD_APPS, 2);
+ /* Free unused memory after this point. */
free(ustream);
+ if (ret == -LTTNG_UST_ERR_NOENT) {
+ /* Got all streams. Continue normal execution. */
+ break;
+ }
+ /* Error at this point. Stop everything. */
ret = LTTNG_ERR_UST_STREAM_FAIL;
- break;
+ goto error_rcu_unlock;
}
- ustream->handle = ustream->obj->handle;
health_code_update(&health_thread_cmd);
- /* Order is important */
+ /* Order is important this is why a list is used. */
cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
- ret = snprintf(ustream->name, sizeof(ustream->name), "%s_%u",
- ua_chan->name, ua_chan->streams.count);
ua_chan->streams.count++;
- if (ret < 0) {
- PERROR("asprintf UST create stream");
- /*
- * XXX what should we do here with the
- * stream ?
- */
- continue;
- }
+
DBG2("UST stream %d ready (handle: %d)", ua_chan->streams.count,
ustream->handle);
}
/* This start the UST tracing */
ret = ustctl_start_session(app->sock, ua_sess->handle);
if (ret < 0) {
- ERR("Error starting tracing for app pid: %d", app->pid);
+ ERR("Error starting tracing for app pid: %d (ret: %d)", app->pid, ret);
goto error_rcu_unlock;
}
* from either the application manager thread or the command thread. Simply
* indicate that this is a stop error.
*/
- if (ua_sess->started == 1) {
+ if (!ua_sess->started) {
goto error_rcu_unlock;
}
/* This inhibits UST tracing */
ret = ustctl_stop_session(app->sock, ua_sess->handle);
if (ret < 0) {
- ERR("Error stopping tracing for app pid: %d", app->pid);
+ ERR("Error stopping tracing for app pid: %d (ret: %d)", app->pid, ret);
goto error_rcu_unlock;
}
int ret = 0;
struct lttng_ht_iter iter, uiter, iter_ctx;
struct ust_app *app;
- struct ust_app_session *ua_sess;
+ struct ust_app_session *ua_sess = NULL;
struct ust_app_channel *ua_chan;
struct ust_app_event *ua_event;
struct ust_app_ctx *ua_ctx;
goto error;
}
- ua_sess = create_ust_app_session(usess, app);
- if (ua_sess == NULL || ua_sess == (void *) -1UL) {
- /* Tracer is gone for this session and has been freed */
+ ret = create_ust_app_session(usess, app, &ua_sess, NULL);
+ if (ret < 0) {
+ /* Tracer is probably gone or ENOMEM. */
goto error;
}
+ assert(ua_sess);
/*
* We can iterate safely here over all UST app session sicne the create ust
/* FIXME: Should we quit here or continue... */
continue;
}
-
- ret = set_ust_event_filter(ua_event, app);
- if (ret < 0) {
- /* FIXME: Should we quit here or continue... */
- continue;
- }
}
}
projects / lttng-tools.git / blobdiff