void delete_ust_app(struct ust_app *app)
{
int ret, sock;
- struct lttng_ht_iter iter;
- struct ust_app_session *ua_sess;
+ struct ust_app_session *ua_sess, *tmp_ua_sess;
rcu_read_lock();
sock = app->sock;
app->sock = -1;
+ lttng_ht_destroy(app->sessions);
+
/* Wipe sessions */
- cds_lfht_for_each_entry(app->sessions->ht, &iter.iter, ua_sess,
- node.node) {
- ret = lttng_ht_del(app->sessions, &iter);
- assert(!ret);
- delete_ust_app_session(app->sock, ua_sess);
+ cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
+ teardown_node) {
+ /* Free every object in the session and the session. */
+ delete_ust_app_session(sock, ua_sess);
}
- lttng_ht_destroy(app->sessions);
/*
* Wait until we have deleted the application from the sock hash table
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
ua_chan->obj, &ua_ctx->obj);
DBG2("UST app context created successfully for channel %s", ua_chan->name);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (!ua_event->filter) {
ret = 0;
DBG2("UST filter set successfully for event %s", ua_event->name);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_disable(app->sock, ua_event->obj);
if (ret < 0) {
ua_event->attr.name, app->pid);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_disable(app->sock, ua_chan->obj);
if (ret < 0) {
ua_chan->name, app->pid);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_enable(app->sock, ua_chan->obj);
if (ret < 0) {
ua_chan->name, app->pid);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_enable(app->sock, ua_event->obj);
if (ret < 0) {
ua_event->attr.name, app->pid);
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
int ret;
struct lttng_ust_channel_attr uattr;
- health_code_update(&health_thread_cmd);
+ health_code_update();
uattr.overwrite = ua_sess->metadata->attr.overwrite;
uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
ua_sess->metadata->handle = ua_sess->metadata->obj->handle;
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
/*
- * 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;
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* We are going to receive 2 fds, we need to reserve them. */
ret = lttng_fd_get(LTTNG_FD_APPS, 2);
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;
}
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* TODO: remove cast and use lttng-ust-abi.h */
goto error;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_create_channel(app->sock, ua_sess->handle,
(struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
ua_chan->name, app->pid, app->sock);
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* If channel is not enabled, disable it on the tracer */
if (!ua_chan->enabled) {
}
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret = 0;
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Create UST event on tracer */
ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
DBG2("UST app event %s created successfully for pid:%d",
ua_event->attr.name, app->pid);
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Set filter if one is present. */
if (ua_event->filter) {
}
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
static struct ust_app_session *create_ust_app_session(
struct ltt_ust_session *usess, struct ust_app *app)
{
- int ret;
struct ust_app_session *ua_sess;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ua_sess = lookup_session_by_app(usess, app);
if (ua_sess == NULL) {
shadow_copy_session(ua_sess, usess, app);
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
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);
}
end:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ua_sess;
}
}
/*
- * Create UST app channel and create it on the tracer.
+ * Create UST app channel and create it on the tracer. Set ua_chanp of the
+ * newly created channel if not NULL.
*/
-static struct ust_app_channel *create_ust_app_channel(
- struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
- struct ust_app *app)
+static int create_ust_app_channel(struct ust_app_session *ua_sess,
+ struct ltt_ust_channel *uchan, struct ust_app *app,
+ struct ust_app_channel **ua_chanp)
{
int ret = 0;
struct lttng_ht_iter iter;
ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
if (ua_chan == NULL) {
/* Only malloc can fail here */
+ ret = -ENOMEM;
goto error;
}
shadow_copy_channel(ua_chan, uchan);
goto error;
}
+ /* Only add the channel if successful on the tracer side. */
lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
app->pid);
end:
- return ua_chan;
+ if (ua_chanp) {
+ *ua_chanp = ua_chan;
+ }
+
+ /* Everything went well. */
+ return 0;
error:
delete_ust_app_channel(-1, ua_chan);
- return NULL;
+ 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;
}
lta->sock = sock;
lttng_ht_node_init_ulong(<a->sock_n, (unsigned long)lta->sock);
+ CDS_INIT_LIST_HEAD(<a->teardown_head);
+
rcu_read_lock();
/*
struct ust_app *lta;
struct lttng_ht_node_ulong *node;
struct lttng_ht_iter iter;
+ struct ust_app_session *ua_sess;
int ret;
rcu_read_lock();
lta->pid);
}
+ /* Remove sessions so they are not visible during deletion.*/
+ cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
+ node.node) {
+ ret = lttng_ht_del(lta->sessions, &iter);
+ if (ret) {
+ /* The session was already removed so scheduled for teardown. */
+ continue;
+ }
+
+ /*
+ * Add session to list for teardown. This is safe since at this point we
+ * are the only one using this list.
+ */
+ cds_list_add(&ua_sess->teardown_node, <a->teardown_head);
+ }
+
/* Free memory */
call_rcu(<a->pid_n.head, delete_ust_app_rcu);
size_t nbmem, count = 0;
struct lttng_ht_iter iter;
struct ust_app *app;
- struct lttng_event *tmp;
+ struct lttng_event *tmp_event;
nbmem = UST_APP_EVENT_LIST_SIZE;
- tmp = zmalloc(nbmem * sizeof(struct lttng_event));
- if (tmp == NULL) {
+ tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
+ if (tmp_event == NULL) {
PERROR("zmalloc ust app events");
ret = -ENOMEM;
goto error;
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
struct lttng_ust_tracepoint_iter uiter;
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (!app->compatible) {
/*
while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
&uiter)) != -LTTNG_UST_ERR_NOENT) {
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (count >= nbmem) {
/* In case the realloc fails, we free the memory */
- void *tmp_ptr = (void *) tmp;
+ void *ptr;
+
DBG2("Reallocating event list from %zu to %zu entries", nbmem,
2 * nbmem);
nbmem *= 2;
- tmp = realloc(tmp, nbmem * sizeof(struct lttng_event));
- if (tmp == NULL) {
+ ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event));
+ if (ptr == NULL) {
PERROR("realloc ust app events");
- free(tmp_ptr);
+ free(tmp_event);
ret = -ENOMEM;
goto rcu_error;
}
+ tmp_event = ptr;
}
- memcpy(tmp[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
- tmp[count].loglevel = uiter.loglevel;
- tmp[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
- tmp[count].pid = app->pid;
- tmp[count].enabled = -1;
+ memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
+ tmp_event[count].loglevel = uiter.loglevel;
+ tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
+ tmp_event[count].pid = app->pid;
+ tmp_event[count].enabled = -1;
count++;
}
}
ret = count;
- *events = tmp;
+ *events = tmp_event;
DBG2("UST app list events done (%zu events)", count);
rcu_error:
rcu_read_unlock();
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
size_t nbmem, count = 0;
struct lttng_ht_iter iter;
struct ust_app *app;
- struct lttng_event_field *tmp;
+ struct lttng_event_field *tmp_event;
nbmem = UST_APP_EVENT_LIST_SIZE;
- tmp = zmalloc(nbmem * sizeof(struct lttng_event_field));
- if (tmp == NULL) {
+ tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
+ if (tmp_event == NULL) {
PERROR("zmalloc ust app event fields");
ret = -ENOMEM;
goto error;
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
struct lttng_ust_field_iter uiter;
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (!app->compatible) {
/*
while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
&uiter)) != -LTTNG_UST_ERR_NOENT) {
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (count >= nbmem) {
/* In case the realloc fails, we free the memory */
- void *tmp_ptr = (void *) tmp;
+ void *ptr;
+
DBG2("Reallocating event field list from %zu to %zu entries", nbmem,
2 * nbmem);
nbmem *= 2;
- tmp = realloc(tmp, nbmem * sizeof(struct lttng_event_field));
- if (tmp == NULL) {
+ ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event_field));
+ if (ptr == NULL) {
PERROR("realloc ust app event fields");
- free(tmp_ptr);
+ free(tmp_event);
ret = -ENOMEM;
goto rcu_error;
}
+ tmp_event = ptr;
}
- memcpy(tmp[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
- tmp[count].type = uiter.type;
- tmp[count].nowrite = uiter.nowrite;
+ memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
+ tmp_event[count].type = uiter.type;
+ tmp_event[count].nowrite = uiter.nowrite;
- memcpy(tmp[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
- tmp[count].event.loglevel = uiter.loglevel;
- tmp[count].event.type = LTTNG_UST_TRACEPOINT;
- tmp[count].event.pid = app->pid;
- tmp[count].event.enabled = -1;
+ memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
+ tmp_event[count].event.loglevel = uiter.loglevel;
+ tmp_event[count].event.type = LTTNG_UST_TRACEPOINT;
+ tmp_event[count].event.pid = app->pid;
+ tmp_event[count].event.enabled = -1;
count++;
}
}
ret = count;
- *fields = tmp;
+ *fields = tmp_event;
DBG2("UST app list event fields done (%zu events)", count);
rcu_error:
rcu_read_unlock();
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
continue;
}
ua_sess = lookup_session_by_app(usess, app);
- /* If ua_sess is NULL, there is a code flow error */
- assert(ua_sess);
+ if (!ua_sess) {
+ /* The application has problem or is probably dead. */
+ continue;
+ }
/* Lookup channel in the ust app session */
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
struct lttng_ht_iter iter;
struct ust_app *app;
struct ust_app_session *ua_sess;
- struct ust_app_channel *ua_chan;
/* Very wrong code flow */
assert(usess);
ua_sess = create_ust_app_session(usess, app);
if (ua_sess == NULL) {
/* The malloc() failed. */
- ret = -1;
- goto error;
+ ret = -ENOMEM;
+ goto error_rcu_unlock;
} else if (ua_sess == (void *) -1UL) {
- /* The application's socket is not valid. Contiuing */
- ret = -1;
+ /*
+ * 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;
}
- /* Create channel onto application */
- ua_chan = create_ust_app_channel(ua_sess, uchan, app);
- if (ua_chan == NULL) {
- /* Major problem here and it's maybe the tracer or malloc() */
- ret = -1;
- goto error;
+ /* 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;
}
}
+error_rcu_unlock:
rcu_read_unlock();
-
-error:
return ret;
}
continue;
}
ua_sess = lookup_session_by_app(usess, app);
- /* If ua_sess is NULL, there is a code flow error */
- assert(ua_sess);
+ if (!ua_sess) {
+ /* The application has problem or is probably dead. */
+ continue;
+ }
/* Lookup channel in the ust app session */
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
continue;
}
ua_sess = lookup_session_by_app(usess, app);
- /* If ua_sess is NULL, there is a code flow error */
- assert(ua_sess);
+ if (!ua_sess) {
+ /* The application has problem or is probably dead. */
+ continue;
+ }
/* Lookup channel in the ust app session */
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
ua_sess = lookup_session_by_app(usess, app);
if (ua_sess == NULL) {
- goto error_rcu_unlock;
+ /* The session is in teardown process. Ignore and continue. */
+ goto end;
}
/* Upon restart, we skip the setup, already done */
}
}
- /* Indicate that the session has been started once */
- ua_sess->started = 1;
-
ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
if (ret < 0) {
ret = LTTNG_ERR_UST_META_FAIL;
goto error_rcu_unlock;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_create_stream(app->sock, ua_chan->obj,
&ustream->obj);
if (ret < 0) {
- /* Got all streams */
- lttng_fd_put(LTTNG_FD_APPS, 2);
+ /* Free unused memory and reset FD states. */
free(ustream);
+ lttng_fd_put(LTTNG_FD_APPS, 2);
+ 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);
+ health_code_update();
/* Order is important */
cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
ustream->handle);
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
}
switch (app->bits_per_long) {
goto error_rcu_unlock;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
skip_setup:
/* 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;
}
- health_code_update(&health_thread_cmd);
+ /* Indicate that the session has been started once */
+ ua_sess->started = 1;
+
+ health_code_update();
/* Quiescent wait after starting trace */
ustctl_wait_quiescent(app->sock);
end:
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return 0;
error_rcu_unlock:
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return -1;
}
ua_sess = lookup_session_by_app(usess, app);
if (ua_sess == NULL) {
- /* Only malloc can failed so something is really wrong */
- goto error_rcu_unlock;
+ goto end;
}
/*
* If started = 0, it means that stop trace has been called for a session
- * that was never started. This is a code flow error and should never
- * happen.
+ * that was never started. It's possible since we can have a fail start
+ * from either the application manager thread or the command thread. Simply
+ * indicate that this is a stop error.
*/
- assert(ua_sess->started == 1);
+ if (!ua_sess->started) {
+ goto error_rcu_unlock;
+ }
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* 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;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Quiescent wait after stopping trace */
ustctl_wait_quiescent(app->sock);
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Flushing buffers */
cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
node.node) {
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_sock_flush_buffer(app->sock, ua_chan->obj);
if (ret < 0) {
ERR("UST app PID %d channel %s flush failed with ret %d",
}
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Flush all buffers before stopping */
ret = ustctl_sock_flush_buffer(app->sock, ua_sess->metadata->obj);
end:
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return 0;
error_rcu_unlock:
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return -1;
}
/*
* Destroy a specific UST session in apps.
*/
-int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
+static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
{
struct ust_app_session *ua_sess;
struct lttng_ust_object_data obj;
__lookup_session_by_app(usess, app, &iter);
node = lttng_ht_iter_get_node_ulong(&iter);
if (node == NULL) {
- /* Only malloc can failed so something is really wrong */
- goto error_rcu_unlock;
+ /* Session is being or is deleted. */
+ goto end;
}
ua_sess = caa_container_of(node, struct ust_app_session, node);
ret = lttng_ht_del(app->sessions, &iter);
- assert(!ret);
+ if (ret) {
+ /* Already scheduled for teardown. */
+ goto end;
+ }
+
obj.handle = ua_sess->handle;
obj.shm_fd = -1;
obj.wait_fd = -1;
obj.memory_map_size = 0;
- health_code_update(&health_thread_cmd);
+ health_code_update();
ustctl_release_object(app->sock, &obj);
- health_code_update(&health_thread_cmd);
+ health_code_update();
delete_ust_app_session(app->sock, ua_sess);
/* Quiescent wait after stopping trace */
end:
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return 0;
-
-error_rcu_unlock:
- rcu_read_unlock();
- health_code_update(&health_thread_cmd);
- return -1;
}
/*
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
- ret = ust_app_destroy_trace(usess, app);
+ ret = destroy_trace(usess, app);
if (ret < 0) {
/* Continue to next apps even on error */
continue;
struct ust_app_event *ua_event;
struct ust_app_ctx *ua_ctx;
- if (usess == NULL) {
- ERR("No UST session on global update. Returning");
- goto error;
- }
+ assert(usess);
DBG2("UST app global update for app sock %d for session id %d", sock,
usess->id);
/* 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;
- }
}
}
}
ua_sess = lookup_session_by_app(usess, app);
- /* If ua_sess is NULL, there is a code flow error */
- assert(ua_sess);
+ if (!ua_sess) {
+ /* The application has problem or is probably dead. */
+ goto error;
+ }
/* Lookup channel in the ust app session */
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
}
ua_sess = lookup_session_by_app(usess, app);
- /* If ua_sess is NULL, there is a code flow error */
- assert(ua_sess);
+ if (!ua_sess) {
+ /* The application has problem or is probably dead. */
+ goto error;
+ }
/* Lookup channel in the ust app session */
lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
app = find_app_by_sock(sock);
assert(app);
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_tracer_version(sock, &app->version);
if (ret < 0) {
UST_APP_MAJOR_VERSION);
app->compatible = 1;
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return 0;
error:
UST_APP_MAJOR_VERSION);
app->compatible = 0;
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return -1;
}
continue;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = ustctl_calibrate(app->sock, calibrate);
if (ret < 0) {
rcu_read_unlock();
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
projects / lttng-tools.git / blobdiff