X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=ffbde695ec575cc1e6950235a10b7a297c22f175;hp=4e5216edcf3274acbc01937038b3fe8c52316fb7;hb=3a5f70173aa04d11ccb22694d5d31a702cad33ab;hpb=d602bd6a8ee25d5ca662dde4edb3db3cabf264e1 diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 4e5216edc..ffbde695e 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -28,12 +28,13 @@ #include #include -#include -#include +#include +#include #include #include -#include +#include +#include "event-notifier-error-accounting.h" #include "lttng-sessiond.h" #include "lttng-syscall.h" #include "condition-internal.h" @@ -41,6 +42,7 @@ #include "kernel.h" #include "kernel-consumer.h" #include "kern-modules.h" +#include "sessiond-config.h" #include "utils.h" #include "rotate.h" #include "modprobe.h" @@ -70,8 +72,8 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, { int ret; - assert(chan); - assert(ctx); + LTTNG_ASSERT(chan); + LTTNG_ASSERT(ctx); DBG("Adding context to channel %s", chan->channel->name); ret = kernctl_add_context(chan->fd, &ctx->ctx); @@ -113,7 +115,7 @@ int kernel_create_session(struct ltt_session *session) int ret; struct ltt_kernel_session *lks; - assert(session); + LTTNG_ASSERT(session); /* Allocate data structure */ lks = trace_kernel_create_session(); @@ -182,8 +184,8 @@ int kernel_create_channel(struct ltt_kernel_session *session, int ret; struct ltt_kernel_channel *lkc; - assert(session); - assert(chan); + LTTNG_ASSERT(session); + LTTNG_ASSERT(chan); /* Allocate kernel channel */ lkc = trace_kernel_create_channel(chan); @@ -240,7 +242,7 @@ static int kernel_create_event_notifier_group(int *event_notifier_group_fd) int ret; int local_fd = -1; - assert(event_notifier_group_fd); + LTTNG_ASSERT(event_notifier_group_fd); /* Kernel event notifier group creation. */ ret = kernctl_create_event_notifier_group(kernel_tracer_fd); @@ -295,7 +297,7 @@ int extract_userspace_probe_offset_function_elf( const struct lttng_userspace_probe_location_lookup_method *lookup = NULL; enum lttng_userspace_probe_location_lookup_method_type lookup_method_type; - assert(lttng_userspace_probe_location_get_type(probe_location) == + LTTNG_ASSERT(lttng_userspace_probe_location_get_type(probe_location) == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION); lookup = lttng_userspace_probe_location_get_lookup_method( @@ -308,7 +310,7 @@ int extract_userspace_probe_offset_function_elf( lookup_method_type = lttng_userspace_probe_location_lookup_method_get_type(lookup); - assert(lookup_method_type == + LTTNG_ASSERT(lookup_method_type == LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF); symbol = lttng_userspace_probe_location_function_get_function_name( @@ -357,7 +359,7 @@ int extract_userspace_probe_offset_tracepoint_sdt( int ret = 0; int fd, i; - assert(lttng_userspace_probe_location_get_type(probe_location) == + LTTNG_ASSERT(lttng_userspace_probe_location_get_type(probe_location) == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT); lookup = lttng_userspace_probe_location_get_lookup_method(probe_location); @@ -369,7 +371,7 @@ int extract_userspace_probe_offset_tracepoint_sdt( lookup_method_type = lttng_userspace_probe_location_lookup_method_get_type(lookup); - assert(lookup_method_type == + LTTNG_ASSERT(lookup_method_type == LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT); @@ -434,7 +436,7 @@ int userspace_probe_add_callsite( switch (type) { case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: { - struct lttng_kernel_event_callsite callsite; + struct lttng_kernel_abi_event_callsite callsite; uint64_t offset; ret = extract_userspace_probe_offset_function_elf(location, @@ -458,7 +460,7 @@ int userspace_probe_add_callsite( int i; uint64_t *offsets = NULL; uint32_t offsets_count; - struct lttng_kernel_event_callsite callsite; + struct lttng_kernel_abi_event_callsite callsite; /* * This call allocates the offsets buffer. This buffer must be freed @@ -502,8 +504,8 @@ int userspace_probe_event_add_callsites(struct lttng_event *ev, int ret; const struct lttng_userspace_probe_location *location = NULL; - assert(ev); - assert(ev->type == LTTNG_EVENT_USERSPACE_PROBE); + LTTNG_ASSERT(ev); + LTTNG_ASSERT(ev->type == LTTNG_EVENT_USERSPACE_PROBE); location = lttng_event_get_userspace_probe_location(ev); if (!location) { @@ -536,13 +538,13 @@ static int userspace_probe_event_rule_add_callsites( enum lttng_event_rule_type event_rule_type; const struct lttng_userspace_probe_location *location = NULL; - assert(rule); - assert(creds); + LTTNG_ASSERT(rule); + LTTNG_ASSERT(creds); event_rule_type = lttng_event_rule_get_type(rule); - assert(event_rule_type == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE); + LTTNG_ASSERT(event_rule_type == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE); - status = lttng_event_rule_userspace_probe_get_location(rule, &location); + status = lttng_event_rule_kernel_uprobe_get_location(rule, &location); if (status != LTTNG_EVENT_RULE_STATUS_OK || !location) { ret = -1; goto end; @@ -574,8 +576,8 @@ int kernel_create_event(struct lttng_event *ev, enum lttng_error_code ret; struct ltt_kernel_event *event; - assert(ev); - assert(channel); + LTTNG_ASSERT(ev); + LTTNG_ASSERT(channel); /* We pass ownership of filter_expression and filter */ ret = trace_kernel_create_event(ev, filter_expression, @@ -682,7 +684,7 @@ int kernel_disable_channel(struct ltt_kernel_channel *chan) { int ret; - assert(chan); + LTTNG_ASSERT(chan); ret = kernctl_disable(chan->fd); if (ret < 0) { @@ -707,7 +709,7 @@ int kernel_enable_channel(struct ltt_kernel_channel *chan) { int ret; - assert(chan); + LTTNG_ASSERT(chan); ret = kernctl_enable(chan->fd); if (ret < 0 && ret != -EEXIST) { @@ -732,7 +734,7 @@ int kernel_enable_event(struct ltt_kernel_event *event) { int ret; - assert(event); + LTTNG_ASSERT(event); ret = kernctl_enable(event->fd); if (ret < 0) { @@ -763,18 +765,12 @@ int kernel_disable_event(struct ltt_kernel_event *event) { int ret; - assert(event); + LTTNG_ASSERT(event); ret = kernctl_disable(event->fd); if (ret < 0) { - switch (-ret) { - case EEXIST: - ret = LTTNG_ERR_KERN_EVENT_EXIST; - break; - default: - PERROR("disable kernel event"); - break; - } + PERROR("Failed to disable kernel event: name = '%s', fd = %d", + event->event->name, event->fd); goto error; } @@ -795,7 +791,7 @@ int kernel_disable_event_notifier_rule(struct ltt_kernel_event_notifier_rule *ev { int ret; - assert(event); + LTTNG_ASSERT(event); rcu_read_lock(); cds_lfht_del(kernel_token_to_event_notifier_rule_ht, &event->ht_node); @@ -803,15 +799,8 @@ int kernel_disable_event_notifier_rule(struct ltt_kernel_event_notifier_rule *ev ret = kernctl_disable(event->fd); if (ret < 0) { - switch (-ret) { - case EEXIST: - ret = LTTNG_ERR_KERN_EVENT_EXIST; - break; - default: - PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64, - event->fd, event->token); - break; - } + PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64, + event->fd, event->token); goto error; } @@ -1198,7 +1187,7 @@ int kernel_open_metadata(struct ltt_kernel_session *session) int ret; struct ltt_kernel_metadata *lkm = NULL; - assert(session); + LTTNG_ASSERT(session); /* Allocate kernel metadata */ lkm = trace_kernel_create_metadata(); @@ -1239,7 +1228,7 @@ int kernel_start_session(struct ltt_kernel_session *session) { int ret; - assert(session); + LTTNG_ASSERT(session); ret = kernctl_start_session(session->fd); if (ret < 0) { @@ -1297,7 +1286,7 @@ int kernel_flush_buffer(struct ltt_kernel_channel *channel) int ret; struct ltt_kernel_stream *stream; - assert(channel); + LTTNG_ASSERT(channel); DBG("Flush buffer for channel %s", channel->channel->name); @@ -1321,7 +1310,7 @@ int kernel_stop_session(struct ltt_kernel_session *session) { int ret; - assert(session); + LTTNG_ASSERT(session); ret = kernctl_stop_session(session->fd); if (ret < 0) { @@ -1351,7 +1340,7 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) int ret; struct ltt_kernel_stream *lks; - assert(channel); + LTTNG_ASSERT(channel); while ((ret = kernctl_create_stream(channel->fd)) >= 0) { lks = trace_kernel_create_stream(channel->channel->name, @@ -1395,7 +1384,7 @@ int kernel_open_metadata_stream(struct ltt_kernel_session *session) { int ret; - assert(session); + LTTNG_ASSERT(session); ret = kernctl_create_stream(session->metadata->fd); if (ret < 0) { @@ -1428,7 +1417,7 @@ ssize_t kernel_list_events(struct lttng_event **events) FILE *fp; struct lttng_event *elist; - assert(events); + LTTNG_ASSERT(events); fd = kernctl_tracepoint_list(kernel_tracer_fd); if (fd < 0) { @@ -1504,8 +1493,8 @@ error: /* * Get kernel version and validate it. */ -int kernel_validate_version(struct lttng_kernel_tracer_version *version, - struct lttng_kernel_tracer_abi_version *abi_version) +int kernel_validate_version(struct lttng_kernel_abi_tracer_version *version, + struct lttng_kernel_abi_tracer_abi_version *abi_version) { int ret; @@ -1526,10 +1515,10 @@ int kernel_validate_version(struct lttng_kernel_tracer_version *version, ERR("Failed to retrieve lttng-modules ABI version"); goto error; } - if (abi_version->major != LTTNG_MODULES_ABI_MAJOR_VERSION) { + if (abi_version->major != LTTNG_KERNEL_ABI_MAJOR_VERSION) { ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)", abi_version->major, abi_version->minor, - LTTNG_MODULES_ABI_MAJOR_VERSION); + LTTNG_KERNEL_ABI_MAJOR_VERSION); goto error; } DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)", @@ -1644,8 +1633,8 @@ void kernel_destroy_channel(struct ltt_kernel_channel *kchan) { struct ltt_kernel_session *ksess = NULL; - assert(kchan); - assert(kchan->channel); + LTTNG_ASSERT(kchan); + LTTNG_ASSERT(kchan->channel); DBG3("Kernel destroy channel %s", kchan->channel->name); @@ -1685,9 +1674,9 @@ enum lttng_error_code kernel_snapshot_record( char *trace_path = NULL; size_t consumer_path_offset = 0; - assert(ksess); - assert(ksess->consumer); - assert(output); + LTTNG_ASSERT(ksess); + LTTNG_ASSERT(ksess->consumer); + LTTNG_ASSERT(output); DBG("Kernel snapshot record started"); @@ -1710,7 +1699,7 @@ enum lttng_error_code kernel_snapshot_record( } trace_path = setup_channel_trace_path(ksess->consumer, - DEFAULT_KERNEL_TRACE_DIR, &consumer_path_offset); + "", &consumer_path_offset); if (!trace_path) { status = LTTNG_ERR_INVALID; goto error; @@ -1783,8 +1772,8 @@ error: */ int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits) { - assert(syscall_mask); - assert(nr_bits); + LTTNG_ASSERT(syscall_mask); + LTTNG_ASSERT(nr_bits); return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits); } @@ -1793,7 +1782,7 @@ static int kernel_tracer_abi_greater_or_equal(unsigned int major, unsigned int minor) { int ret; - struct lttng_kernel_tracer_abi_version abi; + struct lttng_kernel_abi_tracer_abi_version abi; ret = kernctl_tracer_abi_version(kernel_tracer_fd, &abi); if (ret < 0) { @@ -1863,8 +1852,8 @@ enum lttng_error_code kernel_rotate_session(struct ltt_session *session) struct lttng_ht_iter iter; struct ltt_kernel_session *ksess = session->kernel_session; - assert(ksess); - assert(ksess->consumer); + LTTNG_ASSERT(ksess); + LTTNG_ASSERT(ksess->consumer); DBG("Rotate kernel session %s started (session %" PRIu64 ")", session->name, session->id); @@ -1916,7 +1905,7 @@ enum lttng_error_code kernel_create_channel_subdirectories( enum lttng_trace_chunk_status chunk_status; rcu_read_lock(); - assert(ksess->current_trace_chunk); + LTTNG_ASSERT(ksess->current_trace_chunk); /* * Create the index subdirectory which will take care @@ -1937,7 +1926,6 @@ error: /* * Setup necessary data for kernel tracer action. */ -LTTNG_HIDDEN int init_kernel_tracer(void) { int ret; @@ -1957,8 +1945,8 @@ int init_kernel_tracer(void) } /* Validate kernel version */ - ret = kernel_validate_version(&kernel_tracer_version, - &kernel_tracer_abi_version); + ret = kernel_validate_version(&the_kernel_tracer_version, + &the_kernel_tracer_abi_version); if (ret < 0) { goto error_version; } @@ -1989,7 +1977,8 @@ int init_kernel_tracer(void) WARN("Failed to create kernel event notifier group"); kernel_tracer_event_notifier_group_fd = -1; } else { - const enum lttng_error_code error_code_ret = + enum event_notifier_error_accounting_status error_accounting_status; + enum lttng_error_code error_code_ret = kernel_create_event_notifier_group_notification_fd( &kernel_tracer_event_notifier_group_notification_fd); @@ -1997,6 +1986,14 @@ int init_kernel_tracer(void) goto error_modules; } + error_accounting_status = event_notifier_error_accounting_register_kernel( + kernel_tracer_event_notifier_group_fd); + if (error_accounting_status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { + ERR("Failed to initialize event notifier error accounting for kernel tracer"); + error_code_ret = LTTNG_ERR_EVENT_NOTIFIER_ERROR_ACCOUNTING; + goto error_modules; + } + kernel_token_to_event_notifier_rule_ht = cds_lfht_new( DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, @@ -2025,6 +2022,7 @@ error_version: PERROR("Failed to close kernel tracer file descriptor: fd = %d", kernel_tracer_fd); } + kernel_tracer_fd = -1; return LTTNG_ERR_KERN_VERSION; @@ -2036,6 +2034,8 @@ error_token_ht: kernel_tracer_event_notifier_group_notification_fd); } + kernel_tracer_event_notifier_group_notification_fd = -1; + error_modules: ret = close(kernel_tracer_event_notifier_group_fd); if (ret) { @@ -2043,12 +2043,16 @@ error_modules: kernel_tracer_event_notifier_group_fd); } + kernel_tracer_event_notifier_group_fd = -1; + ret = close(kernel_tracer_fd); if (ret) { PERROR("Failed to close kernel tracer file descriptor: fd = %d", kernel_tracer_fd); } + kernel_tracer_fd = -1; + error_open: modprobe_remove_lttng_control(); @@ -2062,13 +2066,12 @@ error: } } -LTTNG_HIDDEN void cleanup_kernel_tracer(void) { DBG2("Closing kernel event notifier group notification file descriptor"); if (kernel_tracer_event_notifier_group_notification_fd >= 0) { int ret = notification_thread_command_remove_tracer_event_source( - notification_thread_handle, + the_notification_thread_handle, kernel_tracer_event_notifier_group_notification_fd); if (ret != LTTNG_OK) { ERR("Failed to remove kernel event notifier notification from notification thread"); @@ -2086,7 +2089,7 @@ void cleanup_kernel_tracer(void) if (kernel_token_to_event_notifier_rule_ht) { const int ret = cds_lfht_destroy( kernel_token_to_event_notifier_rule_ht, NULL); - assert(ret == 0); + LTTNG_ASSERT(ret == 0); } DBG2("Closing kernel event notifier group file descriptor"); @@ -2113,12 +2116,9 @@ void cleanup_kernel_tracer(void) kernel_tracer_fd = -1; } - DBG("Unloading kernel modules"); - modprobe_remove_lttng_all(); free(syscall_table); } -LTTNG_HIDDEN bool kernel_tracer_is_initialized(void) { return kernel_tracer_fd >= 0; @@ -2137,8 +2137,8 @@ enum lttng_error_code kernel_clear_session(struct ltt_session *session) struct lttng_ht_iter iter; struct ltt_kernel_session *ksess = session->kernel_session; - assert(ksess); - assert(ksess->consumer); + LTTNG_ASSERT(ksess); + LTTNG_ASSERT(ksess->consumer); DBG("Clear kernel session %s (session %" PRIu64 ")", session->name, session->id); @@ -2210,7 +2210,7 @@ enum lttng_error_code kernel_create_event_notifier_group_notification_fd( int local_fd = -1, ret; enum lttng_error_code error_code_ret; - assert(event_notifier_group_notification_fd); + LTTNG_ASSERT(event_notifier_group_notification_fd); ret = kernctl_create_event_notifier_group_notification_fd( kernel_tracer_event_notifier_group_fd); @@ -2298,30 +2298,32 @@ static enum lttng_error_code kernel_create_event_notifier_rule( enum lttng_condition_type condition_type; enum lttng_event_rule_type event_rule_type; struct ltt_kernel_event_notifier_rule *event_notifier_rule; - struct lttng_kernel_event_notifier kernel_event_notifier = {}; + struct lttng_kernel_abi_event_notifier kernel_event_notifier = {}; unsigned int capture_bytecode_count = 0, i; const struct lttng_condition *condition = NULL; const struct lttng_event_rule *event_rule = NULL; enum lttng_condition_status cond_status; - assert(trigger); + LTTNG_ASSERT(trigger); condition = lttng_trigger_get_const_condition(trigger); - assert(condition); + LTTNG_ASSERT(condition); condition_type = lttng_condition_get_type(condition); - assert(condition_type == LTTNG_CONDITION_TYPE_ON_EVENT); + LTTNG_ASSERT(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); /* Does not acquire a reference. */ - condition_status = lttng_condition_on_event_get_rule( + condition_status = lttng_condition_event_rule_matches_get_rule( condition, &event_rule); - assert(condition_status == LTTNG_CONDITION_STATUS_OK); - assert(event_rule); + LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); + LTTNG_ASSERT(event_rule); event_rule_type = lttng_event_rule_get_type(event_rule); - assert(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN); + LTTNG_ASSERT(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN); error_code_ret = trace_kernel_create_event_notifier_rule(trigger, token, + lttng_condition_event_rule_matches_get_error_counter_index( + condition), &event_notifier_rule); if (error_code_ret != LTTNG_OK) { goto error; @@ -2334,6 +2336,9 @@ static enum lttng_error_code kernel_create_event_notifier_rule( } kernel_event_notifier.event.token = event_notifier_rule->token; + kernel_event_notifier.error_counter_idx = + lttng_condition_event_rule_matches_get_error_counter_index( + condition); fd = kernctl_create_event_notifier( kernel_tracer_event_notifier_group_fd, @@ -2386,7 +2391,7 @@ static enum lttng_error_code kernel_create_event_notifier_rule( } if (lttng_event_rule_get_type(event_rule) == - LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE) { + LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE) { ret = userspace_probe_event_rule_add_callsites( event_rule, creds, event_notifier_rule->fd); if (ret) { @@ -2396,19 +2401,19 @@ static enum lttng_error_code kernel_create_event_notifier_rule( } /* Set the capture bytecode if any. */ - cond_status = lttng_condition_on_event_get_capture_descriptor_count( + cond_status = lttng_condition_event_rule_matches_get_capture_descriptor_count( condition, &capture_bytecode_count); - assert(cond_status == LTTNG_CONDITION_STATUS_OK); + LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK); for (i = 0; i < capture_bytecode_count; i++) { const struct lttng_bytecode *capture_bytecode = - lttng_condition_on_event_get_capture_bytecode_at_index( + lttng_condition_event_rule_matches_get_capture_bytecode_at_index( condition, i); if (capture_bytecode == NULL) { ERR("Unexpected NULL capture bytecode on condition"); error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL; - goto error; + goto capture_error; } ret = kernctl_capture(event_notifier_rule->fd, capture_bytecode); @@ -2416,7 +2421,7 @@ static enum lttng_error_code kernel_create_event_notifier_rule( ERR("Failed to set capture bytecode on event notifier rule fd: fd = %d", event_notifier_rule->fd); error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL; - goto error; + goto capture_error; } } @@ -2446,6 +2451,7 @@ static enum lttng_error_code kernel_create_event_notifier_rule( return LTTNG_OK; +capture_error: add_callsite_error: enable_error: set_cloexec_error: @@ -2476,15 +2482,15 @@ enum lttng_error_code kernel_register_event_notifier( lttng_trigger_get_const_condition(trigger); const uint64_t token = lttng_trigger_get_tracer_token(trigger); - assert(condition); + LTTNG_ASSERT(condition); /* Does not acquire a reference to the event rule. */ - status = lttng_condition_on_event_get_rule( + status = lttng_condition_event_rule_matches_get_rule( condition, &event_rule); - assert(status == LTTNG_CONDITION_STATUS_OK); + LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK); domain_type = lttng_event_rule_get_domain_type(event_rule); - assert(domain_type == LTTNG_DOMAIN_KERNEL); + LTTNG_ASSERT(domain_type == LTTNG_DOMAIN_KERNEL); ret = kernel_create_event_notifier_rule(trigger, cmd_creds, token); if (ret != LTTNG_OK) {