X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=lttng-sessiond%2Fust-app.c;h=209a7fed47fa83b8fa685ad7af848b50fe09aa7b;hp=377600f3d2f2347ce52765b43c5fbec19ceddff7;hb=0857097f7cd49f503c966eb42716415dd5540352;hpb=67e407978a700da256ab4f58736002826c7be7c1 diff --git a/lttng-sessiond/ust-app.c b/lttng-sessiond/ust-app.c index 377600f3d..209a7fed4 100644 --- a/lttng-sessiond/ust-app.c +++ b/lttng-sessiond/ust-app.c @@ -27,10 +27,12 @@ #include #include + #include +#include #include -#include "hashtable.h" +#include "common/runas.h" #include "ust-app.h" #include "ust-consumer.h" #include "ust-ctl.h" @@ -57,16 +59,17 @@ static void delete_ust_app_event(int sock, struct ust_app_event *ua_event) { int ret; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app_ctx *ua_ctx; - cds_lfht_for_each_entry(ua_event->ctx, &iter, ua_ctx, node) { - ret = hashtable_del(ua_event->ctx, &iter); + /* Destroy each context of event */ + cds_lfht_for_each_entry(ua_event->ctx->ht, &iter.iter, ua_ctx, + node.node) { + ret = lttng_ht_del(ua_event->ctx, &iter); assert(!ret); delete_ust_app_ctx(sock, ua_ctx); } - ret = hashtable_destroy(ua_event->ctx); - assert(!ret); + lttng_ht_destroy(ua_event->ctx); if (ua_event->obj != NULL) { ustctl_release_object(sock, ua_event->obj); @@ -97,7 +100,7 @@ static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan) { int ret; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app_event *ua_event; struct ust_app_ctx *ua_ctx; struct ltt_ust_stream *stream, *stmp; @@ -109,22 +112,21 @@ void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan) } /* Wipe context */ - cds_lfht_for_each_entry(ua_chan->ctx, &iter, ua_ctx, node) { - ret = hashtable_del(ua_chan->ctx, &iter); + cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) { + ret = lttng_ht_del(ua_chan->ctx, &iter); assert(!ret); delete_ust_app_ctx(sock, ua_ctx); } - ret = hashtable_destroy(ua_chan->ctx); - assert(!ret); + lttng_ht_destroy(ua_chan->ctx); /* Wipe events */ - cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) { - ret = hashtable_del(ua_chan->events, &iter); + cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event, + node.node) { + ret = lttng_ht_del(ua_chan->events, &iter); assert(!ret); delete_ust_app_event(sock, ua_event); } - ret = hashtable_destroy(ua_chan->events); - assert(!ret); + lttng_ht_destroy(ua_chan->events); if (ua_chan->obj != NULL) { ustctl_release_object(sock, ua_chan->obj); @@ -141,7 +143,7 @@ static void delete_ust_app_session(int sock, struct ust_app_session *ua_sess) { int ret; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app_channel *ua_chan; if (ua_sess->metadata) { @@ -155,14 +157,17 @@ void delete_ust_app_session(int sock, struct ust_app_session *ua_sess) } } - cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) { - ret = hashtable_del(ua_sess->channels, &iter); + cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan, + node.node) { + ret = lttng_ht_del(ua_sess->channels, &iter); assert(!ret); delete_ust_app_channel(sock, ua_chan); } - ret = hashtable_destroy(ua_sess->channels); - assert(!ret); + lttng_ht_destroy(ua_sess->channels); + if (ua_sess->handle != -1) { + ustctl_release_handle(sock, ua_sess->handle); + } free(ua_sess); } @@ -174,56 +179,34 @@ static void delete_ust_app(struct ust_app *app) { int ret, sock; - struct cds_lfht_node *node; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app_session *ua_sess; rcu_read_lock(); - /* Remove from key hash table */ - node = hashtable_lookup(ust_app_sock_key_map, - (void *) ((unsigned long) app->key.sock), sizeof(void *), &iter); - if (node == NULL) { - /* Not suppose to happen */ - ERR("UST app key %d not found in key hash table", app->key.sock); - goto end; - } - - ret = hashtable_del(ust_app_sock_key_map, &iter); - if (ret) { - ERR("UST app unable to delete app sock %d from key hash table", - app->key.sock); - } else { - DBG2("UST app pair sock %d key %d deleted", - app->key.sock, app->key.pid); - } - - /* Socket is already closed at this point */ - /* Delete ust app sessions info */ 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); + 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->key.sock, ua_sess); } - ret = hashtable_destroy(app->sessions); - assert(!ret); + lttng_ht_destroy(app->sessions); /* - * Wait until we have removed the key from the sock hash table - * before closing this socket, otherwise an application could - * re-use the socket ID and race with the teardown, using the - * same hash table entry. + * Wait until we have removed the key from the sock hash table before + * closing this socket, otherwise an application could re-use the socket ID + * and race with the teardown, using the same hash table entry. */ close(sock); DBG2("UST app pid %d deleted", app->key.pid); free(app); -end: + rcu_read_unlock(); } @@ -233,11 +216,12 @@ end: static void delete_ust_app_rcu(struct rcu_head *head) { - struct cds_lfht_node *node = - caa_container_of(head, struct cds_lfht_node, head); + struct lttng_ht_node_ulong *node = + caa_container_of(head, struct lttng_ht_node_ulong, head); struct ust_app *app = caa_container_of(node, struct ust_app, node); + DBG3("Call RCU deleting app PID %d", app->key.pid); delete_ust_app(app); } @@ -257,7 +241,7 @@ struct ust_app_session *alloc_ust_app_session(void) } ua_sess->handle = -1; - ua_sess->channels = hashtable_new_str(0); + ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); return ua_sess; @@ -287,10 +271,9 @@ struct ust_app_channel *alloc_ust_app_channel(char *name, 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)); + ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); + lttng_ht_node_init_str(&ua_chan->node, ua_chan->name); CDS_INIT_LIST_HEAD(&ua_chan->streams.head); @@ -326,9 +309,8 @@ struct ust_app_event *alloc_ust_app_event(char *name, 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)); + ua_event->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + lttng_ht_node_init_str(&ua_event->node, ua_event->name); /* Copy attributes */ if (attr) { @@ -373,21 +355,21 @@ error: static struct ust_app *find_app_by_sock(int sock) { - struct cds_lfht_node *node; + struct lttng_ht_node_ulong *node; struct ust_app_key *key; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; - node = hashtable_lookup(ust_app_sock_key_map, - (void *)((unsigned long) sock), sizeof(void *), &iter); + lttng_ht_lookup(ust_app_sock_key_map, (void *)((unsigned long) sock), + &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node == NULL) { DBG2("UST app find by sock %d key not found", sock); goto error; } - key = caa_container_of(node, struct ust_app_key, node); - node = hashtable_lookup(ust_app_ht, - (void *)((unsigned long) key->pid), sizeof(void *), &iter); + lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) key->pid), &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node == NULL) { DBG2("UST app find by sock %d not found", sock); goto error; @@ -560,11 +542,13 @@ static int open_ust_metadata(struct ust_app *app, ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr, &ua_sess->metadata->obj); if (ret < 0) { - ERR("UST app open metadata failed for app pid:%d", - app->key.pid); + ERR("UST app open metadata failed for app pid:%d with ret %d", + app->key.pid, ret); goto error; } + ua_sess->metadata->handle = ua_sess->metadata->obj->handle; + error: return ret; } @@ -600,7 +584,7 @@ static int create_ust_channel(struct ust_app *app, ret = ustctl_create_channel(app->key.sock, ua_sess->handle, (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj); if (ret < 0) { - DBG("Error creating channel %s for app (pid: %d, sock: %d) " + ERR("Creating channel %s for app (pid: %d, sock: %d) " "and session handle %d with ret %d", ua_chan->name, app->key.pid, app->key.sock, ua_sess->handle, ret); @@ -608,9 +592,6 @@ static int create_ust_channel(struct ust_app *app, } ua_chan->handle = ua_chan->obj->handle; - ua_chan->attr.shm_fd = ua_chan->obj->shm_fd; - ua_chan->attr.wait_fd = ua_chan->obj->wait_fd; - ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size; DBG2("UST app channel %s created successfully for pid:%d and sock:%d", ua_chan->name, app->key.pid, app->key.sock); @@ -640,6 +621,10 @@ int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess, ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj, &ua_event->obj); if (ret < 0) { + if (ret == -EEXIST) { + ret = 0; + goto error; + } ERR("Error ustctl create event %s for app pid: %d with ret %d", ua_event->attr.name, app->key.pid, ret); goto error; @@ -651,9 +636,25 @@ int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess, ua_event->attr.name, app->key.pid); /* If event not enabled, disable it on the tracer */ - if (!ua_event->enabled) { + if (ua_event->enabled == 0) { ret = disable_ust_event(app, ua_sess, ua_event); if (ret < 0) { + /* + * If we hit an EPERM, something is wrong with our disable call. If + * we get an EEXIST, there is a problem on the tracer side since we + * just created it. + */ + switch (ret) { + case -EPERM: + /* Code flow problem */ + assert(0); + case -EEXIST: + /* It's OK for our use case. */ + ret = 0; + break; + default: + break; + } goto error; } } @@ -668,24 +669,28 @@ error: static void shadow_copy_event(struct ust_app_event *ua_event, struct ltt_ust_event *uevent) { - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ltt_ust_context *uctx; struct ust_app_ctx *ua_ctx; strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name)); ua_event->name[sizeof(ua_event->name) - 1] = '\0'; + ua_event->enabled = uevent->enabled; + /* Copy event attributes */ memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr)); - cds_lfht_for_each_entry(uevent->ctx, &iter, uctx, node) { + cds_lfht_for_each_entry(uevent->ctx->ht, &iter.iter, uctx, node.node) { ua_ctx = alloc_ust_app_ctx(&uctx->ctx); if (ua_ctx == NULL) { - continue; + /* malloc() failed. We should simply stop */ + return; } - hashtable_node_init(&ua_ctx->node, - (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *)); - hashtable_add_unique(ua_event->ctx, &ua_ctx->node); + + lttng_ht_node_init_ulong(&ua_ctx->node, + (unsigned long) ua_ctx->ctx.ctx); + lttng_ht_add_unique_ulong(ua_event->ctx, &ua_ctx->node); } } @@ -695,37 +700,38 @@ static void shadow_copy_event(struct ust_app_event *ua_event, static void shadow_copy_channel(struct ust_app_channel *ua_chan, struct ltt_ust_channel *uchan) { - struct cds_lfht_iter iter; - struct cds_lfht_node *ua_event_node; + struct lttng_ht_iter iter; + struct lttng_ht_node_str *ua_event_node; struct ltt_ust_event *uevent; struct ltt_ust_context *uctx; struct ust_app_event *ua_event; struct ust_app_ctx *ua_ctx; - DBG2("Shadow copy of UST app channel %s", ua_chan->name); + DBG2("UST app shadow copy of channel %s started", ua_chan->name); strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name)); ua_chan->name[sizeof(ua_chan->name) - 1] = '\0'; /* Copy event attributes */ memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr)); - cds_lfht_for_each_entry(uchan->ctx, &iter, uctx, node) { + ua_chan->enabled = uchan->enabled; + + cds_lfht_for_each_entry(uchan->ctx->ht, &iter.iter, uctx, node.node) { ua_ctx = alloc_ust_app_ctx(&uctx->ctx); if (ua_ctx == NULL) { continue; } - hashtable_node_init(&ua_ctx->node, - (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *)); - hashtable_add_unique(ua_chan->ctx, &ua_ctx->node); + lttng_ht_node_init_ulong(&ua_ctx->node, + (unsigned long) ua_ctx->ctx.ctx); + lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node); } /* Copy all events from ltt ust channel to ust app channel */ - cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) { - struct cds_lfht_iter uiter; + cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + struct lttng_ht_iter uiter; - ua_event_node = hashtable_lookup(ua_chan->events, - (void *) uevent->attr.name, strlen(uevent->attr.name), - &uiter); + lttng_ht_lookup(ua_chan->events, (void *) uevent->attr.name, &uiter); + ua_event_node = lttng_ht_iter_get_node_str(&uiter); if (ua_event_node == NULL) { DBG2("UST event %s not found on shadow copy channel", uevent->attr.name); @@ -734,22 +740,21 @@ static void shadow_copy_channel(struct ust_app_channel *ua_chan, continue; } shadow_copy_event(ua_event, uevent); - hashtable_add_unique(ua_chan->events, &ua_event->node); + lttng_ht_add_unique_str(ua_chan->events, &ua_event->node); } } - DBG3("Shadow copy channel done"); + DBG3("UST app shadow copy of channel %s done", ua_chan->name); } /* * Copy data between a UST app session and a regular LTT session. */ static void shadow_copy_session(struct ust_app_session *ua_sess, - struct ltt_ust_session *usess, - struct ust_app *app) + struct ltt_ust_session *usess, struct ust_app *app) { - struct cds_lfht_node *ua_chan_node; - struct cds_lfht_iter iter; + struct lttng_ht_node_str *ua_chan_node; + struct lttng_ht_iter iter; struct ltt_ust_channel *uchan; struct ust_app_channel *ua_chan; time_t rawtime; @@ -764,12 +769,12 @@ static void shadow_copy_session(struct ust_app_session *ua_sess, DBG2("Shadow copy of session handle %d", ua_sess->handle); + ua_sess->id = usess->id; ua_sess->uid = usess->uid; + ua_sess->gid = usess->gid; - ret = snprintf(ua_sess->path, PATH_MAX, - "%s/%s-%d-%s", - usess->pathname, app->name, app->key.pid, - datetime); + ret = snprintf(ua_sess->path, PATH_MAX, "%s/%s-%d-%s", usess->pathname, + app->name, app->key.pid, datetime); if (ret < 0) { PERROR("asprintf UST shadow copy session"); /* TODO: We cannot return an error from here.. */ @@ -779,14 +784,14 @@ static void shadow_copy_session(struct ust_app_session *ua_sess, /* TODO: support all UST domain */ /* Iterate over all channels in global domain. */ - cds_lfht_for_each_entry(usess->domain_global.channels, &iter, - uchan, node) { - struct cds_lfht_iter uiter; + cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter, + uchan, node.node) { + struct lttng_ht_iter uiter; - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), - &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); if (ua_chan_node != NULL) { + /* Session exist. Contiuing. */ continue; } @@ -794,12 +799,12 @@ static void shadow_copy_session(struct ust_app_session *ua_sess, uchan->name); ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr); if (ua_chan == NULL) { - /* malloc failed... continuing */ + /* malloc failed FIXME: Might want to do handle ENOMEM .. */ continue; } shadow_copy_channel(ua_chan, uchan); - hashtable_add_unique(ua_sess->channels, &ua_chan->node); + lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node); } } @@ -808,26 +813,24 @@ static void shadow_copy_session(struct ust_app_session *ua_sess, */ static void __lookup_session_by_app(struct ltt_ust_session *usess, - struct ust_app *app, struct cds_lfht_iter *iter) + struct ust_app *app, struct lttng_ht_iter *iter) { /* Get right UST app session from app */ - (void) hashtable_lookup(app->sessions, - (void *) ((unsigned long) usess->uid), sizeof(void *), - iter); + lttng_ht_lookup(app->sessions, (void *)((unsigned long) usess->id), iter); } /* * Return ust app session from the app session hashtable using the UST session - * uid. + * id. */ static struct ust_app_session *lookup_session_by_app( struct ltt_ust_session *usess, struct ust_app *app) { - struct cds_lfht_iter iter; - struct cds_lfht_node *node; + struct lttng_ht_iter iter; + struct lttng_ht_node_ulong *node; __lookup_session_by_app(usess, app, &iter); - node = hashtable_iter_get_node(&iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node == NULL) { goto error; } @@ -852,12 +855,12 @@ static struct ust_app_session *create_ust_app_session( ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { - DBG2("UST app pid: %d session uid %d not found, creating it", - app->key.pid, usess->uid); + DBG2("UST app pid: %d session id %d not found, creating it", + app->key.pid, usess->id); ua_sess = alloc_ust_app_session(); if (ua_sess == NULL) { /* Only malloc can failed so something is really wrong */ - goto error; + goto end; } shadow_copy_session(ua_sess, usess, app); } @@ -865,26 +868,24 @@ static struct ust_app_session *create_ust_app_session( if (ua_sess->handle == -1) { ret = ustctl_create_session(app->key.sock); if (ret < 0) { - ERR("Error creating session for app pid %d, sock %d", - app->key.pid, app->key.sock); - /* TODO: free() ua_sess */ + ERR("Creating session for app pid %d", app->key.pid); goto error; } - DBG2("UST app ustctl create session handle %d", ret); ua_sess->handle = ret; /* Add ust app session to app's HT */ - hashtable_node_init(&ua_sess->node, - (void *)((unsigned long) ua_sess->uid), sizeof(void *)); - hashtable_add_unique(app->sessions, &ua_sess->node); + lttng_ht_node_init_ulong(&ua_sess->node, (unsigned long) ua_sess->id); + lttng_ht_add_unique_ulong(app->sessions, &ua_sess->node); DBG2("UST app session created successfully with handle %d", ret); } +end: return ua_sess; error: + delete_ust_app_session(-1, ua_sess); return NULL; } @@ -897,14 +898,14 @@ int create_ust_app_channel_context(struct ust_app_session *ua_sess, struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *node; + struct lttng_ht_iter iter; + struct lttng_ht_node_ulong *node; struct ust_app_ctx *ua_ctx; DBG2("UST app adding context to channel %s", ua_chan->name); - node = hashtable_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx), - sizeof(void *), &iter); + lttng_ht_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx), &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node != NULL) { ret = -EEXIST; goto error; @@ -917,9 +918,8 @@ int create_ust_app_channel_context(struct ust_app_session *ua_sess, goto error; } - hashtable_node_init(&ua_ctx->node, - (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *)); - hashtable_add_unique(ua_chan->ctx, &ua_ctx->node); + lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx); + lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node); ret = create_ust_channel_context(ua_chan, ua_ctx, app); if (ret < 0) { @@ -939,14 +939,14 @@ int create_ust_app_event_context(struct ust_app_session *ua_sess, struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *node; + struct lttng_ht_iter iter; + struct lttng_ht_node_ulong *node; struct ust_app_ctx *ua_ctx; DBG2("UST app adding context to event %s", ua_event->name); - node = hashtable_lookup(ua_event->ctx, (void *)((unsigned long)uctx->ctx), - sizeof(void *), &iter); + lttng_ht_lookup(ua_event->ctx, (void *)((unsigned long)uctx->ctx), &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node != NULL) { ret = -EEXIST; goto error; @@ -959,9 +959,8 @@ int create_ust_app_event_context(struct ust_app_session *ua_sess, goto error; } - hashtable_node_init(&ua_ctx->node, - (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *)); - hashtable_add_unique(ua_event->ctx, &ua_ctx->node); + lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx); + lttng_ht_add_unique_ulong(ua_event->ctx, &ua_ctx->node); ret = create_ust_event_context(ua_event, ua_ctx, app); if (ret < 0) { @@ -1038,15 +1037,15 @@ static int enable_ust_app_channel(struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan, struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *ua_chan_node; + struct lttng_ht_iter iter; + struct lttng_ht_node_str *ua_chan_node; struct ust_app_channel *ua_chan; - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), &iter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter); + ua_chan_node = lttng_ht_iter_get_node_str(&iter); if (ua_chan_node == NULL) { - DBG2("Unable to find channel %s in ust session uid %u", - uchan->name, ua_sess->uid); + DBG2("Unable to find channel %s in ust session id %u", + uchan->name, ua_sess->id); goto error; } @@ -1069,35 +1068,42 @@ static struct ust_app_channel *create_ust_app_channel( struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *ua_chan_node; + struct lttng_ht_iter iter; + struct lttng_ht_node_str *ua_chan_node; struct ust_app_channel *ua_chan; /* 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) { - DBG2("Unable to find channel %s in ust session uid %u", - uchan->name, ua_sess->uid); - ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr); - if (ua_chan == NULL) { - goto error; - } - shadow_copy_channel(ua_chan, uchan); - - hashtable_add_unique(ua_sess->channels, &ua_chan->node); - } else { + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter); + ua_chan_node = lttng_ht_iter_get_node_str(&iter); + if (ua_chan_node != NULL) { ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node); + goto end; + } + + ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr); + if (ua_chan == NULL) { + /* Only malloc can fail here */ + goto error; } + shadow_copy_channel(ua_chan, uchan); ret = create_ust_channel(app, ua_sess, ua_chan); if (ret < 0) { + /* Not found previously means that it does not exist on the tracer */ + assert(ret != -EEXIST); goto error; } + 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->key.pid); + +end: return ua_chan; error: + delete_ust_app_channel(-1, ua_chan); return NULL; } @@ -1110,16 +1116,15 @@ int create_ust_app_event(struct ust_app_session *ua_sess, struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *ua_event_node; + struct lttng_ht_iter iter; + struct lttng_ht_node_str *ua_event_node; struct ust_app_event *ua_event; /* Get event node */ - ua_event_node = hashtable_lookup(ua_chan->events, - (void *)uevent->attr.name, strlen(uevent->attr.name), &iter); + lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter); + ua_event_node = lttng_ht_iter_get_node_str(&iter); if (ua_event_node != NULL) { - ERR("UST app event %s already exist. Stopping creation.", - uevent->attr.name); + ret = -EEXIST; goto end; } @@ -1128,28 +1133,29 @@ int create_ust_app_event(struct ust_app_session *ua_sess, if (ua_event == NULL) { /* Only malloc can failed so something is really wrong */ ret = -ENOMEM; - goto error; + goto end; } shadow_copy_event(ua_event, uevent); /* 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(); + /* Not found previously means that it does not exist on the tracer */ + assert(ret != -EEXIST); goto error; } - ua_event->enabled = 1; - - hashtable_add_unique(ua_chan->events, &ua_event->node); + lttng_ht_add_unique_str(ua_chan->events, &ua_event->node); - DBG2("UST app create event %s for PID %d completed", - ua_event->name, app->key.pid); + DBG2("UST app create event %s for PID %d completed", ua_event->name, + app->key.pid); end: + return ret; + error: + /* Valid. Calling here is already in a read side lock */ + delete_ust_app_event(-1, ua_event); return ret; } @@ -1160,19 +1166,19 @@ static int create_ust_app_metadata(struct ust_app_session *ua_sess, char *pathname, struct ust_app *app) { int ret = 0; - mode_t old_umask; if (ua_sess->metadata == NULL) { /* Allocate UST metadata */ ua_sess->metadata = trace_ust_create_metadata(pathname); if (ua_sess->metadata == NULL) { - ERR("UST app session %d creating metadata failed", - ua_sess->handle); + /* malloc() failed */ goto error; } ret = open_ust_metadata(app, ua_sess); if (ret < 0) { + /* Cleanup failed metadata struct */ + free(ua_sess->metadata); goto error; } @@ -1186,13 +1192,12 @@ static int create_ust_app_metadata(struct ust_app_session *ua_sess, goto error; } - old_umask = umask(0); - ret = mkdir(ua_sess->path, S_IRWXU | S_IRWXG); + ret = mkdir_run_as(ua_sess->path, S_IRWXU | S_IRWXG, + ua_sess->uid, ua_sess->gid); 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); @@ -1217,7 +1222,7 @@ error: /* * Return pointer to traceable apps list. */ -struct cds_lfht *ust_app_get_ht(void) +struct lttng_ht *ust_app_get_ht(void) { return ust_app_ht; } @@ -1227,12 +1232,12 @@ struct cds_lfht *ust_app_get_ht(void) */ struct ust_app *ust_app_find_by_pid(pid_t pid) { - struct cds_lfht_node *node; - struct cds_lfht_iter iter; + struct lttng_ht_node_ulong *node; + struct lttng_ht_iter iter; rcu_read_lock(); - node = hashtable_lookup(ust_app_ht, - (void *)((unsigned long) pid), sizeof(void *), &iter); + lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node == NULL) { DBG2("UST app no found with pid %d", pid); goto error; @@ -1281,19 +1286,17 @@ int ust_app_register(struct ust_register_msg *msg, int sock) lta->v_minor = msg->minor; strncpy(lta->name, msg->name, sizeof(lta->name)); lta->name[16] = '\0'; - lta->sessions = hashtable_new(0); + lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); /* Set key map */ lta->key.pid = msg->pid; - hashtable_node_init(<a->node, (void *)((unsigned long)lta->key.pid), - sizeof(void *)); + lttng_ht_node_init_ulong(<a->node, (unsigned long)lta->key.pid); lta->key.sock = sock; - hashtable_node_init(<a->key.node, (void *)((unsigned long)lta->key.sock), - sizeof(void *)); + lttng_ht_node_init_ulong(<a->key.node, (unsigned long)lta->key.sock); rcu_read_lock(); - hashtable_add_unique(ust_app_sock_key_map, <a->key.node); - hashtable_add_unique(ust_app_ht, <a->node); + lttng_ht_add_unique_ulong(ust_app_sock_key_map, <a->key.node); + lttng_ht_add_unique_ulong(ust_app_ht, <a->node); rcu_read_unlock(); DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s" @@ -1312,8 +1315,8 @@ int ust_app_register(struct ust_register_msg *msg, int sock) void ust_app_unregister(int sock) { struct ust_app *lta; - struct cds_lfht_node *node; - struct cds_lfht_iter iter; + struct lttng_ht_node_ulong *node; + struct lttng_ht_iter iter; int ret; rcu_read_lock(); @@ -1325,15 +1328,21 @@ void ust_app_unregister(int sock) DBG("PID %d unregistering with sock %d", lta->key.pid, sock); + /* Remove application from socket hash table */ + lttng_ht_lookup(ust_app_sock_key_map, (void *)((unsigned long) sock), &iter); + ret = lttng_ht_del(ust_app_sock_key_map, &iter); + assert(!ret); + /* Get the node reference for a call_rcu */ - node = hashtable_lookup(ust_app_ht, - (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter); + lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) lta->key.pid), &iter); + node = lttng_ht_iter_get_node_ulong(&iter); if (node == NULL) { ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid); goto error; } - ret = hashtable_del(ust_app_ht, &iter); + /* Remove application from PID hash table */ + ret = lttng_ht_del(ust_app_ht, &iter); assert(!ret); call_rcu(&node->head, delete_ust_app_rcu); error: @@ -1349,7 +1358,7 @@ unsigned long ust_app_list_count(void) unsigned long count; rcu_read_lock(); - count = hashtable_get_count(ust_app_ht); + count = lttng_ht_get_count(ust_app_ht); rcu_read_unlock(); return count; @@ -1362,7 +1371,7 @@ int ust_app_list_events(struct lttng_event **events) { int ret, handle; size_t nbmem, count = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; struct lttng_event *tmp; @@ -1376,8 +1385,8 @@ int ust_app_list_events(struct lttng_event **events) rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { - struct lttng_ust_tracepoint_iter iter; + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { + struct lttng_ust_tracepoint_iter uiter; handle = ustctl_tracepoint_list(app->key.sock); if (handle < 0) { @@ -1387,7 +1396,7 @@ int ust_app_list_events(struct lttng_event **events) } while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle, - &iter)) != -ENOENT) { + &uiter)) != -ENOENT) { if (count >= nbmem) { DBG2("Reallocating event list from %zu to %zu entries", nbmem, 2 * nbmem); @@ -1399,9 +1408,9 @@ int ust_app_list_events(struct lttng_event **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; + memcpy(tmp[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN); + memcpy(tmp[count].loglevel, uiter.loglevel, LTTNG_UST_SYM_NAME_LEN); + tmp[count].loglevel_value = uiter.loglevel_value; tmp[count].type = LTTNG_UST_TRACEPOINT; tmp[count].pid = app->key.pid; tmp[count].enabled = -1; @@ -1426,21 +1435,27 @@ error: void ust_app_clean_list(void) { int ret; - struct cds_lfht_iter iter; - struct ust_app *app; + struct lttng_ht_iter iter; + struct lttng_ht_node_ulong *node; DBG2("UST app cleaning registered apps hash table"); rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { - ret = hashtable_del(ust_app_ht, &iter); + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, node, node) { + ret = lttng_ht_del(ust_app_ht, &iter); assert(!ret); - call_rcu(&iter.node->head, delete_ust_app_rcu); + call_rcu(&node->head, delete_ust_app_rcu); } + /* Destroy is done only when the ht is empty */ + lttng_ht_destroy(ust_app_ht); - hashtable_destroy(ust_app_ht); - hashtable_destroy(ust_app_sock_key_map); + cds_lfht_for_each_entry(ust_app_sock_key_map->ht, &iter.iter, node, node) { + ret = lttng_ht_del(ust_app_sock_key_map, &iter); + assert(!ret); + } + /* Destroy is done only when the ht is empty */ + lttng_ht_destroy(ust_app_sock_key_map); rcu_read_unlock(); } @@ -1450,8 +1465,8 @@ void ust_app_clean_list(void) */ void ust_app_ht_alloc(void) { - ust_app_ht = hashtable_new(0); - ust_app_sock_key_map = hashtable_new(0); + ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + ust_app_sock_key_map = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); } /* @@ -1461,8 +1476,8 @@ int ust_app_disable_channel_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan) { int ret = 0; - struct cds_lfht_iter iter; - struct cds_lfht_node *ua_chan_node; + struct lttng_ht_iter iter; + struct lttng_ht_node_str *ua_chan_node; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; @@ -1473,21 +1488,22 @@ int ust_app_disable_channel_glb(struct ltt_ust_session *usess, goto error; } - DBG2("UST app disabling channel %s from global domain for session uid %d", - uchan->name, usess->uid); + DBG2("UST app disabling channel %s from global domain for session id %d", + uchan->name, usess->id); rcu_read_lock(); /* For every registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { + struct lttng_ht_iter uiter; ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { continue; } /* Get channel */ - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), &iter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); /* If the session if found for the app, the channel must be there */ assert(ua_chan_node); @@ -1516,7 +1532,7 @@ int ust_app_enable_channel_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; struct ust_app_session *ua_sess; @@ -1526,13 +1542,13 @@ int ust_app_enable_channel_glb(struct ltt_ust_session *usess, goto error; } - DBG2("UST app enabling channel %s to global domain for session uid %d", - uchan->name, usess->uid); + DBG2("UST app enabling channel %s to global domain for session id %d", + uchan->name, usess->id); rcu_read_lock(); /* For every registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { continue; @@ -1559,20 +1575,20 @@ int ust_app_disable_event_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent) { int ret = 0; - struct cds_lfht_iter iter, uiter; - struct cds_lfht_node *ua_chan_node, *ua_event_node; + struct lttng_ht_iter iter, uiter; + struct lttng_ht_node_str *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 all apps in channel " - "%s for session uid %d", uevent->attr.name, uchan->name, usess->uid); + "%s for session id %d", uevent->attr.name, uchan->name, usess->id); rcu_read_lock(); /* For all registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { /* Next app */ @@ -1580,17 +1596,17 @@ int ust_app_disable_event_glb(struct ltt_ust_session *usess, } /* Lookup channel in the ust app session */ - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); if (ua_chan_node == NULL) { - DBG2("Channel %s not found in session uid %d for app pid %d." - "Skipping", uchan->name, usess->uid, app->key.pid); + DBG2("Channel %s not found in session id %d for app pid %d." + "Skipping", uchan->name, usess->id, app->key.pid); continue; } 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), &uiter); + lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter); + ua_event_node = lttng_ht_iter_get_node_str(&uiter); if (ua_event_node == NULL) { DBG2("Event %s not found in channel %s for app pid %d." "Skipping", uevent->attr.name, uchan->name, app->key.pid); @@ -1618,34 +1634,35 @@ int ust_app_disable_all_event_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan) { int ret = 0; - struct cds_lfht_iter iter, uiter; - struct cds_lfht_node *ua_chan_node; + struct lttng_ht_iter iter, uiter; + struct lttng_ht_node_str *ua_chan_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 all event for all apps in channel " - "%s for session uid %d", uchan->name, usess->uid); + "%s for session id %d", uchan->name, usess->id); rcu_read_lock(); /* For all registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { 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), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); /* 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); /* Disable each events of channel */ - cds_lfht_for_each_entry(ua_chan->events, &uiter, ua_event, node) { + cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event, + node.node) { ret = disable_ust_app_event(ua_sess, ua_event, app); if (ret < 0) { /* XXX: Report error someday... */ @@ -1665,25 +1682,22 @@ int ust_app_disable_all_event_glb(struct ltt_ust_session *usess, int ust_app_create_channel_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan) { - int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; - if (usess == NULL || uchan == NULL) { - ERR("Adding UST global channel to NULL values"); - ret = -1; - goto error; - } + /* Very wrong code flow */ + assert(usess); + assert(uchan); - DBG2("UST app adding channel %s to global domain for session uid %d", - uchan->name, usess->uid); + DBG2("UST app adding channel %s to global domain for session id %d", + uchan->name, usess->id); rcu_read_lock(); /* For every registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { /* * Create session on the tracer side and add it to app session HT. Note * that if session exist, it will simply return a pointer to the ust @@ -1691,20 +1705,24 @@ int ust_app_create_channel_glb(struct ltt_ust_session *usess, */ ua_sess = create_ust_app_session(usess, app); if (ua_sess == NULL) { - continue; + /* Major problem here and it's maybe the tracer or malloc() */ + goto error; } /* Create channel onto application */ ua_chan = create_ust_app_channel(ua_sess, uchan, app); if (ua_chan == NULL) { - continue; + /* Major problem here and it's maybe the tracer or malloc() */ + goto error; } } rcu_read_unlock(); + return 0; + error: - return ret; + return -1; } /* @@ -1714,15 +1732,15 @@ int ust_app_enable_event_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent) { int ret = 0; - struct cds_lfht_iter iter, uiter; - struct cds_lfht_node *ua_chan_node, *ua_event_node; + struct lttng_ht_iter iter, uiter; + struct lttng_ht_node_str *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 all apps for session uid %d", - uevent->attr.name, usess->uid); + DBG("UST app enabling event %s for all apps for session id %d", + uevent->attr.name, usess->id); /* * NOTE: At this point, this function is called only if the session and @@ -1733,21 +1751,21 @@ int ust_app_enable_event_glb(struct ltt_ust_session *usess, rcu_read_lock(); /* For all registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { 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), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); /* 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), &uiter); + lttng_ht_lookup(ua_chan->events, (void*)uevent->attr.name, &uiter); + ua_event_node = lttng_ht_iter_get_node_str(&uiter); if (ua_event_node == NULL) { DBG3("UST app enable event %s not found for app PID %d." "Skipping app", uevent->attr.name, app->key.pid); @@ -1774,32 +1792,26 @@ int ust_app_create_event_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent) { int ret = 0; - struct cds_lfht_iter iter, uiter; - struct cds_lfht_node *ua_chan_node; + struct lttng_ht_iter iter, uiter; + struct lttng_ht_node_str *ua_chan_node; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; - DBG("UST app creating event %s for all apps for session uid %d", - uevent->attr.name, usess->uid); - - /* - * NOTE: At this point, this function is called only if the session and - * channel passed are already created for all apps. and enabled on the - * tracer also. - */ + DBG("UST app creating event %s for all apps for session id %d", + uevent->attr.name, usess->id); rcu_read_lock(); /* For all registered applications */ - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { 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), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); /* If the channel is not found, there is a code flow error */ assert(ua_chan_node); @@ -1807,6 +1819,12 @@ int ust_app_create_event_glb(struct ltt_ust_session *usess, ret = create_ust_app_event(ua_sess, ua_chan, uevent, app); if (ret < 0) { + if (ret != -EEXIST) { + /* Possible value at this point: -ENOMEM. If so, we stop! */ + break; + } + DBG2("UST app event %s already exist on app PID %d", + uevent->attr.name, app->key.pid); continue; } } @@ -1822,7 +1840,7 @@ int ust_app_create_event_glb(struct ltt_ust_session *usess, int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; struct ltt_ust_stream *ustream; @@ -1848,7 +1866,8 @@ int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app) } /* For each channel */ - cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) { + cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan, + node.node) { /* Create all streams */ while (1) { /* Create UST stream */ @@ -1925,7 +1944,9 @@ error_rcu_unlock: int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app) { int ret = 0; + struct lttng_ht_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); @@ -1937,34 +1958,38 @@ int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app) 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); + /* This inhibits UST tracing */ + ret = ustctl_stop_session(app->key.sock, ua_sess->handle); if (ret < 0) { - ERR("UST metadata flush failed"); + ERR("Error stopping tracing for app pid: %d", app->key.pid); + goto error_rcu_unlock; } - cds_list_for_each_entry(ustchan, &usess->channels.head, list) { - ret = ustctl_flush_buffer(usess->sock, ustchan->obj); + /* Quiescent wait after stopping trace */ + ustctl_wait_quiescent(app->key.sock); + + /* Flushing buffers */ + cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan, + node.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); + /* Flush all buffers before stopping */ + ret = ustctl_sock_flush_buffer(app->key.sock, ua_sess->metadata->obj); if (ret < 0) { - ERR("Error stopping tracing for app pid: %d", app->key.pid); - goto error_rcu_unlock; + ERR("UST app PID %d metadata flush failed", app->key.pid); + ERR("Ended with ret %d", ret); } rcu_read_unlock(); - /* Quiescent wait after stopping trace */ - ustctl_wait_quiescent(app->key.sock); - return 0; error_rcu_unlock: @@ -1979,8 +2004,8 @@ int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app) { struct ust_app_session *ua_sess; struct lttng_ust_object_data obj; - struct cds_lfht_iter iter; - struct cds_lfht_node *node; + struct lttng_ht_iter iter; + struct lttng_ht_node_ulong *node; int ret; DBG("Destroy tracing for ust app pid %d", app->key.pid); @@ -1988,13 +2013,13 @@ int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app) rcu_read_lock(); __lookup_session_by_app(usess, app, &iter); - node = hashtable_iter_get_node(&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; } ua_sess = caa_container_of(node, struct ust_app_session, node); - ret = hashtable_del(app->sessions, &iter); + ret = lttng_ht_del(app->sessions, &iter); assert(!ret); delete_ust_app_session(app->key.sock, ua_sess); obj.handle = ua_sess->handle; @@ -2021,14 +2046,14 @@ error_rcu_unlock: int ust_app_start_trace_all(struct ltt_ust_session *usess) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; DBG("Starting all UST traces"); rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ret = ust_app_start_trace(usess, app); if (ret < 0) { /* Continue to next apps even on error */ @@ -2047,14 +2072,14 @@ int ust_app_start_trace_all(struct ltt_ust_session *usess) int ust_app_stop_trace_all(struct ltt_ust_session *usess) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; DBG("Stopping all UST traces"); rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ret = ust_app_stop_trace(usess, app); if (ret < 0) { /* Continue to next apps even on error */ @@ -2073,14 +2098,14 @@ int ust_app_stop_trace_all(struct ltt_ust_session *usess) int ust_app_destroy_trace_all(struct ltt_ust_session *usess) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter; struct ust_app *app; DBG("Destroy all UST traces"); rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ret = ust_app_destroy_trace(usess, app); if (ret < 0) { /* Continue to next apps even on error */ @@ -2099,7 +2124,7 @@ int ust_app_destroy_trace_all(struct ltt_ust_session *usess) void ust_app_global_update(struct ltt_ust_session *usess, int sock) { int ret = 0; - struct cds_lfht_iter iter; + struct lttng_ht_iter iter, uiter; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; @@ -2110,8 +2135,8 @@ void ust_app_global_update(struct ltt_ust_session *usess, int sock) goto error; } - DBG2("UST app global update for app sock %d for session uid %d", sock, - usess->uid); + DBG2("UST app global update for app sock %d for session id %d", sock, + usess->id); rcu_read_lock(); @@ -2131,7 +2156,8 @@ void ust_app_global_update(struct ltt_ust_session *usess, int sock) * app session above made a shadow copy of the UST global domain from the * ltt ust session. */ - cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) { + cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan, + node.node) { ret = create_ust_channel(app, ua_sess, ua_chan); if (ret < 0) { /* FIXME: Should we quit here or continue... */ @@ -2139,7 +2165,8 @@ void ust_app_global_update(struct ltt_ust_session *usess, int sock) } /* For each events */ - cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) { + cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event, + node.node) { ret = create_ust_event(app, ua_sess, ua_chan, ua_event); if (ret < 0) { /* FIXME: Should we quit here or continue... */ @@ -2169,23 +2196,23 @@ int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess, struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx) { int ret = 0; - struct cds_lfht_node *ua_chan_node; - struct cds_lfht_iter iter, uiter; + struct lttng_ht_node_str *ua_chan_node; + struct lttng_ht_iter iter, uiter; struct ust_app_channel *ua_chan = NULL; struct ust_app_session *ua_sess; struct ust_app *app; rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { continue; } /* Lookup channel in the ust app session */ - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); if (ua_chan_node == NULL) { continue; } @@ -2210,8 +2237,8 @@ int ust_app_add_ctx_event_glb(struct ltt_ust_session *usess, struct ltt_ust_context *uctx) { int ret = 0; - struct cds_lfht_node *ua_chan_node, *ua_event_node; - struct cds_lfht_iter iter, uiter; + struct lttng_ht_node_str *ua_chan_node, *ua_event_node; + struct lttng_ht_iter iter, uiter; struct ust_app_session *ua_sess; struct ust_app_event *ua_event; struct ust_app_channel *ua_chan = NULL; @@ -2219,23 +2246,23 @@ int ust_app_add_ctx_event_glb(struct ltt_ust_session *usess, rcu_read_lock(); - cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, node.node) { ua_sess = lookup_session_by_app(usess, app); if (ua_sess == NULL) { continue; } /* Lookup channel in the ust app session */ - ua_chan_node = hashtable_lookup(ua_sess->channels, - (void *)uchan->name, strlen(uchan->name), &uiter); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter); + ua_chan_node = lttng_ht_iter_get_node_str(&uiter); if (ua_chan_node == NULL) { continue; } 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), &uiter); + lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter); + ua_event_node = lttng_ht_iter_get_node_str(&uiter); if (ua_event_node == NULL) { continue; } @@ -2259,8 +2286,8 @@ 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 lttng_ht_iter iter; + struct lttng_ht_node_str *ua_chan_node, *ua_event_node; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; @@ -2282,15 +2309,15 @@ int ust_app_enable_event_pid(struct ltt_ust_session *usess, 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); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter); + ua_chan_node = lttng_ht_iter_get_node_str(&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); + lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter); + ua_event_node = lttng_ht_iter_get_node_str(&iter); if (ua_event_node == NULL) { ret = create_ust_app_event(ua_sess, ua_chan, uevent, app); if (ret < 0) { @@ -2317,8 +2344,8 @@ 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 lttng_ht_iter iter; + struct lttng_ht_node_str *ua_chan_node, *ua_event_node; struct ust_app *app; struct ust_app_session *ua_sess; struct ust_app_channel *ua_chan; @@ -2340,16 +2367,16 @@ int ust_app_disable_event_pid(struct ltt_ust_session *usess, 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); + lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter); + ua_chan_node = lttng_ht_iter_get_node_str(&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); + lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter); + ua_event_node = lttng_ht_iter_get_node_str(&iter); if (ua_event_node == NULL) { /* Event does not exist, skip disabling */ goto error;