* Delete ust app event safely. RCU read lock must be held before calling
* this function.
*/
-static void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
+static
+void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
{
int ret;
struct cds_lfht_iter iter;
* Delete ust app stream safely. RCU read lock must be held before calling
* this function.
*/
-static void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
+static
+void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
{
- ustctl_release_object(sock, stream->obj);
- free(stream->obj);
+ if (stream->obj) {
+ ustctl_release_object(sock, stream->obj);
+ free(stream->obj);
+ }
free(stream);
}
* Delete ust app channel safely. RCU read lock must be held before calling
* this function.
*/
-static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
+static
+void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
{
int ret;
struct cds_lfht_iter iter;
* Delete ust app session safely. RCU read lock must be held before calling
* this function.
*/
-static void delete_ust_app_session(int sock,
- struct ust_app_session *ua_sess)
+static
+void delete_ust_app_session(int sock, struct ust_app_session *ua_sess)
{
int ret;
struct cds_lfht_iter iter;
struct ust_app_channel *ua_chan;
if (ua_sess->metadata) {
- ustctl_release_object(sock, ua_sess->metadata->stream_obj);
- free(ua_sess->metadata->stream_obj);
- ustctl_release_object(sock, ua_sess->metadata->obj);
- free(ua_sess->metadata->obj);
+ if (ua_sess->metadata->stream_obj) {
+ ustctl_release_object(sock, ua_sess->metadata->stream_obj);
+ free(ua_sess->metadata->stream_obj);
+ }
+ if (ua_sess->metadata->obj) {
+ ustctl_release_object(sock, ua_sess->metadata->obj);
+ free(ua_sess->metadata->obj);
+ }
}
cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
assert(!ret);
delete_ust_app_channel(sock, ua_chan);
}
-
ret = hashtable_destroy(ua_sess->channels);
- if (ret < 0) {
- ERR("UST app destroy session hashtable failed");
- goto error;
- }
+ assert(!ret);
-error:
- return;
+ if (ua_sess->handle != -1) {
+ ustctl_release_handle(sock, ua_sess->handle);
+ }
+ free(ua_sess);
}
/*
* Delete a traceable application structure from the global list. Never call
* this function outside of a call_rcu call.
*/
-static void delete_ust_app(struct ust_app *app)
+static
+void delete_ust_app(struct ust_app *app)
{
- int ret;
+ int ret, sock;
struct cds_lfht_node *node;
struct cds_lfht_iter iter;
struct ust_app_session *ua_sess;
- int sock;
rcu_read_lock();
sock = app->key.sock;
app->key.sock = -1;
+ /* Wipe sessions */
cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
ret = hashtable_del(app->sessions, &iter);
assert(!ret);
delete_ust_app_session(app->key.sock, ua_sess);
}
-
ret = hashtable_destroy(app->sessions);
- if (ret < 0) {
- ERR("UST app destroy session hashtable failed");
- goto end;
- }
+ assert(!ret);
/*
* Wait until we have removed the key from the sock hash table
/*
* URCU intermediate call to delete an UST app.
*/
-static void delete_ust_app_rcu(struct rcu_head *head)
+static
+void delete_ust_app_rcu(struct rcu_head *head)
{
struct cds_lfht_node *node =
caa_container_of(head, struct cds_lfht_node, head);
delete_ust_app(app);
}
+/*
+ * Alloc new UST app session.
+ */
+static
+struct ust_app_session *alloc_ust_app_session(void)
+{
+ struct ust_app_session *ua_sess;
+
+ /* Init most of the default value by allocating and zeroing */
+ ua_sess = zmalloc(sizeof(struct ust_app_session));
+ if (ua_sess == NULL) {
+ PERROR("malloc");
+ goto error;
+ }
+
+ ua_sess->handle = -1;
+ ua_sess->channels = hashtable_new_str(0);
+
+ return ua_sess;
+
+error:
+ return NULL;
+}
+
+/*
+ * Alloc new UST app channel.
+ */
+static
+struct ust_app_channel *alloc_ust_app_channel(char *name,
+ struct lttng_ust_channel *attr)
+{
+ struct ust_app_channel *ua_chan;
+
+ /* Init most of the default value by allocating and zeroing */
+ ua_chan = zmalloc(sizeof(struct ust_app_channel));
+ if (ua_chan == NULL) {
+ PERROR("malloc");
+ goto error;
+ }
+
+ /* Setup channel name */
+ strncpy(ua_chan->name, name, sizeof(ua_chan->name));
+ ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
+
+ ua_chan->enabled = 1;
+ ua_chan->handle = -1;
+ ua_chan->ctx = hashtable_new(0);
+ ua_chan->events = hashtable_new_str(0);
+ hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
+ strlen(ua_chan->name));
+
+ CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
+
+ /* Copy attributes */
+ if (attr) {
+ memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
+ }
+
+ DBG3("UST app channel %s allocated", ua_chan->name);
+
+ return ua_chan;
+
+error:
+ return NULL;
+}
+
+/*
+ * Alloc new UST app event.
+ */
+static
+struct ust_app_event *alloc_ust_app_event(char *name,
+ struct lttng_ust_event *attr)
+{
+ struct ust_app_event *ua_event;
+
+ /* Init most of the default value by allocating and zeroing */
+ ua_event = zmalloc(sizeof(struct ust_app_event));
+ if (ua_event == NULL) {
+ PERROR("malloc");
+ goto error;
+ }
+
+ ua_event->enabled = 1;
+ strncpy(ua_event->name, name, sizeof(ua_event->name));
+ ua_event->name[sizeof(ua_event->name) - 1] = '\0';
+ ua_event->ctx = hashtable_new(0);
+ hashtable_node_init(&ua_event->node, (void *) ua_event->name,
+ strlen(ua_event->name));
+
+ /* Copy attributes */
+ if (attr) {
+ memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
+ }
+
+ DBG3("UST app event %s allocated", ua_event->name);
+
+ return ua_event;
+
+error:
+ return NULL;
+}
+
+/*
+ * Alloc new UST app context.
+ */
+static
+struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
+{
+ struct ust_app_ctx *ua_ctx;
+
+ ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
+ if (ua_ctx == NULL) {
+ goto error;
+ }
+
+ if (uctx) {
+ memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
+ }
+
+ DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
+
+error:
+ return ua_ctx;
+}
+
/*
* Find an ust_app using the sock and return it. RCU read side lock must be
* held before calling this helper function.
*/
-static struct ust_app *find_app_by_sock(int sock)
+static
+struct ust_app *find_app_by_sock(int sock)
{
struct cds_lfht_node *node;
struct ust_app_key *key;
goto error;
}
+ ua_sess->metadata->handle = ua_sess->metadata->obj->handle;
+
error:
return ret;
}
return ret;
}
-/*
- * Alloc new UST app session.
- */
-static struct ust_app_session *alloc_ust_app_session(void)
-{
- struct ust_app_session *ua_sess;
-
- /* Init most of the default value by allocating and zeroing */
- ua_sess = zmalloc(sizeof(struct ust_app_session));
- if (ua_sess == NULL) {
- PERROR("malloc");
- goto error;
- }
-
- ua_sess->handle = -1;
- ua_sess->channels = hashtable_new_str(0);
-
- return ua_sess;
-
-error:
- return NULL;
-}
-
-/*
- * Alloc new UST app channel.
- */
-static struct ust_app_channel *alloc_ust_app_channel(char *name,
- struct lttng_ust_channel *attr)
-{
- struct ust_app_channel *ua_chan;
-
- /* Init most of the default value by allocating and zeroing */
- ua_chan = zmalloc(sizeof(struct ust_app_channel));
- if (ua_chan == NULL) {
- PERROR("malloc");
- goto error;
- }
-
- /* Setup channel name */
- strncpy(ua_chan->name, name, sizeof(ua_chan->name));
- ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
-
- ua_chan->enabled = 1;
- ua_chan->handle = -1;
- ua_chan->ctx = hashtable_new(0);
- ua_chan->events = hashtable_new_str(0);
- hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
- strlen(ua_chan->name));
-
- CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
-
- /* Copy attributes */
- if (attr) {
- memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
- }
-
- DBG3("UST app channel %s allocated", ua_chan->name);
-
- return ua_chan;
-
-error:
- return NULL;
-}
-
-/*
- * Alloc new UST app event.
- */
-static struct ust_app_event *alloc_ust_app_event(char *name,
- struct lttng_ust_event *attr)
-{
- struct ust_app_event *ua_event;
-
- /* Init most of the default value by allocating and zeroing */
- ua_event = zmalloc(sizeof(struct ust_app_event));
- if (ua_event == NULL) {
- PERROR("malloc");
- goto error;
- }
-
- ua_event->enabled = 1;
- strncpy(ua_event->name, name, sizeof(ua_event->name));
- ua_event->name[sizeof(ua_event->name) - 1] = '\0';
- ua_event->ctx = hashtable_new(0);
- hashtable_node_init(&ua_event->node, (void *) ua_event->name,
- strlen(ua_event->name));
-
- /* Copy attributes */
- if (attr) {
- memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
- }
-
- DBG3("UST app event %s allocated", ua_event->name);
-
- return ua_event;
-
-error:
- return NULL;
-}
-
-/*
- * Alloc new UST app context.
- */
-static
-struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
-{
- struct ust_app_ctx *ua_ctx;
-
- ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
- if (ua_ctx == NULL) {
- goto error;
- }
-
- if (uctx) {
- memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
- }
-
- DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
-
-error:
- return ua_ctx;
-}
-
/*
* Copy data between an UST app event and a LTT event.
*/
* Disable on the tracer side a ust app event for the session and channel.
*/
static int disable_ust_app_event(struct ust_app_session *ua_sess,
- struct ust_app_channel *ua_chan, struct ust_app_event *ua_event,
- struct ust_app *app)
+ struct ust_app_event *ua_event, struct ust_app *app)
{
int ret;
/* Create it on the tracer side */
ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
if (ret < 0) {
+ rcu_read_lock();
delete_ust_app_event(app->key.sock, ua_event);
+ rcu_read_unlock();
goto error;
}
hashtable_add_unique(ua_chan->events, &ua_event->node);
+ DBG2("UST app create event %s for PID %d completed",
+ ua_event->name, app->key.pid);
+
end:
error:
return ret;
char *pathname, struct ust_app *app)
{
int ret = 0;
+ mode_t old_umask;
if (ua_sess->metadata == NULL) {
/* Allocate UST metadata */
goto error;
}
+ old_umask = umask(0);
ret = mkdir(ua_sess->path, S_IRWXU | S_IRWXG);
if (ret < 0) {
PERROR("mkdir UST metadata");
goto error;
}
+ umask(old_umask);
ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
"%s/metadata", ua_sess->path);
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
+ struct lttng_ust_tracepoint_iter iter;
+
handle = ustctl_tracepoint_list(app->key.sock);
if (handle < 0) {
ERR("UST app list events getting handle failed for app pid %d",
}
while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
- tmp[count].name)) != -ENOENT) {
- if (count > nbmem) {
- DBG2("Reallocating event list from %zu to %zu bytes", nbmem,
- nbmem + UST_APP_EVENT_LIST_SIZE);
- nbmem += UST_APP_EVENT_LIST_SIZE;
+ &iter)) != -ENOENT) {
+ if (count >= nbmem) {
+ 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) {
PERROR("realloc ust app events");
goto rcu_error;
}
}
-
+ memcpy(tmp[count].name, iter.name, LTTNG_UST_SYM_NAME_LEN);
+ memcpy(tmp[count].loglevel, iter.loglevel, LTTNG_UST_SYM_NAME_LEN);
+ tmp[count].loglevel_value = iter.loglevel_value;
tmp[count].type = LTTNG_UST_TRACEPOINT;
tmp[count].pid = app->key.pid;
tmp[count].enabled = -1;
}
ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
- ret = disable_ust_app_event(ua_sess, ua_chan, ua_event, app);
+ ret = disable_ust_app_event(ua_sess, ua_event, app);
if (ret < 0) {
/* XXX: Report error someday... */
continue;
/* Disable each events of channel */
cds_lfht_for_each_entry(ua_chan->events, &uiter, ua_event, node) {
- ret = disable_ust_app_event(ua_sess, ua_chan, ua_event, app);
+ ret = disable_ust_app_event(ua_sess, ua_event, app);
if (ret < 0) {
/* XXX: Report error someday... */
continue;
ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
- ua_event_node = hashtable_lookup(ua_sess->channels,
+ ua_event_node = hashtable_lookup(ua_chan->events,
(void*)uevent->attr.name, strlen(uevent->attr.name), &uiter);
if (ua_event_node == NULL) {
- DBG3("UST app enable event %s not found. Skipping app",
- uevent->attr.name);
+ DBG3("UST app enable event %s not found for app PID %d."
+ "Skipping app", uevent->attr.name, app->key.pid);
continue;
}
ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
ret = enable_ust_app_event(ua_sess, ua_event, app);
if (ret < 0) {
- /* XXX: Report error someday... */
- continue;
+ goto error;
}
}
+error:
rcu_read_unlock();
-
return ret;
}
int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
{
int ret = 0;
+ struct cds_lfht_iter iter;
struct ust_app_session *ua_sess;
+ struct ust_app_channel *ua_chan;
DBG("Stopping tracing for ust app pid %d", app->key.pid);
goto error_rcu_unlock;
}
-#if 0 /* only useful when periodical flush will be supported */
- /* need to keep a handle on shm in session for this. */
- /* Flush all buffers before stopping */
- ret = ustctl_flush_buffer(usess->sock, usess->metadata->obj);
- if (ret < 0) {
- ERR("UST metadata flush failed");
- }
-
- cds_list_for_each_entry(ustchan, &usess->channels.head, list) {
- ret = ustctl_flush_buffer(usess->sock, ustchan->obj);
+ cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
+ ret = ustctl_sock_flush_buffer(app->key.sock, ua_chan->obj);
if (ret < 0) {
- ERR("UST flush buffer error");
+ ERR("UST app PID %d channel %s flush failed",
+ app->key.pid, ua_chan->name);
+ ERR("Ended with ret %d", ret);
+ /* Continuing flushing all buffers */
+ continue;
}
}
-#endif
/* This inhibits UST tracing */
ret = ustctl_stop_session(app->key.sock, ua_sess->handle);
/* Quiescent wait after stopping trace */
ustctl_wait_quiescent(app->key.sock);
+ /* Flush all buffers before stopping */
+ ret = ustctl_sock_flush_buffer(app->key.sock, ua_sess->metadata->obj);
+ if (ret < 0) {
+ ERR("UST app PID %d metadata flush failed", app->key.pid);
+ ERR("Ended with ret %d", ret);
+ }
+
return 0;
error_rcu_unlock:
}
}
- /* Add ltt UST context node to ltt UST channel */
- hashtable_add_unique(uchan->ctx, &uctx->node);
-
rcu_read_unlock();
return ret;
}
}
}
- /* Add ltt UST context node to ltt UST event */
- hashtable_add_unique(uevent->ctx, &uctx->node);
+ rcu_read_unlock();
+ return ret;
+}
+
+/*
+ * Enable event for a channel from a UST session for a specific PID.
+ */
+int ust_app_enable_event_pid(struct ltt_ust_session *usess,
+ struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
+{
+ int ret = 0;
+ struct cds_lfht_iter iter;
+ struct cds_lfht_node *ua_chan_node, *ua_event_node;
+ struct ust_app *app;
+ struct ust_app_session *ua_sess;
+ struct ust_app_channel *ua_chan;
+ struct ust_app_event *ua_event;
+ DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
+
+ rcu_read_lock();
+
+ app = ust_app_find_by_pid(pid);
+ if (app == NULL) {
+ ERR("UST app enable event per PID %d not found", pid);
+ ret = -1;
+ goto error;
+ }
+
+ ua_sess = lookup_session_by_app(usess, app);
+ /* If ua_sess is NULL, there is a code flow error */
+ assert(ua_sess);
+
+ /* Lookup channel in the ust app session */
+ ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
+ strlen(uchan->name), &iter);
+ /* If the channel is not found, there is a code flow error */
+ assert(ua_chan_node);
+
+ ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
+
+ ua_event_node = hashtable_lookup(ua_chan->events,
+ (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
+ if (ua_event_node == NULL) {
+ ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
+ if (ret < 0) {
+ goto error;
+ }
+ } else {
+ ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
+
+ ret = enable_ust_app_event(ua_sess, ua_event, app);
+ if (ret < 0) {
+ goto error;
+ }
+ }
+
+error:
+ rcu_read_unlock();
+ return ret;
+}
+
+/*
+ * Disable event for a channel from a UST session for a specific PID.
+ */
+int ust_app_disable_event_pid(struct ltt_ust_session *usess,
+ struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
+{
+ int ret = 0;
+ struct cds_lfht_iter iter;
+ struct cds_lfht_node *ua_chan_node, *ua_event_node;
+ struct ust_app *app;
+ struct ust_app_session *ua_sess;
+ struct ust_app_channel *ua_chan;
+ struct ust_app_event *ua_event;
+
+ DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
+
+ rcu_read_lock();
+
+ app = ust_app_find_by_pid(pid);
+ if (app == NULL) {
+ ERR("UST app disable event per PID %d not found", pid);
+ ret = -1;
+ goto error;
+ }
+
+ ua_sess = lookup_session_by_app(usess, app);
+ /* If ua_sess is NULL, there is a code flow error */
+ assert(ua_sess);
+
+ /* Lookup channel in the ust app session */
+ ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
+ strlen(uchan->name), &iter);
+ if (ua_chan_node == NULL) {
+ /* Channel does not exist, skip disabling */
+ goto error;
+ }
+ ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
+
+ ua_event_node = hashtable_lookup(ua_chan->events,
+ (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
+ if (ua_event_node == NULL) {
+ /* Event does not exist, skip disabling */
+ goto error;
+ }
+ ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
+
+ ret = disable_ust_app_event(ua_sess, ua_event, app);
+ if (ret < 0) {
+ goto error;
+ }
+
+error:
rcu_read_unlock();
return ret;
}
projects / lttng-tools.git / blobdiff