* this function.
*/
static
-void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
+void delete_ust_app_stream(int sock, struct ust_app_stream *stream)
{
if (stream->obj) {
ustctl_release_object(sock, stream->obj);
struct lttng_ht_iter iter;
struct ust_app_event *ua_event;
struct ust_app_ctx *ua_ctx;
- struct ltt_ust_stream *stream, *stmp;
+ struct ust_app_stream *stream, *stmp;
/* Wipe stream */
cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
/* Copy attributes */
if (attr) {
- memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
+ /* Translate from lttng_ust_channel to lttng_ust_channel_attr.*/
+ ua_chan->attr.subbuf_size = attr->subbuf_size;
+ ua_chan->attr.num_subbuf = attr->num_subbuf;
+ ua_chan->attr.overwrite = attr->overwrite;
+ ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
+ ua_chan->attr.read_timer_interval = attr->read_timer_interval;
+ ua_chan->attr.output = attr->output;
}
DBG3("UST app channel %s allocated", ua_chan->name);
return NULL;
}
+/*
+ * Allocate and initialize a UST app stream.
+ *
+ * Return newly allocated stream pointer or NULL on error.
+ */
+static struct ust_app_stream *alloc_ust_app_stream(void)
+{
+ struct ust_app_stream *stream = NULL;
+
+ stream = zmalloc(sizeof(*stream));
+ if (stream == NULL) {
+ PERROR("zmalloc ust app stream");
+ goto error;
+ }
+
+ /* Zero could be a valid value for a handle so flag it to -1. */
+ stream->handle = -1;
+
+error:
+ return stream;
+}
+
/*
* Alloc new UST app event.
*/
{
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;
}
{
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);
}
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
* 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)
+ struct ust_app_channel *ua_chan, struct ust_app_stream *stream)
{
int ret;
assert(ua_chan->obj);
assert(stream);
- 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);
stream->handle = stream->obj->handle;
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
{
int ret;
- health_code_update(&health_thread_cmd);
-
- /* TODO: remove cast and use lttng-ust-abi.h */
+ health_code_update();
/* We are going to receive 2 fds, we need to reserve them. */
ret = lttng_fd_get(LTTNG_FD_APPS, 2);
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);
+ ret = ustctl_create_channel(app->sock, ua_sess->handle, &ua_chan->attr,
+ &ua_chan->obj);
if (ret < 0) {
ERR("Creating channel %s for app (pid: %d, sock: %d) "
"and session handle %d with ret %d",
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;
}
assert(app);
assert(ua_sess_ptr);
- health_code_update(&health_thread_cmd);
+ health_code_update();
ua_sess = lookup_session_by_app(usess, app);
if (ua_sess == NULL) {
created = 1;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
if (ua_sess->handle == -1) {
ret = ustctl_create_session(app->sock);
ret = 0;
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
}
ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
- "%s/metadata", ua_sess->path);
+ "%s/" DEFAULT_METADATA_NAME, ua_sess->path);
if (ret < 0) {
PERROR("asprintf UST create stream");
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 *ptr;
rcu_error:
rcu_read_unlock();
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
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 *ptr;
rcu_error:
rcu_read_unlock();
error:
- health_code_update(&health_thread_cmd);
+ health_code_update();
return ret;
}
struct lttng_ht_iter iter;
struct ust_app_session *ua_sess;
struct ust_app_channel *ua_chan;
- struct ltt_ust_stream *ustream;
+ struct ust_app_stream *ustream;
struct consumer_socket *socket;
DBG("Starting tracing for ust app pid %d", app->pid);
/* Create all streams */
while (1) {
/* Create UST stream */
- ustream = zmalloc(sizeof(*ustream));
+ ustream = alloc_ust_app_stream();
if (ustream == NULL) {
- PERROR("zmalloc ust stream");
goto error_rcu_unlock;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
ret = create_ust_stream(app, ua_chan, ustream);
if (ret < 0) {
goto error_rcu_unlock;
}
- health_code_update(&health_thread_cmd);
+ health_code_update();
/* Order is important this is why a list is used. */
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 */
/* Indicate that the session has been started once */
ua_sess->started = 1;
- health_code_update(&health_thread_cmd);
+ 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;
}
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);
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;
}
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;
}
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