X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=lttng-sessiond%2Fust-app.c;h=ab65f2b1576f2d20ccbdff0bc89e488f81bc2e91;hp=46c3dfdc12442247274801d26a3dac72f58bbf95;hb=88ff5b7f958a7bb60723d10ed97ceb79f9913167;hpb=6414a7130bcd9773f725da602ba3adffe0a37dd9 diff --git a/lttng-sessiond/ust-app.c b/lttng-sessiond/ust-app.c index 46c3dfdc1..ab65f2b15 100644 --- a/lttng-sessiond/ust-app.c +++ b/lttng-sessiond/ust-app.c @@ -26,6 +26,7 @@ #include #include +#include #include #include @@ -47,6 +48,7 @@ static void delete_ust_app_event(int sock, struct ust_app_event *ua_event) //} ustctl_release_object(sock, ua_event->obj); + free(ua_event->obj); free(ua_event); } @@ -56,11 +58,9 @@ static void delete_ust_app_event(int sock, struct ust_app_event *ua_event) */ static void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream) { - //TODO - //stream is used for passing to consumer. - //send_channel_streams is responsible for freeing the streams. - //note that this will not play well with flight recorder mode: - //we might need a criterion to discard the streams. + ustctl_release_object(sock, stream->obj); + free(stream->obj); + free(stream); } /* @@ -75,6 +75,7 @@ static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan) struct ltt_ust_stream *stream, *stmp; cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) { + cds_list_del(&stream->list); delete_ust_app_stream(sock, stream); } @@ -95,6 +96,9 @@ static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan) ERR("UST app destroy session hashtable failed"); goto error; } + ustctl_release_object(sock, ua_chan->obj); + free(ua_chan->obj); + free(ua_chan); error: return; @@ -112,10 +116,10 @@ static void delete_ust_app_session(int sock, struct ust_app_channel *ua_chan; if (ua_sess->metadata) { - /* - * We do NOT release the stream object and metadata object since they - * are release when fds are sent to the consumer. - */ + 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); } cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) { @@ -565,6 +569,16 @@ 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) +{ + /* Get right UST app session from app */ + (void) hashtable_lookup(app->sessions, + (void *) ((unsigned long) usess->uid), sizeof(void *), + iter); +} + /* * Return ust app session from the app session hashtable using the UST session * uid. @@ -575,9 +589,8 @@ static struct ust_app_session *lookup_session_by_app( struct cds_lfht_iter iter; struct cds_lfht_node *node; - /* Get right UST app session from app */ - node = hashtable_lookup(app->sessions, - (void *) ((unsigned long) usess->uid), sizeof(void *), &iter); + __lookup_session_by_app(usess, app, &iter); + node = hashtable_iter_get_node(&iter); if (node == NULL) { goto error; } @@ -815,12 +828,28 @@ error: * Using pid and uid (of the app), allocate a new ust_app struct and * add it to the global traceable app list. * - * On success, return 0, else return malloc ENOMEM. + * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app + * bitness is not supported. */ int ust_app_register(struct ust_register_msg *msg, int sock) { struct ust_app *lta; + /* + * Currently support only tracing of application which share the + * same bitness as the consumer. Eventually implement dispatch + * to specific compat32 consumer. + */ + if (msg->bits_per_long != CAA_BITS_PER_LONG) { + ERR("Registration failed: application \"%s\" (pid: %d) has " + "%d-bit long, but only " + "%d-bit lttng-consumerd is available.\n", + msg->name, msg->pid, msg->bits_per_long, + CAA_BITS_PER_LONG); + close(sock); + return -EINVAL; + } + lta = zmalloc(sizeof(struct ust_app)); if (lta == NULL) { PERROR("malloc"); @@ -1122,6 +1151,10 @@ int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app) goto error_rcu_unlock; } + /* upon restart, we skip the setup, already done */ + if (ua_sess->started) + goto skip_setup; + ret = create_ust_app_metadata(ua_sess, usess->pathname, app); if (ret < 0) { goto error_rcu_unlock; @@ -1165,7 +1198,9 @@ int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app) if (ret < 0) { goto error_rcu_unlock; } + ua_sess->started = 1; +skip_setup: /* This start the UST tracing */ ret = ustctl_start_session(app->key.sock, ua_sess->handle); if (ret < 0) { @@ -1185,6 +1220,100 @@ error_rcu_unlock: return -1; } +/* + * Stop tracing for a specific UST session and app. + */ +int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app) +{ + int ret = 0; + struct ust_app_session *ua_sess; + + DBG("Stopping tracing for ust app pid %d", app->key.pid); + + rcu_read_lock(); + + 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; + } + +#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); + if (ret < 0) { + ERR("UST flush buffer error"); + } + } +#endif + + /* This inhibits UST tracing */ + ret = ustctl_stop_session(app->key.sock, ua_sess->handle); + if (ret < 0) { + ERR("Error stopping tracing for app pid: %d", app->key.pid); + goto error_rcu_unlock; + } + + rcu_read_unlock(); + + /* Quiescent wait after stopping trace */ + ustctl_wait_quiescent(app->key.sock); + + return 0; + +error_rcu_unlock: + rcu_read_unlock(); + return -1; +} + +/* + * Destroy a specific UST session in apps. + */ +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; + + DBG("Destroy tracing for ust app pid %d", app->key.pid); + + rcu_read_lock(); + + __lookup_session_by_app(usess, app, &iter); + node = hashtable_iter_get_node(&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); + hashtable_del(app->sessions, &iter); + delete_ust_app_session(app->key.sock, ua_sess); + obj.handle = ua_sess->handle; + obj.shm_fd = -1; + obj.wait_fd = -1; + obj.memory_map_size = 0; + ustctl_release_object(app->key.sock, &obj); + + rcu_read_unlock(); + + /* Quiescent wait after stopping trace */ + ustctl_wait_quiescent(app->key.sock); + + return 0; + +error_rcu_unlock: + rcu_read_unlock(); + return -1; +} + /* * Start tracing for the UST session. */ @@ -1211,6 +1340,58 @@ int ust_app_start_trace_all(struct ltt_ust_session *usess) return 0; } +/* + * Start tracing for the UST session. + */ +int ust_app_stop_trace_all(struct ltt_ust_session *usess) +{ + int ret = 0; + struct cds_lfht_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) { + ret = ust_app_stop_trace(usess, app); + if (ret < 0) { + /* Continue to next apps even on error */ + continue; + } + } + + rcu_read_unlock(); + + return 0; +} + +/* + * Destroy app UST session. + */ +int ust_app_destroy_trace_all(struct ltt_ust_session *usess) +{ + int ret = 0; + struct cds_lfht_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) { + ret = ust_app_destroy_trace(usess, app); + if (ret < 0) { + /* Continue to next apps even on error */ + continue; + } + } + + rcu_read_unlock(); + + return 0; +} + /* * Add channels/events from UST global domain to registered apps at sock. */