X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ftrace-kernel.c;h=cbafd12bd45ebbb35177894136a30e0cf7269ca5;hb=a0377dfefe40662ba7d68617bce6ff467114136c;hp=aa615214432113ef179b9ce771c897c271fc47bf;hpb=1f1567a534b09badcbe6f6c10a4693e9fddb62dc;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/trace-kernel.c b/src/bin/lttng-sessiond/trace-kernel.c index aa6152144..cbafd12bd 100644 --- a/src/bin/lttng-sessiond/trace-kernel.c +++ b/src/bin/lttng-sessiond/trace-kernel.c @@ -18,13 +18,14 @@ #include #include #include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -43,8 +44,8 @@ struct ltt_kernel_channel *trace_kernel_get_channel_by_name( { struct ltt_kernel_channel *chan; - assert(session); - assert(name); + LTTNG_ASSERT(session); + LTTNG_ASSERT(name); /* * If we receive an empty string for channel name, it means the @@ -76,8 +77,8 @@ struct ltt_kernel_event *trace_kernel_find_event( struct ltt_kernel_event *ev; int found = 0; - assert(name); - assert(channel); + LTTNG_ASSERT(name); + LTTNG_ASSERT(channel); cds_list_for_each_entry(ev, &channel->events_list.head, list) { if (type != LTTNG_EVENT_ALL && ev->type != type) { @@ -118,8 +119,8 @@ struct ltt_kernel_event *trace_kernel_get_event_by_name( struct ltt_kernel_event *ev; int found = 0; - assert(name); - assert(channel); + LTTNG_ASSERT(name); + LTTNG_ASSERT(channel); cds_list_for_each_entry(ev, &channel->events_list.head, list) { if (type != LTTNG_EVENT_ALL && ev->type != type) { @@ -219,7 +220,7 @@ struct ltt_kernel_channel *trace_kernel_create_channel( struct ltt_kernel_channel *lkc; struct lttng_channel_extended *extended = NULL; - assert(chan); + LTTNG_ASSERT(chan); lkc = zmalloc(sizeof(struct ltt_kernel_channel)); if (lkc == NULL) { @@ -251,7 +252,7 @@ struct ltt_kernel_channel *trace_kernel_create_channel( strncpy(lkc->channel->name, DEFAULT_CHANNEL_NAME, sizeof(lkc->channel->name)); } - lkc->channel->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + lkc->channel->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; lkc->fd = -1; lkc->stream_count = 0; @@ -280,7 +281,7 @@ error: * Return the allocated object or NULL on error. */ struct ltt_kernel_context *trace_kernel_create_context( - struct lttng_kernel_context *ctx) + struct lttng_kernel_abi_context *ctx) { struct ltt_kernel_context *kctx; @@ -308,7 +309,7 @@ struct ltt_kernel_context *trace_kernel_copy_context( { struct ltt_kernel_context *kctx_copy; - assert(kctx); + LTTNG_ASSERT(kctx); kctx_copy = zmalloc(sizeof(*kctx_copy)); if (!kctx_copy) { PERROR("zmalloc ltt_kernel_context"); @@ -334,14 +335,14 @@ enum lttng_error_code trace_kernel_create_event( struct ltt_kernel_event **kernel_event) { enum lttng_error_code ret; - struct lttng_kernel_event *attr; + struct lttng_kernel_abi_event *attr; struct ltt_kernel_event *local_kernel_event; struct lttng_userspace_probe_location *userspace_probe_location = NULL; - assert(ev); + LTTNG_ASSERT(ev); local_kernel_event = zmalloc(sizeof(struct ltt_kernel_event)); - attr = zmalloc(sizeof(struct lttng_kernel_event)); + attr = zmalloc(sizeof(struct lttng_kernel_abi_event)); if (local_kernel_event == NULL || attr == NULL) { PERROR("kernel event zmalloc"); ret = LTTNG_ERR_NOMEM; @@ -350,12 +351,12 @@ enum lttng_error_code trace_kernel_create_event( switch (ev->type) { case LTTNG_EVENT_PROBE: - attr->instrumentation = LTTNG_KERNEL_KPROBE; + attr->instrumentation = LTTNG_KERNEL_ABI_KPROBE; attr->u.kprobe.addr = ev->attr.probe.addr; attr->u.kprobe.offset = ev->attr.probe.offset; strncpy(attr->u.kprobe.symbol_name, - ev->attr.probe.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN); - attr->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + ev->attr.probe.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); + attr->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; case LTTNG_EVENT_USERSPACE_PROBE: { @@ -376,7 +377,7 @@ enum lttng_error_code trace_kernel_create_event( * In the interactions with the kernel tracer, we use the * uprobe term. */ - attr->instrumentation = LTTNG_KERNEL_UPROBE; + attr->instrumentation = LTTNG_KERNEL_ABI_UPROBE; lookup = lttng_userspace_probe_location_get_lookup_method( location); @@ -422,30 +423,30 @@ enum lttng_error_code trace_kernel_create_event( break; } case LTTNG_EVENT_FUNCTION: - attr->instrumentation = LTTNG_KERNEL_KRETPROBE; + attr->instrumentation = LTTNG_KERNEL_ABI_KRETPROBE; attr->u.kretprobe.addr = ev->attr.probe.addr; attr->u.kretprobe.offset = ev->attr.probe.offset; strncpy(attr->u.kretprobe.symbol_name, - ev->attr.probe.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN); - attr->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + ev->attr.probe.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); + attr->u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; case LTTNG_EVENT_FUNCTION_ENTRY: - attr->instrumentation = LTTNG_KERNEL_FUNCTION; + attr->instrumentation = LTTNG_KERNEL_ABI_FUNCTION; strncpy(attr->u.ftrace.symbol_name, - ev->attr.ftrace.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN); - attr->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + ev->attr.ftrace.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); + attr->u.ftrace.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; break; case LTTNG_EVENT_TRACEPOINT: - attr->instrumentation = LTTNG_KERNEL_TRACEPOINT; + attr->instrumentation = LTTNG_KERNEL_ABI_TRACEPOINT; break; case LTTNG_EVENT_SYSCALL: - attr->instrumentation = LTTNG_KERNEL_SYSCALL; - attr->u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_ALL; - attr->u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRYEXIT; - attr->u.syscall.match = LTTNG_KERNEL_SYSCALL_MATCH_NAME; + attr->instrumentation = LTTNG_KERNEL_ABI_SYSCALL; + attr->u.syscall.abi = LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL; + attr->u.syscall.entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT; + attr->u.syscall.match = LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME; break; case LTTNG_EVENT_ALL: - attr->instrumentation = LTTNG_KERNEL_ALL; + attr->instrumentation = LTTNG_KERNEL_ABI_ALL; break; default: ERR("Unknown kernel instrumentation type (%d)", ev->type); @@ -454,8 +455,8 @@ enum lttng_error_code trace_kernel_create_event( } /* Copy event name */ - strncpy(attr->name, ev->name, LTTNG_KERNEL_SYM_NAME_LEN); - attr->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + strncpy(attr->name, ev->name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); + attr->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; /* Setting up a kernel event */ local_kernel_event->fd = -1; @@ -485,6 +486,7 @@ error: enum lttng_error_code trace_kernel_create_event_notifier_rule( struct lttng_trigger *trigger, uint64_t token, + uint64_t error_counter_index, struct ltt_kernel_event_notifier_rule **event_notifier_rule) { enum lttng_error_code ret = LTTNG_OK; @@ -495,21 +497,21 @@ enum lttng_error_code trace_kernel_create_event_notifier_rule( const struct lttng_condition *condition = NULL; const struct lttng_event_rule *event_rule = NULL; - assert(event_notifier_rule); + LTTNG_ASSERT(event_notifier_rule); - condition = lttng_trigger_get_condition(trigger); - assert(condition); + condition = lttng_trigger_get_const_condition(trigger); + LTTNG_ASSERT(condition); condition_type = lttng_condition_get_type(condition); - assert(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_HIT); + LTTNG_ASSERT(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); - condition_status = lttng_condition_event_rule_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); local_kernel_token_event_rule = zmalloc(sizeof(struct ltt_kernel_event_notifier_rule)); @@ -522,6 +524,7 @@ enum lttng_error_code trace_kernel_create_event_notifier_rule( local_kernel_token_event_rule->fd = -1; local_kernel_token_event_rule->enabled = 1; local_kernel_token_event_rule->token = token; + local_kernel_token_event_rule->error_counter_index = error_counter_index; /* Get the reference of the event rule. */ lttng_trigger_get(trigger); @@ -543,14 +546,14 @@ error: */ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( const struct lttng_event_rule *rule, - struct lttng_kernel_event_notifier *kernel_event_notifier) + struct lttng_kernel_abi_event_notifier *kernel_event_notifier) { enum lttng_error_code ret_code; const char *name; int strncpy_ret; switch (lttng_event_rule_get_type(rule)) { - case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: + case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE: { uint64_t address = 0, offset = 0; const char *symbol_name = NULL; @@ -558,7 +561,7 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( enum lttng_kernel_probe_location_status k_status; enum lttng_event_rule_status status; - status = lttng_event_rule_kernel_probe_get_location(rule, &location); + status = lttng_event_rule_kernel_kprobe_get_location(rule, &location); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; @@ -569,14 +572,14 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( { k_status = lttng_kernel_probe_location_address_get_address( location, &address); - assert(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); + LTTNG_ASSERT(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); break; } case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET: { k_status = lttng_kernel_probe_location_symbol_get_offset( location, &offset); - assert(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); + LTTNG_ASSERT(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); symbol_name = lttng_kernel_probe_location_symbol_get_name( location); break; @@ -585,13 +588,13 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( abort(); } - kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_KPROBE; + kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_KPROBE; kernel_event_notifier->event.u.kprobe.addr = address; kernel_event_notifier->event.u.kprobe.offset = offset; if (symbol_name) { strncpy_ret = lttng_strncpy( kernel_event_notifier->event.u.kprobe.symbol_name, - symbol_name, LTTNG_KERNEL_SYM_NAME_LEN); + symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); if (strncpy_ret) { ret_code = LTTNG_ERR_INVALID; @@ -599,26 +602,26 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( } } - kernel_event_notifier->event.u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; + kernel_event_notifier->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; - status = lttng_event_rule_kernel_probe_get_name(rule, &name); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + status = lttng_event_rule_kernel_kprobe_get_event_name(rule, &name); + LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); ret_code = LTTNG_OK; break; } - case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: + case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE: { const struct lttng_userspace_probe_location* location = NULL; const struct lttng_userspace_probe_location_lookup_method *lookup = NULL; enum lttng_event_rule_status status; - 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) { ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; } - kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_UPROBE; + kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_UPROBE; lookup = lttng_userspace_probe_location_get_lookup_method( location); @@ -647,54 +650,71 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( abort(); } - status = lttng_event_rule_userspace_probe_get_name(rule, &name); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + status = lttng_event_rule_kernel_uprobe_get_event_name( + rule, &name); + LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); ret_code = LTTNG_OK; break; } - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT: { - const enum lttng_domain_type domain = - lttng_event_rule_get_domain_type(rule); const enum lttng_event_rule_status status = - lttng_event_rule_tracepoint_get_pattern( + lttng_event_rule_kernel_tracepoint_get_name_pattern( rule, &name); - assert(domain == LTTNG_DOMAIN_KERNEL); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); kernel_event_notifier->event.instrumentation = - LTTNG_KERNEL_TRACEPOINT; + LTTNG_KERNEL_ABI_TRACEPOINT; ret_code = LTTNG_OK; break; } - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: { const enum lttng_event_rule_status status = - lttng_event_rule_syscall_get_pattern( + lttng_event_rule_kernel_syscall_get_name_pattern( rule, &name); + const enum lttng_event_rule_kernel_syscall_emission_site + emission_site = + lttng_event_rule_kernel_syscall_get_emission_site(rule); + enum lttng_kernel_abi_syscall_entryexit entryexit; - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); + LTTNG_ASSERT(emission_site != LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN); + + switch(emission_site) { + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: + entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRY; + break; + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT: + entryexit = LTTNG_KERNEL_ABI_SYSCALL_EXIT; + break; + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT; + break; + default: + abort(); + break; + } kernel_event_notifier->event.instrumentation = - LTTNG_KERNEL_SYSCALL; + LTTNG_KERNEL_ABI_SYSCALL; kernel_event_notifier->event.u.syscall.abi = - LTTNG_KERNEL_SYSCALL_ABI_ALL; + LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL; kernel_event_notifier->event.u.syscall.entryexit = - LTTNG_KERNEL_SYSCALL_ENTRY; + entryexit; kernel_event_notifier->event.u.syscall.match = - LTTNG_KERNEL_SYSCALL_MATCH_NAME; + LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME; ret_code = LTTNG_OK; break; } - case LTTNG_EVENT_RULE_TYPE_KRETPROBE: default: abort(); break; } strncpy_ret = lttng_strncpy(kernel_event_notifier->event.name, name, - LTTNG_KERNEL_SYM_NAME_LEN); + LTTNG_KERNEL_ABI_SYM_NAME_LEN); if (strncpy_ret) { ret_code = LTTNG_ERR_INVALID; goto error; @@ -778,7 +798,7 @@ struct ltt_kernel_stream *trace_kernel_create_stream(const char *name, int ret; struct ltt_kernel_stream *lks; - assert(name); + LTTNG_ASSERT(name); lks = zmalloc(sizeof(struct ltt_kernel_stream)); if (lks == NULL) { @@ -810,7 +830,7 @@ error: */ void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream) { - assert(stream); + LTTNG_ASSERT(stream); DBG("[trace] Closing stream fd %d", stream->fd); /* Close kernel fd */ @@ -833,7 +853,7 @@ void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream) */ void trace_kernel_destroy_event(struct ltt_kernel_event *event) { - assert(event); + LTTNG_ASSERT(event); if (event->fd >= 0) { int ret; @@ -872,7 +892,7 @@ static void free_token_event_rule_rcu(struct rcu_head *rcu_node) void trace_kernel_destroy_event_notifier_rule( struct ltt_kernel_event_notifier_rule *event) { - assert(event); + LTTNG_ASSERT(event); if (event->fd >= 0) { const int ret = close(event->fd); @@ -895,7 +915,7 @@ void trace_kernel_destroy_event_notifier_rule( */ void trace_kernel_destroy_context(struct ltt_kernel_context *ctx) { - assert(ctx); + LTTNG_ASSERT(ctx); if (ctx->in_list) { cds_list_del(&ctx->list); @@ -914,7 +934,7 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) int ret; enum lttng_error_code status; - assert(channel); + LTTNG_ASSERT(channel); DBG("[trace] Closing channel fd %d", channel->fd); /* Close kernel fd */ @@ -943,12 +963,12 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) /* Remove from channel list */ cds_list_del(&channel->list); - if (notification_thread_handle - && channel->published_to_notification_thread) { + if (the_notification_thread_handle && + channel->published_to_notification_thread) { status = notification_thread_command_remove_channel( - notification_thread_handle, - channel->key, LTTNG_DOMAIN_KERNEL); - assert(status == LTTNG_OK); + the_notification_thread_handle, channel->key, + LTTNG_DOMAIN_KERNEL); + LTTNG_ASSERT(status == LTTNG_OK); } free(channel->channel->attr.extended.ptr); free(channel->channel); @@ -960,7 +980,7 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) */ void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata) { - assert(metadata); + LTTNG_ASSERT(metadata); DBG("[trace] Closing metadata fd %d", metadata->fd); /* Close kernel fd */ @@ -987,7 +1007,7 @@ void trace_kernel_destroy_session(struct ltt_kernel_session *session) struct ltt_kernel_channel *channel, *ctmp; int ret; - assert(session); + LTTNG_ASSERT(session); DBG("[trace] Closing session fd %d", session->fd); /* Close kernel fds */