X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fagent.c;h=a4b1510f5dfe387ba567430f0037840589017529;hp=45a3045ddfe57f57faea2973e46021fc7e34a68c;hb=a33c2651cf40c30d86a0b93eec7088cc0e74dd05;hpb=6a4e403927ffef4cae8726064dcf53c463eb128c diff --git a/src/bin/lttng-sessiond/agent.c b/src/bin/lttng-sessiond/agent.c index 45a3045dd..a4b1510f5 100644 --- a/src/bin/lttng-sessiond/agent.c +++ b/src/bin/lttng-sessiond/agent.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2013 - David Goulet + * Copyright (C) 2016 - Jérémie Galarneau * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License, version 2 only, as @@ -15,10 +16,10 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE #define _LGPL_SOURCE #include #include +#include #include #include @@ -28,6 +29,58 @@ #include "agent.h" #include "ust-app.h" #include "utils.h" +#include "error.h" + +#define AGENT_RET_CODE_INDEX(code) (code - AGENT_RET_CODE_SUCCESS) + +/* + * Agent application context representation. + */ +struct agent_app_ctx { + char *provider_name; + char *ctx_name; + + /* agent_app_ctx are part of the agent app_ctx_list. */ + struct cds_list_head list_node; + + /* For call_rcu teardown. */ + struct rcu_head rcu_node; +}; + +/* + * Human readable agent return code. + */ +static const char *error_string_array[] = { + [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_SUCCESS) ] = "Success", + [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_INVALID) ] = "Invalid command", + [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_UNKNOWN_NAME) ] = "Unknown logger name", + + /* Last element */ + [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_NR) ] = "Unknown code", +}; + +static +void log_reply_code(uint32_t in_reply_ret_code) +{ + int level = PRINT_DBG3; + /* + * reply_ret_code and in_reply_ret_code are kept separate to have a + * sanitized value (used to retrieve the human readable string) and the + * original value which is logged as-is. + */ + uint32_t reply_ret_code = in_reply_ret_code; + + if (reply_ret_code < AGENT_RET_CODE_SUCCESS || + reply_ret_code >= AGENT_RET_CODE_NR) { + reply_ret_code = AGENT_RET_CODE_NR; + level = PRINT_ERR; + } + + LOG(level, "Agent replied with retcode: %s (%"PRIu32")", + error_string_array[AGENT_RET_CODE_INDEX( + reply_ret_code)], + in_reply_ret_code); +} /* * Match function for the events hash table lookup by name. @@ -65,6 +118,7 @@ static int ht_match_event(struct cds_lfht_node *node, { struct agent_event *event; const struct agent_ht_key *key; + int ll_match; assert(node); assert(_key); @@ -79,14 +133,21 @@ static int ht_match_event(struct cds_lfht_node *node, goto no_match; } - if (event->loglevel != key->loglevel) { - if (event->loglevel_type == LTTNG_EVENT_LOGLEVEL_ALL && - key->loglevel == 0 && event->loglevel == -1) { - goto match; - } + /* Event loglevel value and type. */ + ll_match = loglevels_match(event->loglevel_type, + event->loglevel_value, key->loglevel_type, + key->loglevel_value, LTTNG_EVENT_LOGLEVEL_ALL); + + if (!ll_match) { goto no_match; } -match: + + /* Filter expression */ + if (strncmp(event->filter_expression, key->filter_expression, + strlen(event->filter_expression)) != 0) { + goto no_match; + } + return 1; no_match: @@ -107,7 +168,9 @@ static void add_unique_agent_event(struct lttng_ht *ht, assert(event); key.name = event->name; - key.loglevel = event->loglevel; + key.loglevel_value = event->loglevel_value; + key.loglevel_type = event->loglevel_type; + key.filter_expression = event->filter_expression; node_ptr = cds_lfht_add_unique(ht->ht, ht->hash_fct(event->node.key, lttng_ht_seed), @@ -125,7 +188,7 @@ static void destroy_event_agent_rcu(struct rcu_head *head) struct agent_event *event = caa_container_of(node, struct agent_event, node); - free(event); + agent_destroy_event(event); } /* @@ -178,7 +241,7 @@ error: * * Return 0 on success or else a negative errno value of sendmsg() op. */ -static int send_payload(struct lttcomm_sock *sock, void *data, +static int send_payload(struct lttcomm_sock *sock, const void *data, size_t size) { int ret; @@ -235,6 +298,7 @@ static ssize_t list_events(struct agent_app *app, struct lttng_event **events) int ret, i, len = 0, offset = 0; uint32_t nb_event; size_t data_size; + uint32_t reply_ret_code; struct lttng_event *tmp_events = NULL; struct lttcomm_agent_list_reply *reply = NULL; struct lttcomm_agent_list_reply_hdr reply_hdr; @@ -257,14 +321,14 @@ static ssize_t list_events(struct agent_app *app, struct lttng_event **events) goto error_io; } - switch (be32toh(reply_hdr.ret_code)) { + reply_ret_code = be32toh(reply_hdr.ret_code); + log_reply_code(reply_ret_code); + switch (reply_ret_code) { case AGENT_RET_CODE_SUCCESS: data_size = be32toh(reply_hdr.data_size) + sizeof(*reply); break; default: - ERR("Agent returned an unknown code: %" PRIu32, - be32toh(reply_hdr.ret_code)); - ret = LTTNG_ERR_FATAL; + ret = LTTNG_ERR_UNK; goto error; } @@ -319,8 +383,11 @@ error: static int enable_event(struct agent_app *app, struct agent_event *event) { int ret; + char *bytes_to_send; uint64_t data_size; - struct lttcomm_agent_enable msg; + size_t filter_expression_length; + uint32_t reply_ret_code; + struct lttcomm_agent_enable_event msg; struct lttcomm_agent_generic_reply reply; assert(app); @@ -330,7 +397,16 @@ static int enable_event(struct agent_app *app, struct agent_event *event) DBG2("Agent enabling event %s for app pid: %d and socket %d", event->name, app->pid, app->sock->fd); - data_size = sizeof(msg); + /* + * Calculate the payload's size, which is the fixed-size struct followed + * by the variable-length filter expression (+1 for the ending \0). + */ + if (!event->filter_expression) { + filter_expression_length = 0; + } else { + filter_expression_length = strlen(event->filter_expression) + 1; + } + data_size = sizeof(msg) + filter_expression_length; ret = send_header(app->sock, data_size, AGENT_CMD_ENABLE, 0); if (ret < 0) { @@ -338,10 +414,25 @@ static int enable_event(struct agent_app *app, struct agent_event *event) } memset(&msg, 0, sizeof(msg)); - msg.loglevel = event->loglevel; - msg.loglevel_type = event->loglevel_type; + msg.loglevel_value = htobe32(event->loglevel_value); + msg.loglevel_type = htobe32(event->loglevel_type); strncpy(msg.name, event->name, sizeof(msg.name)); - ret = send_payload(app->sock, &msg, sizeof(msg)); + msg.filter_expression_length = htobe32(filter_expression_length); + + bytes_to_send = zmalloc(data_size); + if (!bytes_to_send) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + + memcpy(bytes_to_send, &msg, sizeof(msg)); + if (filter_expression_length > 0) { + memcpy(bytes_to_send + sizeof(msg), event->filter_expression, + filter_expression_length); + } + + ret = send_payload(app->sock, bytes_to_send, data_size); + free(bytes_to_send); if (ret < 0) { goto error_io; } @@ -351,16 +442,122 @@ static int enable_event(struct agent_app *app, struct agent_event *event) goto error_io; } - switch (be32toh(reply.ret_code)) { + reply_ret_code = be32toh(reply.ret_code); + log_reply_code(reply_ret_code); + switch (reply_ret_code) { case AGENT_RET_CODE_SUCCESS: break; case AGENT_RET_CODE_UNKNOWN_NAME: ret = LTTNG_ERR_UST_EVENT_NOT_FOUND; goto error; default: - ERR("Agent returned an unknown code: %" PRIu32, - be32toh(reply.ret_code)); - ret = LTTNG_ERR_FATAL; + ret = LTTNG_ERR_UNK; + goto error; + } + + return LTTNG_OK; + +error_io: + ret = LTTNG_ERR_UST_ENABLE_FAIL; +error: + return ret; +} + +/* + * Send Pascal-style string. Size is sent as a 32-bit big endian integer. + */ +static +int send_pstring(struct lttcomm_sock *sock, const char *str, uint32_t len) +{ + int ret; + uint32_t len_be; + + len_be = htobe32(len); + ret = send_payload(sock, &len_be, sizeof(len_be)); + if (ret) { + goto end; + } + + ret = send_payload(sock, str, len); + if (ret) { + goto end; + } +end: + return ret; +} + +/* + * Internal enable application context on an agent application. This function + * communicates with the agent to enable a given application context. + * + * Return LTTNG_OK on success or else a LTTNG_ERR* code. + */ +static int app_context_op(struct agent_app *app, + struct agent_app_ctx *ctx, enum lttcomm_agent_command cmd) +{ + int ret; + uint32_t reply_ret_code; + struct lttcomm_agent_generic_reply reply; + size_t app_ctx_provider_name_len, app_ctx_name_len, data_size; + + assert(app); + assert(app->sock); + assert(ctx); + assert(cmd == AGENT_CMD_APP_CTX_ENABLE || + cmd == AGENT_CMD_APP_CTX_DISABLE); + + DBG2("Agent %s application %s:%s for app pid: %d and socket %d", + cmd == AGENT_CMD_APP_CTX_ENABLE ? "enabling" : "disabling", + ctx->provider_name, ctx->ctx_name, + app->pid, app->sock->fd); + + /* + * Calculate the payload's size, which consists of the size (u32, BE) + * of the provider name, the NULL-terminated provider name string, the + * size (u32, BE) of the context name, followed by the NULL-terminated + * context name string. + */ + app_ctx_provider_name_len = strlen(ctx->provider_name) + 1; + app_ctx_name_len = strlen(ctx->ctx_name) + 1; + data_size = sizeof(uint32_t) + app_ctx_provider_name_len + + sizeof(uint32_t) + app_ctx_name_len; + + ret = send_header(app->sock, data_size, cmd, 0); + if (ret < 0) { + goto error_io; + } + + if (app_ctx_provider_name_len > UINT32_MAX || + app_ctx_name_len > UINT32_MAX) { + ERR("Application context name > MAX_UINT32"); + ret = LTTNG_ERR_INVALID; + goto error; + } + + ret = send_pstring(app->sock, ctx->provider_name, + (uint32_t) app_ctx_provider_name_len); + if (ret < 0) { + goto error_io; + } + + ret = send_pstring(app->sock, ctx->ctx_name, + (uint32_t) app_ctx_name_len); + if (ret < 0) { + goto error_io; + } + + ret = recv_reply(app->sock, &reply, sizeof(reply)); + if (ret < 0) { + goto error_io; + } + + reply_ret_code = be32toh(reply.ret_code); + log_reply_code(reply_ret_code); + switch (reply_ret_code) { + case AGENT_RET_CODE_SUCCESS: + break; + default: + ret = LTTNG_ERR_UNK; goto error; } @@ -382,7 +579,8 @@ static int disable_event(struct agent_app *app, struct agent_event *event) { int ret; uint64_t data_size; - struct lttcomm_agent_disable msg; + uint32_t reply_ret_code; + struct lttcomm_agent_disable_event msg; struct lttcomm_agent_generic_reply reply; assert(app); @@ -411,16 +609,16 @@ static int disable_event(struct agent_app *app, struct agent_event *event) goto error_io; } - switch (be32toh(reply.ret_code)) { + reply_ret_code = be32toh(reply.ret_code); + log_reply_code(reply_ret_code); + switch (reply_ret_code) { case AGENT_RET_CODE_SUCCESS: break; case AGENT_RET_CODE_UNKNOWN_NAME: ret = LTTNG_ERR_UST_EVENT_NOT_FOUND; goto error; default: - ERR("Agent returned an unknown code: %" PRIu32, - be32toh(reply.ret_code)); - ret = LTTNG_ERR_FATAL; + ret = LTTNG_ERR_UNK; goto error; } @@ -485,20 +683,107 @@ error: return ret; } +static +void destroy_app_ctx(struct agent_app_ctx *ctx) +{ + free(ctx->provider_name); + free(ctx->ctx_name); + free(ctx); +} + +static +struct agent_app_ctx *create_app_ctx(struct lttng_event_context *ctx) +{ + struct agent_app_ctx *agent_ctx = NULL; + + if (!ctx) { + goto end; + } + + assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT); + agent_ctx = zmalloc(sizeof(*ctx)); + if (!agent_ctx) { + goto end; + } + + agent_ctx->provider_name = strdup(ctx->u.app_ctx.provider_name); + agent_ctx->ctx_name = strdup(ctx->u.app_ctx.ctx_name); + if (!agent_ctx->provider_name || !agent_ctx->ctx_name) { + destroy_app_ctx(agent_ctx); + agent_ctx = NULL; + } +end: + return agent_ctx; +} + /* - * Disable agent event on every agent applications registered with the session + * Enable agent context on every agent applications registered with the session * daemon. * * Return LTTNG_OK on success or else a LTTNG_ERR* code. */ -int agent_disable_event(struct agent_event *event, +int agent_enable_context(struct lttng_event_context *ctx, enum lttng_domain_type domain) { int ret; struct agent_app *app; struct lttng_ht_iter iter; + assert(ctx); + if (ctx->ctx != LTTNG_EVENT_CONTEXT_APP_CONTEXT) { + ret = LTTNG_ERR_INVALID; + goto error; + } + + rcu_read_lock(); + + cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app, + node.node) { + struct agent_app_ctx *agent_ctx; + + if (app->domain != domain) { + continue; + } + + agent_ctx = create_app_ctx(ctx); + if (!agent_ctx) { + ret = LTTNG_ERR_NOMEM; + goto error_unlock; + } + + /* Enable event on agent application through TCP socket. */ + ret = app_context_op(app, agent_ctx, AGENT_CMD_APP_CTX_ENABLE); + if (ret != LTTNG_OK) { + destroy_app_ctx(agent_ctx); + goto error_unlock; + } + } + + ret = LTTNG_OK; + +error_unlock: + rcu_read_unlock(); +error: + return ret; +} + +/* + * Disable agent event on every agent application registered with the session + * daemon. + * + * Return LTTNG_OK on success or else a LTTNG_ERR* code. + */ +int agent_disable_event(struct agent_event *event, + enum lttng_domain_type domain) +{ + int ret = LTTNG_OK; + struct agent_app *app; + struct lttng_ht_iter iter; + assert(event); + if (!event->enabled) { + goto end; + } rcu_read_lock(); @@ -516,10 +801,43 @@ int agent_disable_event(struct agent_event *event, } event->enabled = 0; - ret = LTTNG_OK; error: rcu_read_unlock(); +end: + return ret; +} + +/* + * Disable agent context on every agent application registered with the session + * daemon. + * + * Return LTTNG_OK on success or else a LTTNG_ERR* code. + */ +int disable_context(struct agent_app_ctx *ctx, enum lttng_domain_type domain) +{ + int ret = LTTNG_OK; + struct agent_app *app; + struct lttng_ht_iter iter; + + assert(ctx); + + rcu_read_lock(); + DBG2("Disabling agent application context %s:%s", + ctx->provider_name, ctx->ctx_name); + cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app, + node.node) { + if (app->domain != domain) { + continue; + } + + ret = app_context_op(app, ctx, AGENT_CMD_APP_CTX_DISABLE); + if (ret != LTTNG_OK) { + goto end; + } + } +end: + rcu_read_unlock(); return ret; } @@ -672,10 +990,7 @@ void agent_add_app(struct agent_app *app) assert(app); DBG3("Agent adding app sock: %d and pid: %d to ht", app->sock->fd, app->pid); - - rcu_read_lock(); lttng_ht_add_unique_ulong(agent_apps_ht_by_sock, &app->node); - rcu_read_unlock(); } /* @@ -732,6 +1047,7 @@ int agent_init(struct agent *agt) } lttng_ht_node_init_u64(&agt->node, agt->domain); + CDS_INIT_LIST_HEAD(&agt->app_ctx_list); return 0; error: @@ -748,9 +1064,7 @@ void agent_add(struct agent *agt, struct lttng_ht *ht) DBG3("Agent adding from domain %d", agt->domain); - rcu_read_lock(); lttng_ht_add_unique_u64(ht, &agt->node); - rcu_read_unlock(); } /* @@ -763,7 +1077,7 @@ struct agent *agent_create(enum lttng_domain_type domain) int ret; struct agent *agt; - agt = zmalloc(sizeof(*agt)); + agt = zmalloc(sizeof(struct agent)); if (!agt) { goto error; } @@ -781,33 +1095,40 @@ error: } /* - * Create a newly allocated agent event data structure. If name is valid, it's - * copied into the created event. + * Create a newly allocated agent event data structure. + * Ownership of filter_expression is taken. * * Return a new object else NULL on error. */ struct agent_event *agent_create_event(const char *name, - struct lttng_filter_bytecode *filter) + enum lttng_loglevel_type loglevel_type, int loglevel_value, + struct lttng_filter_bytecode *filter, char *filter_expression) { - struct agent_event *event; + struct agent_event *event = NULL; - DBG3("Agent create new event with name %s", name); + DBG3("Agent create new event with name %s, loglevel type %d, \ + loglevel value %d and filter %s", + name, loglevel_type, loglevel_value, + filter_expression ? filter_expression : "NULL"); - event = zmalloc(sizeof(*event)); - if (!event) { + if (!name) { + ERR("Failed to create agent event; no name provided."); goto error; } - if (name) { - strncpy(event->name, name, sizeof(event->name)); - event->name[sizeof(event->name) - 1] = '\0'; - lttng_ht_node_init_str(&event->node, event->name); + event = zmalloc(sizeof(*event)); + if (!event) { + goto error; } - if (filter) { - event->filter = filter; - } + strncpy(event->name, name, sizeof(event->name)); + event->name[sizeof(event->name) - 1] = '\0'; + lttng_ht_node_init_str(&event->node, event->name); + event->loglevel_value = loglevel_value; + event->loglevel_type = loglevel_type; + event->filter = filter; + event->filter_expression = filter_expression; error: return event; } @@ -822,59 +1143,91 @@ void agent_add_event(struct agent_event *event, struct agent *agt) assert(agt->events); DBG3("Agent adding event %s", event->name); - - rcu_read_lock(); add_unique_agent_event(agt->events, event); - rcu_read_unlock(); agt->being_used = 1; } /* - * Find a agent event in the given agent using name. + * Unique add of a agent context to an agent object. + */ +int agent_add_context(struct lttng_event_context *ctx, struct agent *agt) +{ + int ret = LTTNG_OK; + struct agent_app_ctx *agent_ctx = NULL; + + assert(ctx); + assert(agt); + assert(agt->events); + assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT); + + agent_ctx = create_app_ctx(ctx); + if (!agent_ctx) { + ret = LTTNG_ERR_NOMEM; + goto end; + } + + DBG3("Agent adding context %s:%s", ctx->u.app_ctx.provider_name, + ctx->u.app_ctx.ctx_name); + cds_list_add_tail_rcu(&agent_ctx->list_node, &agt->app_ctx_list); +end: + return ret; +} + +/* + * Find multiple agent events sharing the given name. * - * RCU read side lock MUST be acquired. + * RCU read side lock MUST be acquired. It must be held for the + * duration of the iteration. * - * Return object if found else NULL. + * Sets the given iterator. */ -struct agent_event *agent_find_event_by_name(const char *name, - struct agent *agt) +void agent_find_events_by_name(const char *name, struct agent *agt, + struct lttng_ht_iter* iter) { - struct lttng_ht_node_str *node; - struct lttng_ht_iter iter; struct lttng_ht *ht; struct agent_ht_key key; assert(name); assert(agt); assert(agt->events); + assert(iter); ht = agt->events; key.name = name; cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed), - ht_match_event_by_name, &key, &iter.iter); - node = lttng_ht_iter_get_node_str(&iter); - if (node == NULL) { - goto error; - } + ht_match_event_by_name, &key, &iter->iter); +} - DBG3("Agent event found %s by name.", name); - return caa_container_of(node, struct agent_event, node); +/* + * Get the next agent event duplicate by name. This should be called + * after a call to agent_find_events_by_name() to iterate on events. + * + * The RCU read lock must be held during the iteration and for as long + * as the object the iterator points to remains in use. + */ +void agent_event_next_duplicate(const char *name, + struct agent *agt, struct lttng_ht_iter* iter) +{ + struct agent_ht_key key; -error: - DBG3("Agent NOT found by name %s.", name); - return NULL; + key.name = name; + + cds_lfht_next_duplicate(agt->events->ht, ht_match_event_by_name, + &key, &iter->iter); } /* - * Find a agent event in the given agent using name and loglevel. + * Find a agent event in the given agent using name, loglevel and filter. * - * RCU read side lock MUST be acquired. + * RCU read side lock MUST be acquired. It must be kept for as long as + * the returned agent_event is used. * * Return object if found else NULL. */ -struct agent_event *agent_find_event(const char *name, int loglevel, - struct agent *agt) +struct agent_event *agent_find_event(const char *name, + enum lttng_loglevel_type loglevel_type, int loglevel_value, + char *filter_expression, struct agent *agt) { struct lttng_ht_node_str *node; struct lttng_ht_iter iter; @@ -887,7 +1240,9 @@ struct agent_event *agent_find_event(const char *name, int loglevel, ht = agt->events; key.name = name; - key.loglevel = loglevel; + key.loglevel_value = loglevel_value; + key.loglevel_type = loglevel_type; + key.filter_expression = filter_expression; cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed), ht_match_event, &key, &iter.iter); @@ -914,39 +1269,43 @@ void agent_destroy_event(struct agent_event *event) assert(event); free(event->filter); + free(event->filter_expression); + free(event->exclusion); free(event); } +static +void destroy_app_ctx_rcu(struct rcu_head *head) +{ + struct agent_app_ctx *ctx = + caa_container_of(head, struct agent_app_ctx, rcu_node); + + destroy_app_ctx(ctx); +} + /* - * Destroy an agent completely. Note that the given pointer is NOT freed - * thus a reference to static or stack data can be passed to this function. + * Destroy an agent completely. */ void agent_destroy(struct agent *agt) { struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + struct agent_app_ctx *ctx; assert(agt); DBG3("Agent destroy"); - /* - * Just ignore if no events hash table exists. This is possible if for - * instance an agent object was allocated but not initialized. - */ - if (!agt->events) { - return; - } - rcu_read_lock(); cds_lfht_for_each_entry(agt->events->ht, &iter.iter, node, node) { int ret; struct agent_event *event; /* - * When destroying an event, we have to try to disable it on the agent - * side so the event stops generating data. The return value is not - * important since we have to continue anyway destroying the object. + * When destroying an event, we have to try to disable it on the + * agent side so the event stops generating data. The return + * value is not important since we have to continue anyway + * destroying the object. */ event = caa_container_of(node, struct agent_event, node); (void) agent_disable_event(event, agt->domain); @@ -955,9 +1314,15 @@ void agent_destroy(struct agent *agt) assert(!ret); call_rcu(&node->head, destroy_event_agent_rcu); } - rcu_read_unlock(); + cds_list_for_each_entry_rcu(ctx, &agt->app_ctx_list, list_node) { + (void) disable_context(ctx, agt->domain); + cds_list_del(&ctx->list_node); + call_rcu(&ctx->rcu_node, destroy_app_ctx_rcu); + } + rcu_read_unlock(); ht_cleanup_push(agt->events); + free(agt); } /* @@ -1009,6 +1374,9 @@ void agent_app_ht_clean(void) struct lttng_ht_node_ulong *node; struct lttng_ht_iter iter; + if (!agent_apps_ht_by_sock) { + return; + } rcu_read_lock(); cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, node, node) { struct agent_app *app; @@ -1033,6 +1401,7 @@ void agent_update(struct agent *agt, int sock) struct agent_app *app; struct agent_event *event; struct lttng_ht_iter iter; + struct agent_app_ctx *ctx; assert(agt); assert(sock >= 0); @@ -1040,19 +1409,18 @@ void agent_update(struct agent *agt, int sock) DBG("Agent updating app socket %d", sock); rcu_read_lock(); + app = agent_find_app_by_sock(sock); + /* + * We are in the registration path thus if the application is gone, + * there is a serious code flow error. + */ + assert(app); cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { /* Skip event if disabled. */ if (!event->enabled) { continue; } - app = agent_find_app_by_sock(sock); - /* - * We are in the registration path thus if the application is gone, - * there is a serious code flow error. - */ - assert(app); - ret = enable_event(app, event); if (ret != LTTNG_OK) { DBG2("Agent update unable to enable event %s on app pid: %d sock %d", @@ -1061,5 +1429,16 @@ void agent_update(struct agent *agt, int sock) continue; } } + + cds_list_for_each_entry_rcu(ctx, &agt->app_ctx_list, list_node) { + ret = app_context_op(app, ctx, AGENT_CMD_APP_CTX_ENABLE); + if (ret != LTTNG_OK) { + DBG2("Agent update unable to add application context %s:%s on app pid: %d sock %d", + ctx->provider_name, ctx->ctx_name, + app->pid, app->sock->fd); + continue; + } + } + rcu_read_unlock(); }