X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fnotification-thread-events.c;h=aadc1b0a8b207edac646c8aa785ffc3b09f848f5;hb=d602bd6a8ee25d5ca662dde4edb3db3cabf264e1;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..aadc1b0a8 100644 --- a/src/bin/lttng-sessiond/notification-thread-events.c +++ b/src/bin/lttng-sessiond/notification-thread-events.c @@ -21,6 +21,8 @@ #include #include #include +#include +#include #include #include #include @@ -48,6 +50,9 @@ #define CLIENT_POLL_MASK_IN (LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP) #define CLIENT_POLL_MASK_IN_OUT (CLIENT_POLL_MASK_IN | LPOLLOUT) +/* The tracers currently limit the capture size to PIPE_BUF (4kb on linux). */ +#define MAX_CAPTURE_SIZE (PIPE_BUF) + enum lttng_object_type { LTTNG_OBJECT_TYPE_UNKNOWN, LTTNG_OBJECT_TYPE_NONE, @@ -193,6 +198,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); @@ -457,7 +467,7 @@ enum lttng_object_type get_condition_binding_object( case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING: case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED: return LTTNG_OBJECT_TYPE_SESSION; - case LTTNG_CONDITION_TYPE_EVENT_RULE_HIT: + case LTTNG_CONDITION_TYPE_ON_EVENT: return LTTNG_OBJECT_TYPE_NONE; default: return LTTNG_OBJECT_TYPE_UNKNOWN; @@ -1980,6 +1990,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 +2099,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; @@ -2141,12 +2222,12 @@ bool condition_is_supported(struct lttng_condition *condition) is_supported = kernel_supports_ring_buffer_snapshot_sample_positions() == 1; break; } - case LTTNG_CONDITION_TYPE_EVENT_RULE_HIT: + case LTTNG_CONDITION_TYPE_ON_EVENT: { const struct lttng_event_rule *event_rule; enum lttng_domain_type domain; const enum lttng_condition_status status = - lttng_condition_event_rule_get_rule( + lttng_condition_on_event_get_rule( condition, &event_rule); assert(status == LTTNG_CONDITION_STATUS_OK); @@ -2454,7 +2535,7 @@ int handle_notification_thread_command_register_trigger( goto error_free_ht_element; } - if (lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_EVENT_RULE_HIT) { + if (lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT) { trigger_tokens_ht_element = zmalloc(sizeof(*trigger_tokens_ht_element)); if (!trigger_tokens_ht_element) { /* Fatal error. */ @@ -2749,7 +2830,7 @@ int handle_notification_thread_command_unregister_trigger( } if (lttng_condition_get_type(condition) == - LTTNG_CONDITION_TYPE_EVENT_RULE_HIT) { + LTTNG_CONDITION_TYPE_ON_EVENT) { struct notification_trigger_tokens_ht_element *trigger_tokens_ht_element; @@ -4161,16 +4242,19 @@ 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; uint64_t token; struct lttng_event_notifier_notification *notification = NULL; + char *capture_buffer = NULL; + size_t capture_buffer_size; 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 */ @@ -4203,42 +4287,72 @@ static struct lttng_event_notifier_notification *receive_notification( switch(domain) { case LTTNG_DOMAIN_UST: token = ust_notification.token; + capture_buffer_size = ust_notification.capture_buf_size; break; case LTTNG_DOMAIN_KERNEL: token = kernel_notification.token; + capture_buffer_size = kernel_notification.capture_buf_size; break; default: abort(); } - notification = lttng_event_notifier_notification_create( - token, domain); + if (capture_buffer_size == 0) { + capture_buffer = NULL; + goto skip_capture; + } + + if (capture_buffer_size > MAX_CAPTURE_SIZE) { + ERR("[notification-thread] Event notifier has a capture payload size which exceeds the maximum allowed size: capture_payload_size = %zu bytes, max allowed size = %d bytes", + capture_buffer_size, MAX_CAPTURE_SIZE); + goto end; + } + + capture_buffer = zmalloc(capture_buffer_size); + if (!capture_buffer) { + ERR("[notification-thread] Failed to allocate capture buffer"); + goto end; + } + + /* Fetch additional payload (capture). */ + ret = lttng_read(notification_pipe_read_fd, capture_buffer, capture_buffer_size); + if (ret != capture_buffer_size) { + ERR("[notification-thread] Failed to read from event source pipe (fd = %i)", + notification_pipe_read_fd); + goto end; + } + +skip_capture: + notification = lttng_event_notifier_notification_create(token, domain, + capture_buffer, capture_buffer_size); + if (notification == NULL) { + goto end; + } + + /* + * Ownership transfered to the lttng_event_notifier_notification object. + */ + capture_buffer = NULL; + end: + free(capture_buffer); 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; + unsigned int capture_count = 0; /* Find triggers associated with this token. */ rcu_read_lock(); @@ -4271,14 +4385,34 @@ int handle_notification_thread_event_notification(struct notification_thread_sta trigger_status = lttng_trigger_get_name(element->trigger, &trigger_name); assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); - evaluation = lttng_evaluation_event_rule_create( - trigger_name); + if (lttng_condition_on_event_get_capture_descriptor_count( + lttng_trigger_get_const_condition(element->trigger), + &capture_count) != LTTNG_CONDITION_STATUS_OK) { + ERR("Failed to get capture count"); + ret = -1; + goto end; + } + + if (!notification->capture_buffer && capture_count != 0) { + ERR("Expected capture but capture buffer is null"); + ret = -1; + goto end; + } + + evaluation = lttng_evaluation_on_event_create( + container_of(lttng_trigger_get_const_condition( + element->trigger), + struct lttng_condition_on_event, + parent), + trigger_name, + notification->capture_buffer, + notification->capture_buf_size, false); + if (evaluation == NULL) { ERR("[notification-thread] Failed to create event rule hit evaluation while creating and enqueuing action executor job"); ret = -1; goto end_unlock; } - client_list = get_client_list_from_condition(state, lttng_trigger_get_const_condition(element->trigger)); executor_status = action_executor_enqueue(state->executor, @@ -4336,6 +4470,7 @@ next_client: pthread_mutex_unlock(&client_list->lock); break; } + case ACTION_EXECUTOR_STATUS_INVALID: case ACTION_EXECUTOR_STATUS_ERROR: /* Fatal error, shut down everything. */ ERR("Fatal error encoutered while enqueuing action to the action executor"); @@ -4347,13 +4482,46 @@ next_client: } end_unlock: - lttng_event_notifier_notification_destroy(notification); notification_client_list_put(client_list); rcu_read_unlock(); end: return ret; } +static +int handle_one_event_notifier_notification( + struct notification_thread_state *state, + int pipe, enum lttng_domain_type domain) +{ + int ret = 0; + struct lttng_event_notifier_notification *notification = NULL; + + notification = recv_one_event_notifier_notification(pipe, domain); + if (notification == NULL) { + /* Reception failed, don't consider it fatal. */ + ERR("[notification-thread] Error receiving an event notifier notification from tracer: fd = %i, domain = %s", + pipe, lttng_domain_type_str(domain)); + 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)