X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fnotification-thread-events.c;h=309c54c879cc0cd14cae470a61af8c9dad1ffe06;hb=fc4b93fa8aa36b19caad0f8dc4a6a3237fcc36bf;hp=823f2a7eb3b2d53a4642844738ebd808445e2f26;hpb=b9a8d78fefbc856370939d9eb553d6e9c1fcc86a;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/notification-thread-events.c b/src/bin/lttng-sessiond/notification-thread-events.c index 823f2a7eb..309c54c87 100644 --- a/src/bin/lttng-sessiond/notification-thread-events.c +++ b/src/bin/lttng-sessiond/notification-thread-events.c @@ -193,6 +193,11 @@ int client_handle_transmission_status( enum client_transmission_status transmission_status, struct notification_thread_state *state); +static +int handle_one_event_notifier_notification( + struct notification_thread_state *state, + int pipe, enum lttng_domain_type domain); + static void free_lttng_trigger_ht_element_rcu(struct rcu_head *node); @@ -1980,6 +1985,59 @@ end: return ret; } +static +int drain_event_notifier_notification_pipe( + struct notification_thread_state *state, + int pipe, enum lttng_domain_type domain) +{ + struct lttng_poll_event events = {0}; + int ret; + + ret = lttng_poll_create(&events, 1, LTTNG_CLOEXEC); + if (ret < 0) { + ERR("[notification-thread] Error creating lttng_poll_event"); + goto end; + } + + ret = lttng_poll_add(&events, pipe, LPOLLIN); + if (ret < 0) { + ERR("[notification-thread] Error adding fd event notifier notification pipe to lttng_poll_event: fd = %d", + pipe); + goto end; + } + + while (true) { + /* + * Continue to consume notifications as long as there are new + * ones coming in. The tracer has been asked to stop producing + * them. + * + * LPOLLIN is explicitly checked since LPOLLHUP is implicitly + * monitored (on Linux, at least) and will be returned when + * the pipe is closed but empty. + */ + ret = lttng_poll_wait_interruptible(&events, 0); + if (ret == 0 || (LTTNG_POLL_GETEV(&events, 0) & LPOLLIN) == 0) { + /* No more notification to be read on this pipe. */ + ret = 0; + goto end; + } else if (ret < 0) { + PERROR("Failed on lttng_poll_wait_interruptible() call"); + ret = -1; + goto end; + } + + ret = handle_one_event_notifier_notification(state, pipe, domain); + if (ret) { + ERR("[notification-thread] Error consuming an event notifier notification from pipe: fd = %d", + pipe); + } + } +end: + lttng_poll_clean(&events); + return ret; +} + static int handle_notification_thread_command_remove_tracer_event_source( struct notification_thread_state *state, @@ -2036,6 +2094,24 @@ int handle_notification_thread_command_remove_tracer_event_source( source_element->is_fd_in_poll_set = false; + ret = drain_event_notifier_notification_pipe(state, tracer_event_source_fd, + source_element->domain); + if (ret) { + ERR("[notification-thread] Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s", + tracer_event_source_fd, + lttng_domain_type_str(source_element->domain)); + cmd_result = LTTNG_ERR_FATAL; + goto end; + } + + /* + * The drain_event_notifier_notification_pipe() call might have read + * data from an fd that we received in event in the latest _poll_wait() + * call. Make sure the thread call poll_wait() again to ensure we have + * a clean state. + */ + state->restart_poll = true; + end: free(source_element); *_cmd_result = cmd_result; @@ -4161,7 +4237,8 @@ end: return ret; } -static struct lttng_event_notifier_notification *receive_notification( +static +struct lttng_event_notifier_notification *recv_one_event_notifier_notification( int notification_pipe_read_fd, enum lttng_domain_type domain) { int ret; @@ -4170,7 +4247,7 @@ static struct lttng_event_notifier_notification *receive_notification( void *reception_buffer; size_t reception_size; - struct lttng_ust_event_notifier_notification ust_notification; + struct lttng_ust_abi_event_notifier_notification ust_notification; struct lttng_kernel_event_notifier_notification kernel_notification; /* Init lttng_event_notifier_notification */ @@ -4217,28 +4294,19 @@ end: return notification; } -int handle_notification_thread_event_notification(struct notification_thread_state *state, - int pipe, - enum lttng_domain_type domain) +static +int dispatch_one_event_notifier_notification(struct notification_thread_state *state, + struct lttng_event_notifier_notification *notification) { - int ret; - enum lttng_trigger_status trigger_status; struct cds_lfht_node *node; struct cds_lfht_iter iter; struct notification_trigger_tokens_ht_element *element; + enum lttng_trigger_status trigger_status; struct lttng_evaluation *evaluation = NULL; - struct lttng_event_notifier_notification *notification = NULL; enum action_executor_status executor_status; struct notification_client_list *client_list = NULL; const char *trigger_name; - - notification = receive_notification(pipe, domain); - if (notification == NULL) { - ERR("[notification-thread] Error receiving notification from tracer (fd = %i, domain = %s)", - pipe, lttng_domain_type_str(domain)); - ret = -1; - goto end; - } + int ret; /* Find triggers associated with this token. */ rcu_read_lock(); @@ -4347,13 +4415,45 @@ next_client: } end_unlock: - lttng_event_notifier_notification_destroy(notification); notification_client_list_put(client_list); rcu_read_unlock(); + return ret; +} + +static +int handle_one_event_notifier_notification( + struct notification_thread_state *state, + int pipe, enum lttng_domain_type domain) +{ + int ret; + struct lttng_event_notifier_notification *notification = NULL; + + notification = recv_one_event_notifier_notification(pipe, domain); + if (notification == NULL) { + ERR("[notification-thread] Error receiving an event notifier notification from tracer: fd = %i, domain = %s", + pipe, lttng_domain_type_str(domain)); + ret = -1; + goto end; + } + + ret = dispatch_one_event_notifier_notification(state, notification); + if (ret) { + ERR("[notification-thread] Error dispatching an event notifier notification from tracer: fd = %i, domain = %s", + pipe, lttng_domain_type_str(domain)); + goto end; + } + end: + lttng_event_notifier_notification_destroy(notification); return ret; } +int handle_notification_thread_event_notification(struct notification_thread_state *state, + int pipe, enum lttng_domain_type domain) +{ + return handle_one_event_notifier_notification(state, pipe, domain); +} + int handle_notification_thread_channel_sample( struct notification_thread_state *state, int pipe, enum lttng_domain_type domain)