X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fnotification-thread-events.c;h=254aa5396e5d30c102e771545773645ad766311c;hp=0bb75b6d81607954093695ab894b58326a70f0bb;hb=8abe313a6c4f251063e4b72ddd47ce8107384d71;hpb=47a32869a6b2f7014887d523943046c9c64e6458 diff --git a/src/bin/lttng-sessiond/notification-thread-events.c b/src/bin/lttng-sessiond/notification-thread-events.c index 0bb75b6d8..254aa5396 100644 --- a/src/bin/lttng-sessiond/notification-thread-events.c +++ b/src/bin/lttng-sessiond/notification-thread-events.c @@ -19,9 +19,6 @@ #include #include -#include "notification-thread.h" -#include "notification-thread-events.h" -#include "notification-thread-commands.h" #include #include #include @@ -36,12 +33,19 @@ #include #include #include + #include #include #include #include #include +#include "notification-thread.h" +#include "notification-thread-events.h" +#include "notification-thread-commands.h" +#include "lttng-sessiond.h" +#include "kernel.h" + #define CLIENT_POLL_MASK_IN (LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP) #define CLIENT_POLL_MASK_IN_OUT (CLIENT_POLL_MASK_IN | LPOLLOUT) @@ -84,7 +88,7 @@ struct notification_client { uid_t uid; gid_t gid; /* - * Indicates if the credentials and versions of the client has been + * Indicates if the credentials and versions of the client have been * checked. */ bool validated; @@ -97,6 +101,11 @@ struct notification_client { struct cds_lfht_node client_socket_ht_node; struct { struct { + /* + * During the reception of a message, the reception + * buffers' "size" is set to contain the current + * message's complete payload. + */ struct lttng_dynamic_buffer buffer; /* Bytes left to receive for the current message. */ size_t bytes_to_receive; @@ -106,12 +115,13 @@ struct notification_client { * Indicates whether or not credentials are expected * from the client. */ - bool receive_creds; + bool expect_creds; /* * Indicates whether or not credentials were received * from the client. */ bool creds_received; + /* Only used during credentials reception. */ lttng_sock_cred creds; } inbound; struct { @@ -144,6 +154,37 @@ struct channel_state_sample { uint64_t lowest_usage; }; +static unsigned long hash_channel_key(struct channel_key *key); +static int evaluate_condition(struct lttng_condition *condition, + struct lttng_evaluation **evaluation, + struct notification_thread_state *state, + struct channel_state_sample *previous_sample, + struct channel_state_sample *latest_sample, + uint64_t buffer_capacity); +static +int send_evaluation_to_clients(struct lttng_trigger *trigger, + struct lttng_evaluation *evaluation, + struct notification_client_list *client_list, + struct notification_thread_state *state, + uid_t channel_uid, gid_t channel_gid); + + +static +void session_info_destroy(void *_data); +static +void session_info_get(struct session_info *session_info); +static +void session_info_put(struct session_info *session_info); +static +struct session_info *session_info_create(const char *name, + uid_t uid, gid_t gid); +static +void session_info_add_channel(struct session_info *session_info, + struct channel_info *channel_info); +static +void session_info_remove_channel(struct session_info *session_info, + struct channel_info *channel_info); + static int match_client(struct cds_lfht_node *node, const void *key) { @@ -271,7 +312,7 @@ unsigned long lttng_condition_buffer_usage_hash( val = condition->threshold_ratio.value * (double) UINT32_MAX; hash ^= hash_key_u64(&val, lttng_ht_seed); - } else if (condition->threshold_ratio.set) { + } else if (condition->threshold_bytes.set) { uint64_t val; val = condition->threshold_bytes.value; @@ -298,6 +339,16 @@ unsigned long lttng_condition_hash(struct lttng_condition *condition) } } +static +unsigned long hash_channel_key(struct channel_key *key) +{ + unsigned long key_hash = hash_key_u64(&key->key, lttng_ht_seed); + unsigned long domain_hash = hash_key_ulong( + (void *) (unsigned long) key->domain, lttng_ht_seed); + + return key_hash ^ domain_hash; +} + static void channel_info_destroy(struct channel_info *channel_info) { @@ -305,48 +356,260 @@ void channel_info_destroy(struct channel_info *channel_info) return; } - if (channel_info->session_name) { - free(channel_info->session_name); + if (channel_info->session_info) { + session_info_remove_channel(channel_info->session_info, + channel_info); + session_info_put(channel_info->session_info); } - if (channel_info->channel_name) { - free(channel_info->channel_name); + if (channel_info->name) { + free(channel_info->name); } free(channel_info); } +/* Don't call directly, use the ref-counting mechanism. */ static -struct channel_info *channel_info_copy(struct channel_info *channel_info) +void session_info_destroy(void *_data) { - struct channel_info *copy = zmalloc(sizeof(*channel_info)); + struct session_info *session_info = _data; - assert(channel_info); - assert(channel_info->session_name); - assert(channel_info->channel_name); + assert(session_info); + if (session_info->channel_infos_ht) { + cds_lfht_destroy(session_info->channel_infos_ht, NULL); + } + free(session_info->name); + free(session_info); +} - if (!copy) { - goto end; +static +void session_info_get(struct session_info *session_info) +{ + if (!session_info) { + return; } + lttng_ref_get(&session_info->ref); +} - memcpy(copy, channel_info, sizeof(*channel_info)); - copy->session_name = NULL; - copy->channel_name = NULL; +static +void session_info_put(struct session_info *session_info) +{ + if (!session_info) { + return; + } + lttng_ref_put(&session_info->ref); +} - copy->session_name = strdup(channel_info->session_name); - if (!copy->session_name) { +static +struct session_info *session_info_create(const char *name, uid_t uid, gid_t gid) +{ + struct session_info *session_info; + + assert(name); + + session_info = zmalloc(sizeof(*session_info)); + if (!session_info) { + goto end; + } + lttng_ref_init(&session_info->ref, session_info_destroy); + + session_info->channel_infos_ht = cds_lfht_new(DEFAULT_HT_SIZE, + 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); + if (!session_info->channel_infos_ht) { goto error; } - copy->channel_name = strdup(channel_info->channel_name); - if (!copy->channel_name) { + + cds_lfht_node_init(&session_info->sessions_ht_node); + session_info->name = strdup(name); + if (!session_info->name) { goto error; } + session_info->uid = uid; + session_info->gid = gid; +end: + return session_info; +error: + session_info_put(session_info); + return NULL; +} + +static +void session_info_add_channel(struct session_info *session_info, + struct channel_info *channel_info) +{ + rcu_read_lock(); + cds_lfht_add(session_info->channel_infos_ht, + hash_channel_key(&channel_info->key), + &channel_info->session_info_channels_ht_node); + rcu_read_unlock(); +} + +static +void session_info_remove_channel(struct session_info *session_info, + struct channel_info *channel_info) +{ + rcu_read_lock(); + cds_lfht_del(session_info->channel_infos_ht, + &channel_info->session_info_channels_ht_node); + rcu_read_unlock(); +} + +static +struct channel_info *channel_info_create(const char *channel_name, + struct channel_key *channel_key, uint64_t channel_capacity, + struct session_info *session_info) +{ + struct channel_info *channel_info = zmalloc(sizeof(*channel_info)); + + if (!channel_info) { + goto end; + } + cds_lfht_node_init(&channel_info->channels_ht_node); + cds_lfht_node_init(&channel_info->session_info_channels_ht_node); + memcpy(&channel_info->key, channel_key, sizeof(*channel_key)); + channel_info->capacity = channel_capacity; + + channel_info->name = strdup(channel_name); + if (!channel_info->name) { + goto error; + } + + /* + * Set the references between session and channel infos: + * - channel_info holds a strong reference to session_info + * - session_info holds a weak reference to channel_info + */ + session_info_get(session_info); + session_info_add_channel(session_info, channel_info); + channel_info->session_info = session_info; end: - return copy; + return channel_info; error: - channel_info_destroy(copy); + channel_info_destroy(channel_info); return NULL; } +/* This function must be called with the RCU read lock held. */ +static +int evaluate_condition_for_client(struct lttng_trigger *trigger, + struct lttng_condition *condition, + struct notification_client *client, + struct notification_thread_state *state) +{ + int ret; + struct cds_lfht_iter iter; + struct cds_lfht_node *node; + struct channel_info *channel_info = NULL; + struct channel_key *channel_key = NULL; + struct channel_state_sample *last_sample = NULL; + struct lttng_channel_trigger_list *channel_trigger_list = NULL; + struct lttng_evaluation *evaluation = NULL; + struct notification_client_list client_list = { 0 }; + struct notification_client_list_element client_list_element = { 0 }; + + assert(trigger); + assert(condition); + assert(client); + assert(state); + + /* Find the channel associated with the trigger. */ + cds_lfht_for_each_entry(state->channel_triggers_ht, &iter, + channel_trigger_list , channel_triggers_ht_node) { + struct lttng_trigger_list_element *element; + + cds_list_for_each_entry(element, &channel_trigger_list->list, node) { + struct lttng_condition *current_condition = + lttng_trigger_get_condition( + element->trigger); + + assert(current_condition); + if (!lttng_condition_is_equal(condition, + current_condition)) { + continue; + } + + /* Found the trigger, save the channel key. */ + channel_key = &channel_trigger_list->channel_key; + break; + } + if (channel_key) { + /* The channel key was found stop iteration. */ + break; + } + } + + if (!channel_key){ + /* No channel found; normal exit. */ + DBG("[notification-thread] No channel associated with newly subscribed-to condition"); + ret = 0; + goto end; + } + + /* Fetch channel info for the matching channel. */ + cds_lfht_lookup(state->channels_ht, + hash_channel_key(channel_key), + match_channel_info, + channel_key, + &iter); + node = cds_lfht_iter_get_node(&iter); + assert(node); + channel_info = caa_container_of(node, struct channel_info, + channels_ht_node); + + /* Retrieve the channel's last sample, if it exists. */ + cds_lfht_lookup(state->channel_state_ht, + hash_channel_key(channel_key), + match_channel_state_sample, + channel_key, + &iter); + node = cds_lfht_iter_get_node(&iter); + if (node) { + last_sample = caa_container_of(node, + struct channel_state_sample, + channel_state_ht_node); + } else { + /* Nothing to evaluate, no sample was ever taken. Normal exit */ + DBG("[notification-thread] No channel sample associated with newly subscribed-to condition"); + ret = 0; + goto end; + } + + ret = evaluate_condition(condition, &evaluation, state, NULL, + last_sample, channel_info->capacity); + if (ret) { + WARN("[notification-thread] Fatal error occurred while evaluating a newly subscribed-to condition"); + goto end; + } + + if (!evaluation) { + /* Evaluation yielded nothing. Normal exit. */ + DBG("[notification-thread] Newly subscribed-to condition evaluated to false, nothing to report to client"); + ret = 0; + goto end; + } + + /* + * Create a temporary client list with the client currently + * subscribing. + */ + cds_lfht_node_init(&client_list.notification_trigger_ht_node); + CDS_INIT_LIST_HEAD(&client_list.list); + client_list.trigger = trigger; + + CDS_INIT_LIST_HEAD(&client_list_element.node); + client_list_element.client = client; + cds_list_add(&client_list_element.node, &client_list.list); + + /* Send evaluation result to the newly-subscribed client. */ + DBG("[notification-thread] Newly subscribed-to condition evaluated to true, notifying client"); + ret = send_evaluation_to_clients(trigger, evaluation, &client_list, + state, channel_info->session_info->uid, + channel_info->session_info->gid); + +end: + return ret; +} + static int notification_thread_client_subscribe(struct notification_client *client, struct lttng_condition *condition, @@ -394,11 +657,6 @@ int notification_thread_client_subscribe(struct notification_client *client, condition_list_element->condition = condition; cds_list_add(&condition_list_element->node, &client->condition_list); - /* - * Add the client to the list of clients interested in a given trigger - * if a "notification" trigger with a corresponding condition was - * added prior. - */ cds_lfht_lookup(state->notification_trigger_clients_ht, lttng_condition_hash(condition), match_client_list_condition, @@ -406,12 +664,34 @@ int notification_thread_client_subscribe(struct notification_client *client, &iter); node = cds_lfht_iter_get_node(&iter); if (!node) { + /* + * No notification-emiting trigger registered with this + * condition. We don't evaluate the condition right away + * since this trigger is not registered yet. + */ free(client_list_element); goto end_unlock; } client_list = caa_container_of(node, struct notification_client_list, notification_trigger_ht_node); + /* + * The condition to which the client just subscribed is evaluated + * at this point so that conditions that are already TRUE result + * in a notification being sent out. + */ + if (evaluate_condition_for_client(client_list->trigger, condition, + client, state)) { + WARN("[notification-thread] Evaluation of a condition on client subscription failed, aborting."); + ret = -1; + goto end_unlock; + } + + /* + * Add the client to the list of clients interested in a given trigger + * if a "notification" trigger with a corresponding condition was + * added prior. + */ client_list_element->client = client; CDS_INIT_LIST_HEAD(&client_list_element->node); cds_list_add(&client_list_element->node, &client_list->list); @@ -565,7 +845,7 @@ end: static bool trigger_applies_to_channel(struct lttng_trigger *trigger, - struct channel_info *info) + struct channel_info *channel_info) { enum lttng_condition_status status; struct lttng_condition *condition; @@ -589,7 +869,7 @@ bool trigger_applies_to_channel(struct lttng_trigger *trigger, status = lttng_condition_buffer_usage_get_domain_type(condition, &trigger_domain); assert(status == LTTNG_CONDITION_STATUS_OK); - if (info->key.domain != trigger_domain) { + if (channel_info->key.domain != trigger_domain) { goto fail; } @@ -601,10 +881,10 @@ bool trigger_applies_to_channel(struct lttng_trigger *trigger, condition, &trigger_channel_name); assert((status == LTTNG_CONDITION_STATUS_OK) && trigger_channel_name); - if (strcmp(info->session_name, trigger_session_name)) { + if (strcmp(channel_info->session_info->name, trigger_session_name)) { goto fail; } - if (strcmp(info->channel_name, trigger_channel_name)) { + if (strcmp(channel_info->name, trigger_channel_name)) { goto fail; } @@ -633,38 +913,90 @@ bool trigger_applies_to_client(struct lttng_trigger *trigger, } static -unsigned long hash_channel_key(struct channel_key *key) +int match_session(struct cds_lfht_node *node, const void *key) { - return hash_key_u64(&key->key, lttng_ht_seed) ^ hash_key_ulong( - (void *) (unsigned long) key->domain, lttng_ht_seed); + const char *name = key; + struct session_info *session_info = caa_container_of( + node, struct session_info, sessions_ht_node); + + return !strcmp(session_info->name, name); +} + +static +struct session_info *find_or_create_session_info( + struct notification_thread_state *state, + const char *name, uid_t uid, gid_t gid) +{ + struct session_info *session = NULL; + struct cds_lfht_node *node; + struct cds_lfht_iter iter; + + rcu_read_lock(); + cds_lfht_lookup(state->sessions_ht, + hash_key_str(name, lttng_ht_seed), + match_session, + name, + &iter); + node = cds_lfht_iter_get_node(&iter); + if (node) { + DBG("[notification-thread] Found session info of session \"%s\" (uid = %i, gid = %i)", + name, uid, gid); + session = caa_container_of(node, struct session_info, + sessions_ht_node); + assert(session->uid == uid); + assert(session->gid == gid); + goto end; + } + + session = session_info_create(name, uid, gid); + if (!session) { + ERR("[notification-thread] Failed to allocation session info for session \"%s\" (uid = %i, gid = %i)", + name, uid, gid); + goto end; + } +end: + rcu_read_unlock(); + return session; } static int handle_notification_thread_command_add_channel( - struct notification_thread_state *state, - struct channel_info *channel_info, - enum lttng_error_code *cmd_result) + struct notification_thread_state *state, + const char *session_name, uid_t session_uid, gid_t session_gid, + const char *channel_name, enum lttng_domain_type channel_domain, + uint64_t channel_key_int, uint64_t channel_capacity, + enum lttng_error_code *cmd_result) { struct cds_list_head trigger_list; - struct channel_info *new_channel_info; - struct channel_key *channel_key; + struct channel_info *new_channel_info = NULL; + struct channel_key channel_key = { + .key = channel_key_int, + .domain = channel_domain, + }; struct lttng_channel_trigger_list *channel_trigger_list = NULL; struct lttng_trigger_ht_element *trigger_ht_element = NULL; int trigger_count = 0; struct cds_lfht_iter iter; + struct session_info *session_info = NULL; DBG("[notification-thread] Adding channel %s from session %s, channel key = %" PRIu64 " in %s domain", - channel_info->channel_name, channel_info->session_name, - channel_info->key.key, channel_info->key.domain == LTTNG_DOMAIN_KERNEL ? "kernel" : "user space"); + channel_name, session_name, channel_key_int, + channel_domain == LTTNG_DOMAIN_KERNEL ? "kernel" : "user space"); CDS_INIT_LIST_HEAD(&trigger_list); - new_channel_info = channel_info_copy(channel_info); - if (!new_channel_info) { + session_info = find_or_create_session_info(state, session_name, + session_uid, session_gid); + if (!session_info) { + /* Allocation error or an internal error occured. */ goto error; } - channel_key = &new_channel_info->key; + new_channel_info = channel_info_create(channel_name, &channel_key, + channel_capacity, session_info); + if (!new_channel_info) { + goto error; + } /* Build a list of all triggers applying to the new channel. */ cds_lfht_for_each_entry(state->triggers_ht, &iter, trigger_ht_element, @@ -672,7 +1004,7 @@ int handle_notification_thread_command_add_channel( struct lttng_trigger_list_element *new_element; if (!trigger_applies_to_channel(trigger_ht_element->trigger, - channel_info)) { + new_channel_info)) { continue; } @@ -692,7 +1024,7 @@ int handle_notification_thread_command_add_channel( if (!channel_trigger_list) { goto error; } - channel_trigger_list->channel_key = *channel_key; + channel_trigger_list->channel_key = new_channel_info->key; CDS_INIT_LIST_HEAD(&channel_trigger_list->list); cds_lfht_node_init(&channel_trigger_list->channel_triggers_ht_node); cds_list_splice(&trigger_list, &channel_trigger_list->list); @@ -700,21 +1032,21 @@ int handle_notification_thread_command_add_channel( rcu_read_lock(); /* Add channel to the channel_ht which owns the channel_infos. */ cds_lfht_add(state->channels_ht, - hash_channel_key(channel_key), + hash_channel_key(&new_channel_info->key), &new_channel_info->channels_ht_node); /* * Add the list of triggers associated with this channel to the * channel_triggers_ht. */ cds_lfht_add(state->channel_triggers_ht, - hash_channel_key(channel_key), + hash_channel_key(&new_channel_info->key), &channel_trigger_list->channel_triggers_ht_node); rcu_read_unlock(); *cmd_result = LTTNG_OK; return 0; error: - /* Empty trigger list */ channel_info_destroy(new_channel_info); + session_info_put(session_info); return 1; } @@ -800,21 +1132,66 @@ end: return 0; } +static +int condition_is_supported(struct lttng_condition *condition) +{ + int ret; + + switch (lttng_condition_get_type(condition)) { + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW: + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH: + { + enum lttng_domain_type domain; + + ret = lttng_condition_buffer_usage_get_domain_type(condition, + &domain); + if (ret) { + ret = -1; + goto end; + } + + if (domain != LTTNG_DOMAIN_KERNEL) { + ret = 1; + goto end; + } + + /* + * Older kernel tracers don't expose the API to monitor their + * buffers. Therefore, we reject triggers that require that + * mechanism to be available to be evaluated. + */ + ret = kernel_supports_ring_buffer_snapshot_sample_positions( + kernel_tracer_fd); + break; + } + default: + ret = 1; + } +end: + return ret; +} + /* * FIXME A client's credentials are not checked when registering a trigger, nor * are they stored alongside with the trigger. * - * The effects of this are benign: + * The effects of this are benign since: * - The client will succeed in registering the trigger, as it is valid, * - The trigger will, internally, be bound to the channel, * - The notifications will not be sent since the client's credentials * are checked against the channel at that moment. + * + * If this function returns a non-zero value, it means something is + * fundamentally broken and the whole subsystem/thread will be torn down. + * + * If a non-fatal error occurs, just set the cmd_result to the appropriate + * error code. */ static int handle_notification_thread_command_register_trigger( - struct notification_thread_state *state, - struct lttng_trigger *trigger, - enum lttng_error_code *cmd_result) + struct notification_thread_state *state, + struct lttng_trigger *trigger, + enum lttng_error_code *cmd_result) { int ret = 0; struct lttng_condition *condition; @@ -830,6 +1207,19 @@ int handle_notification_thread_command_register_trigger( rcu_read_lock(); condition = lttng_trigger_get_condition(trigger); + assert(condition); + + ret = condition_is_supported(condition); + if (ret < 0) { + goto error; + } else if (ret == 0) { + *cmd_result = LTTNG_ERR_NOT_SUPPORTED; + goto error; + } else { + /* Feature is supported, continue. */ + ret = 0; + } + trigger_ht_element = zmalloc(sizeof(*trigger_ht_element)); if (!trigger_ht_element) { ret = -1; @@ -892,11 +1282,6 @@ int handle_notification_thread_command_register_trigger( cds_lfht_add(state->notification_trigger_clients_ht, lttng_condition_hash(condition), &client_list->notification_trigger_ht_node); - /* - * Client list ownership transferred to the - * notification_trigger_clients_ht. - */ - client_list = NULL; /* * Add the trigger to list of triggers bound to the channels currently @@ -918,7 +1303,6 @@ int handle_notification_thread_command_register_trigger( &iter); node = cds_lfht_iter_get_node(&iter); assert(node); - /* Free the list of triggers associated with this channel. */ trigger_list = caa_container_of(node, struct lttng_channel_trigger_list, channel_triggers_ht_node); @@ -931,10 +1315,52 @@ int handle_notification_thread_command_register_trigger( CDS_INIT_LIST_HEAD(&trigger_list_element->node); trigger_list_element->trigger = trigger; cds_list_add(&trigger_list_element->node, &trigger_list->list); + /* A trigger can only apply to one channel. */ break; } + /* + * Since there is nothing preventing clients from subscribing to a + * condition before the corresponding trigger is registered, we have + * to evaluate this new condition right away. + * + * At some point, we were waiting for the next "evaluation" (e.g. on + * reception of a channel sample) to evaluate this new condition, but + * that was broken. + * + * The reason it was broken is that waiting for the next sample + * does not allow us to properly handle transitions for edge-triggered + * conditions. + * + * Consider this example: when we handle a new channel sample, we + * evaluate each conditions twice: once with the previous state, and + * again with the newest state. We then use those two results to + * determine whether a state change happened: a condition was false and + * became true. If a state change happened, we have to notify clients. + * + * Now, if a client subscribes to a given notification and registers + * a trigger *after* that subscription, we have to make sure the + * condition is evaluated at this point while considering only the + * current state. Otherwise, the next evaluation cycle may only see + * that the evaluations remain the same (true for samples n-1 and n) and + * the client will never know that the condition has been met. + */ + cds_list_for_each_entry_safe(client_list_element, tmp, + &client_list->list, node) { + ret = evaluate_condition_for_client(trigger, condition, + client_list_element->client, state); + if (ret) { + goto error_free_client_list; + } + } + + /* + * Client list ownership transferred to the + * notification_trigger_clients_ht. + */ + client_list = NULL; + *cmd_result = LTTNG_OK; error_free_client_list: if (client_list) { @@ -1009,6 +1435,8 @@ int handle_notification_thread_command_unregister_trigger( DBG("[notification-thread] Removed trigger from channel_triggers_ht"); cds_list_del(&trigger_element->node); + /* A trigger can only appear once per channel */ + break; } } @@ -1060,8 +1488,9 @@ int handle_notification_thread_command( uint64_t counter; struct notification_thread_command *cmd; - /* Read event_fd to put it back into a quiescent state. */ - ret = read(handle->cmd_queue.event_fd, &counter, sizeof(counter)); + /* Read the event pipe to put it back into a quiescent state. */ + ret = read(lttng_pipe_get_readfd(handle->cmd_queue.event_pipe), &counter, + sizeof(counter)); if (ret == -1) { goto error; } @@ -1085,7 +1514,14 @@ int handle_notification_thread_command( case NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL: DBG("[notification-thread] Received add channel command"); ret = handle_notification_thread_command_add_channel( - state, &cmd->parameters.add_channel, + state, + cmd->parameters.add_channel.session.name, + cmd->parameters.add_channel.session.uid, + cmd->parameters.add_channel.session.gid, + cmd->parameters.add_channel.channel.name, + cmd->parameters.add_channel.channel.domain, + cmd->parameters.add_channel.channel.key, + cmd->parameters.add_channel.channel.capacity, &cmd->reply_code); break; case NOTIFICATION_COMMAND_TYPE_REMOVE_CHANNEL: @@ -1153,7 +1589,7 @@ end: } static -void client_reset_inbound_state(struct notification_client *client) +int client_reset_inbound_state(struct notification_client *client) { int ret; @@ -1165,9 +1601,12 @@ void client_reset_inbound_state(struct notification_client *client) sizeof(struct lttng_notification_channel_message); client->communication.inbound.msg_type = LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_UNKNOWN; - client->communication.inbound.receive_creds = false; LTTNG_SOCK_SET_UID_CRED(&client->communication.inbound.creds, -1); LTTNG_SOCK_SET_GID_CRED(&client->communication.inbound.creds, -1); + ret = lttng_dynamic_buffer_set_size( + &client->communication.inbound.buffer, + client->communication.inbound.bytes_to_receive); + return ret; } int handle_notification_thread_client_connect( @@ -1187,7 +1626,13 @@ int handle_notification_thread_client_connect( CDS_INIT_LIST_HEAD(&client->condition_list); lttng_dynamic_buffer_init(&client->communication.inbound.buffer); lttng_dynamic_buffer_init(&client->communication.outbound.buffer); - client_reset_inbound_state(client); + client->communication.inbound.expect_creds = true; + ret = client_reset_inbound_state(client); + if (ret) { + ERR("[notification-thread] Failed to reset client communication's inbound state"); + ret = 0; + goto error; + } ret = lttcomm_accept_unix_sock(state->notification_channel_socket); if (ret < 0) { @@ -1291,7 +1736,7 @@ int handle_notification_thread_client_disconnect_all( int handle_notification_thread_trigger_unregister_all( struct notification_thread_state *state) { - bool error_occured = false; + bool error_occurred = false; struct cds_lfht_iter iter; struct lttng_trigger_ht_element *trigger_ht_element; @@ -1300,10 +1745,10 @@ int handle_notification_thread_trigger_unregister_all( int ret = handle_notification_thread_command_unregister_trigger( state, trigger_ht_element->trigger, NULL); if (ret) { - error_occured = true; + error_occurred = true; } } - return error_occured ? -1 : 0; + return error_occurred ? -1 : 0; } static @@ -1476,12 +1921,8 @@ int client_dispatch_message(struct notification_client *client, client->communication.inbound.bytes_to_receive = msg->size; client->communication.inbound.msg_type = (enum lttng_notification_channel_message_type) msg->type; - if (client->communication.inbound.msg_type == - LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_HANDSHAKE) { - client->communication.inbound.receive_creds = true; - } ret = lttng_dynamic_buffer_set_size( - &client->communication.inbound.buffer, 0); + &client->communication.inbound.buffer, msg->size); if (ret) { goto end; } @@ -1548,7 +1989,11 @@ int client_dispatch_message(struct notification_client *client, } /* Set reception state to receive the next message header. */ - client_reset_inbound_state(client); + ret = client_reset_inbound_state(client); + if (ret) { + ERR("[notification-thread] Failed to reset client communication's inbound state"); + goto end; + } client->validated = true; break; } @@ -1574,10 +2019,6 @@ int client_dispatch_message(struct notification_client *client, if (client->communication.inbound.msg_type == LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_SUBSCRIBE) { - /* - * FIXME The current state should be evaluated on - * subscription. - */ ret = notification_thread_client_subscribe(client, condition, state, &status); } else { @@ -1595,7 +2036,11 @@ int client_dispatch_message(struct notification_client *client, } /* Set reception state to receive the next message header. */ - client_reset_inbound_state(client); + ret = client_reset_inbound_state(client); + if (ret) { + ERR("[notification-thread] Failed to reset client communication's inbound state"); + goto end; + } break; } default: @@ -1609,7 +2054,7 @@ end: int handle_notification_thread_client_in( struct notification_thread_state *state, int socket) { - int ret; + int ret = 0; struct notification_client *client; ssize_t recv_ret; size_t offset; @@ -1621,21 +2066,15 @@ int handle_notification_thread_client_in( goto end; } - offset = client->communication.inbound.buffer.size; - ret = lttng_dynamic_buffer_set_size( - &client->communication.inbound.buffer, - client->communication.inbound.bytes_to_receive); - if (ret) { - goto end; - } - - if (client->communication.inbound.receive_creds) { + offset = client->communication.inbound.buffer.size - + client->communication.inbound.bytes_to_receive; + if (client->communication.inbound.expect_creds) { recv_ret = lttcomm_recv_creds_unix_sock(socket, client->communication.inbound.buffer.data + offset, client->communication.inbound.bytes_to_receive, &client->communication.inbound.creds); if (recv_ret > 0) { - client->communication.inbound.receive_creds = false; + client->communication.inbound.expect_creds = false; client->communication.inbound.creds_received = true; } } else { @@ -1648,14 +2087,6 @@ int handle_notification_thread_client_in( } client->communication.inbound.bytes_to_receive -= recv_ret; - ret = lttng_dynamic_buffer_set_size( - &client->communication.inbound.buffer, - client->communication.inbound.buffer.size - - client->communication.inbound.bytes_to_receive); - if (ret) { - goto end; - } - if (client->communication.inbound.bytes_to_receive == 0) { ret = client_dispatch_message(client, state); if (ret) { @@ -1989,9 +2420,9 @@ int handle_notification_thread_channel_sample( channel_info = caa_container_of(node, struct channel_info, channels_ht_node); DBG("[notification-thread] Handling channel sample for channel %s (key = %" PRIu64 ") in session %s (highest usage = %" PRIu64 ", lowest usage = %" PRIu64")", - channel_info->channel_name, + channel_info->name, latest_sample.key.key, - channel_info->session_name, + channel_info->session_info->name, latest_sample.highest_usage, latest_sample.lowest_usage); @@ -2101,7 +2532,9 @@ int handle_notification_thread_channel_sample( /* Dispatch evaluation result to all clients. */ ret = send_evaluation_to_clients(trigger_list_element->trigger, evaluation, client_list, state, - channel_info->uid, channel_info->gid); + channel_info->session_info->uid, + channel_info->session_info->gid); + lttng_evaluation_destroy(evaluation); if (ret) { goto end_unlock; }