X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ftrace-kernel.cpp;h=e1d591761977af24332bcb0c2d3f3cf8df7a7c0c;hp=1a1620aaa78605b195756dc05c269ef021f5180e;hb=5c7248cd5bce45bf64d563fb4e130a63bf345f11;hpb=2d6df81a3d233d7aaf34b874087555e72b105877 diff --git a/src/bin/lttng-sessiond/trace-kernel.cpp b/src/bin/lttng-sessiond/trace-kernel.cpp index 1a1620aaa..e1d591761 100644 --- a/src/bin/lttng-sessiond/trace-kernel.cpp +++ b/src/bin/lttng-sessiond/trace-kernel.cpp @@ -6,41 +6,42 @@ */ #define _LGPL_SOURCE -#include -#include -#include -#include +#include "consumer.hpp" +#include "lttng-sessiond.hpp" +#include "notification-thread-commands.hpp" +#include "trace-kernel.hpp" -#include -#include -#include -#include -#include +#include +#include +#include +#include + +#include #include -#include +#include #include -#include +#include #include -#include +#include #include -#include +#include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -#include "consumer.h" -#include "trace-kernel.h" -#include "lttng-sessiond.h" -#include "notification-thread-commands.h" +#include +#include +#include +#include /* * Find the channel name for the given kernel session. */ -struct ltt_kernel_channel *trace_kernel_get_channel_by_name( - const char *name, struct ltt_kernel_session *session) +struct ltt_kernel_channel *trace_kernel_get_channel_by_name(const char *name, + struct ltt_kernel_session *session) { struct ltt_kernel_channel *chan; @@ -56,23 +57,23 @@ struct ltt_kernel_channel *trace_kernel_get_channel_by_name( DBG("Trying to find channel %s", name); - cds_list_for_each_entry(chan, &session->channel_list.head, list) { + cds_list_for_each_entry (chan, &session->channel_list.head, list) { if (strcmp(name, chan->channel->name) == 0) { DBG("Found channel by name %s", name); return chan; } } - return NULL; + return nullptr; } /* * Find the event for the given channel. */ -struct ltt_kernel_event *trace_kernel_find_event( - char *name, struct ltt_kernel_channel *channel, - enum lttng_event_type type, - struct lttng_bytecode *filter) +struct ltt_kernel_event *trace_kernel_find_event(char *name, + struct ltt_kernel_channel *channel, + enum lttng_event_type type, + struct lttng_bytecode *filter) { struct ltt_kernel_event *ev; int found = 0; @@ -80,11 +81,11 @@ struct ltt_kernel_event *trace_kernel_find_event( LTTNG_ASSERT(name); LTTNG_ASSERT(channel); - cds_list_for_each_entry(ev, &channel->events_list.head, list) { + cds_list_for_each_entry (ev, &channel->events_list.head, list) { if (type != LTTNG_EVENT_ALL && ev->type != type) { continue; } - if (strcmp(name, ev->event->name)) { + if (strcmp(name, ev->event->name) != 0) { continue; } if ((ev->filter && !filter) || (!ev->filter && filter)) { @@ -92,8 +93,7 @@ struct ltt_kernel_event *trace_kernel_find_event( } if (ev->filter && filter) { if (ev->filter->len != filter->len || - memcmp(ev->filter->data, filter->data, - filter->len) != 0) { + memcmp(ev->filter->data, filter->data, filter->len) != 0) { continue; } } @@ -101,20 +101,19 @@ struct ltt_kernel_event *trace_kernel_find_event( break; } if (found) { - DBG("Found event %s for channel %s", name, - channel->channel->name); + DBG("Found event %s for channel %s", name, channel->channel->name); return ev; } else { - return NULL; + return nullptr; } } /* * Find the event name for the given channel. */ -struct ltt_kernel_event *trace_kernel_get_event_by_name( - char *name, struct ltt_kernel_channel *channel, - enum lttng_event_type type) +struct ltt_kernel_event *trace_kernel_get_event_by_name(char *name, + struct ltt_kernel_channel *channel, + enum lttng_event_type type) { struct ltt_kernel_event *ev; int found = 0; @@ -122,22 +121,21 @@ struct ltt_kernel_event *trace_kernel_get_event_by_name( LTTNG_ASSERT(name); LTTNG_ASSERT(channel); - cds_list_for_each_entry(ev, &channel->events_list.head, list) { + cds_list_for_each_entry (ev, &channel->events_list.head, list) { if (type != LTTNG_EVENT_ALL && ev->type != type) { continue; } - if (strcmp(name, ev->event->name)) { + if (strcmp(name, ev->event->name) != 0) { continue; } found = 1; break; } if (found) { - DBG("Found event %s for channel %s", name, - channel->channel->name); + DBG("Found event %s for channel %s", name, channel->channel->name); return ev; } else { - return NULL; + return nullptr; } } @@ -146,13 +144,13 @@ struct ltt_kernel_event *trace_kernel_get_event_by_name( * * Return pointer to structure or NULL. */ -struct ltt_kernel_session *trace_kernel_create_session(void) +struct ltt_kernel_session *trace_kernel_create_session() { - struct ltt_kernel_session *lks = NULL; + struct ltt_kernel_session *lks = nullptr; /* Allocate a new ltt kernel session */ - lks = (ltt_kernel_session *) zmalloc(sizeof(struct ltt_kernel_session)); - if (lks == NULL) { + lks = zmalloc(); + if (lks == nullptr) { PERROR("create kernel session zmalloc"); goto alloc_error; } @@ -162,7 +160,7 @@ struct ltt_kernel_session *trace_kernel_create_session(void) lks->metadata_stream_fd = -1; lks->channel_count = 0; lks->stream_count_global = 0; - lks->metadata = NULL; + lks->metadata = nullptr; CDS_INIT_LIST_HEAD(&lks->channel_list.head); lks->tracker_pid = process_attr_tracker_create(); @@ -190,7 +188,7 @@ struct ltt_kernel_session *trace_kernel_create_session(void) goto error; } lks->consumer = consumer_create_output(CONSUMER_DST_LOCAL); - if (lks->consumer == NULL) { + if (lks->consumer == nullptr) { goto error; } @@ -206,7 +204,7 @@ error: free(lks); alloc_error: - return NULL; + return nullptr; } /* @@ -214,27 +212,26 @@ alloc_error: * * Return pointer to structure or NULL. */ -struct ltt_kernel_channel *trace_kernel_create_channel( - struct lttng_channel *chan) +struct ltt_kernel_channel *trace_kernel_create_channel(struct lttng_channel *chan) { struct ltt_kernel_channel *lkc; - struct lttng_channel_extended *extended = NULL; + struct lttng_channel_extended *extended = nullptr; LTTNG_ASSERT(chan); - lkc = (ltt_kernel_channel *) zmalloc(sizeof(struct ltt_kernel_channel)); - if (lkc == NULL) { + lkc = zmalloc(); + if (lkc == nullptr) { PERROR("ltt_kernel_channel zmalloc"); goto error; } - lkc->channel = (lttng_channel *) zmalloc(sizeof(struct lttng_channel)); - if (lkc->channel == NULL) { + lkc->channel = zmalloc(); + if (lkc->channel == nullptr) { PERROR("lttng_channel zmalloc"); goto error; } - extended = (lttng_channel_extended *) zmalloc(sizeof(struct lttng_channel_extended)); + extended = zmalloc(); if (!extended) { PERROR("lttng_channel_channel zmalloc"); goto error; @@ -242,15 +239,14 @@ struct ltt_kernel_channel *trace_kernel_create_channel( memcpy(lkc->channel, chan, sizeof(struct lttng_channel)); memcpy(extended, chan->attr.extended.ptr, sizeof(struct lttng_channel_extended)); lkc->channel->attr.extended.ptr = extended; - extended = NULL; + extended = nullptr; /* * If we receive an empty string for channel name, it means the * default channel name is requested. */ if (chan->name[0] == '\0') { - strncpy(lkc->channel->name, DEFAULT_CHANNEL_NAME, - sizeof(lkc->channel->name)); + strncpy(lkc->channel->name, DEFAULT_CHANNEL_NAME, sizeof(lkc->channel->name)); } lkc->channel->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0'; @@ -272,7 +268,7 @@ error: } free(extended); free(lkc); - return NULL; + return nullptr; } /* @@ -280,12 +276,11 @@ error: * * Return the allocated object or NULL on error. */ -struct ltt_kernel_context *trace_kernel_create_context( - struct lttng_kernel_abi_context *ctx) +struct ltt_kernel_context *trace_kernel_create_context(struct lttng_kernel_abi_context *ctx) { struct ltt_kernel_context *kctx; - kctx = (ltt_kernel_context *) zmalloc(sizeof(*kctx)); + kctx = zmalloc(); if (!kctx) { PERROR("zmalloc kernel context"); goto error; @@ -304,13 +299,12 @@ error: * * Return the allocated object or NULL on error. */ -struct ltt_kernel_context *trace_kernel_copy_context( - struct ltt_kernel_context *kctx) +struct ltt_kernel_context *trace_kernel_copy_context(struct ltt_kernel_context *kctx) { struct ltt_kernel_context *kctx_copy; LTTNG_ASSERT(kctx); - kctx_copy = (ltt_kernel_context *) zmalloc(sizeof(*kctx_copy)); + kctx_copy = zmalloc(); if (!kctx_copy) { PERROR("zmalloc ltt_kernel_context"); goto error; @@ -329,21 +323,21 @@ error: * * Return pointer to structure or NULL. */ -enum lttng_error_code trace_kernel_create_event( - struct lttng_event *ev, char *filter_expression, - struct lttng_bytecode *filter, - struct ltt_kernel_event **kernel_event) +enum lttng_error_code trace_kernel_create_event(struct lttng_event *ev, + char *filter_expression, + struct lttng_bytecode *filter, + struct ltt_kernel_event **kernel_event) { enum lttng_error_code ret; struct lttng_kernel_abi_event *attr; struct ltt_kernel_event *local_kernel_event; - struct lttng_userspace_probe_location *userspace_probe_location = NULL; + struct lttng_userspace_probe_location *userspace_probe_location = nullptr; LTTNG_ASSERT(ev); - local_kernel_event = (ltt_kernel_event *) zmalloc(sizeof(struct ltt_kernel_event)); - attr = (lttng_kernel_abi_event *) zmalloc(sizeof(struct lttng_kernel_abi_event)); - if (local_kernel_event == NULL || attr == NULL) { + local_kernel_event = zmalloc(); + attr = zmalloc(); + if (local_kernel_event == nullptr || attr == nullptr) { PERROR("kernel event zmalloc"); ret = LTTNG_ERR_NOMEM; goto error; @@ -355,13 +349,14 @@ enum lttng_error_code trace_kernel_create_event( 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_ABI_SYM_NAME_LEN); + 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: { - const struct lttng_userspace_probe_location* location = NULL; - const struct lttng_userspace_probe_location_lookup_method *lookup = NULL; + const struct lttng_userspace_probe_location *location = nullptr; + const struct lttng_userspace_probe_location_lookup_method *lookup = nullptr; location = lttng_event_get_userspace_probe_location(ev); if (!location) { @@ -379,8 +374,7 @@ enum lttng_error_code trace_kernel_create_event( */ attr->instrumentation = LTTNG_KERNEL_ABI_UPROBE; - lookup = lttng_userspace_probe_location_get_lookup_method( - location); + lookup = lttng_userspace_probe_location_get_lookup_method(location); if (!lookup) { ret = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; @@ -394,26 +388,24 @@ enum lttng_error_code trace_kernel_create_event( case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: /* Get the file descriptor on the target binary. */ attr->u.uprobe.fd = - lttng_userspace_probe_location_function_get_binary_fd(location); + lttng_userspace_probe_location_function_get_binary_fd(location); /* * Save a reference to the probe location used during * the listing of events. */ - userspace_probe_location = - lttng_userspace_probe_location_copy(location); + userspace_probe_location = lttng_userspace_probe_location_copy(location); break; case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: /* Get the file descriptor on the target binary. */ attr->u.uprobe.fd = - lttng_userspace_probe_location_tracepoint_get_binary_fd(location); + lttng_userspace_probe_location_tracepoint_get_binary_fd(location); /* * Save a reference to the probe location used during the listing of * events. */ - userspace_probe_location = - lttng_userspace_probe_location_copy(location); + userspace_probe_location = lttng_userspace_probe_location_copy(location); break; default: DBG("Unsupported lookup method type"); @@ -427,13 +419,15 @@ enum lttng_error_code trace_kernel_create_event( 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_ABI_SYM_NAME_LEN); + 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_ABI_FUNCTION; strncpy(attr->u.ftrace.symbol_name, - ev->attr.ftrace.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); + 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: @@ -483,19 +477,19 @@ error: * * Return pointer to structure or NULL. */ -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 +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; enum lttng_condition_type condition_type; enum lttng_event_rule_type event_rule_type; enum lttng_condition_status condition_status; struct ltt_kernel_event_notifier_rule *local_kernel_token_event_rule; - const struct lttng_condition *condition = NULL; - const struct lttng_event_rule *event_rule = NULL; + const struct lttng_condition *condition = nullptr; + const struct lttng_event_rule *event_rule = nullptr; LTTNG_ASSERT(event_notifier_rule); @@ -505,17 +499,15 @@ enum lttng_error_code trace_kernel_create_event_notifier_rule( condition_type = lttng_condition_get_type(condition); LTTNG_ASSERT(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES); - condition_status = lttng_condition_event_rule_matches_get_rule( - condition, &event_rule); + condition_status = lttng_condition_event_rule_matches_get_rule(condition, &event_rule); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); LTTNG_ASSERT(event_rule); event_rule_type = lttng_event_rule_get_type(event_rule); LTTNG_ASSERT(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN); - local_kernel_token_event_rule = - (ltt_kernel_event_notifier_rule *) zmalloc(sizeof(struct ltt_kernel_event_notifier_rule)); - if (local_kernel_token_event_rule == NULL) { + local_kernel_token_event_rule = zmalloc(); + if (local_kernel_token_event_rule == nullptr) { PERROR("Failed to allocate ltt_kernel_token_event_rule structure"); ret = LTTNG_ERR_NOMEM; goto error; @@ -531,11 +523,10 @@ enum lttng_error_code trace_kernel_create_event_notifier_rule( local_kernel_token_event_rule->trigger = trigger; /* The event rule still owns the filter and bytecode. */ - local_kernel_token_event_rule->filter = - lttng_event_rule_get_filter_bytecode(event_rule); + local_kernel_token_event_rule->filter = lttng_event_rule_get_filter_bytecode(event_rule); DBG3("Created kernel event notifier rule: token = %" PRIu64, - local_kernel_token_event_rule->token); + local_kernel_token_event_rule->token); error: *event_notifier_rule = local_kernel_token_event_rule; return ret; @@ -545,8 +536,8 @@ error: * Initialize a kernel trigger from an event rule. */ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( - const struct lttng_event_rule *rule, - struct lttng_kernel_abi_event_notifier *kernel_event_notifier) + const struct lttng_event_rule *rule, + struct lttng_kernel_abi_event_notifier *kernel_event_notifier) { enum lttng_error_code ret_code; const char *name; @@ -556,8 +547,8 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE: { uint64_t address = 0, offset = 0; - const char *symbol_name = NULL; - const struct lttng_kernel_probe_location *location = NULL; + const char *symbol_name = nullptr; + const struct lttng_kernel_probe_location *location = nullptr; enum lttng_kernel_probe_location_status k_status; enum lttng_event_rule_status status; @@ -570,18 +561,16 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( switch (lttng_kernel_probe_location_get_type(location)) { case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS: { - k_status = lttng_kernel_probe_location_address_get_address( - location, &address); + k_status = + lttng_kernel_probe_location_address_get_address(location, &address); 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); + k_status = lttng_kernel_probe_location_symbol_get_offset(location, &offset); LTTNG_ASSERT(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); - symbol_name = lttng_kernel_probe_location_symbol_get_name( - location); + symbol_name = lttng_kernel_probe_location_symbol_get_name(location); break; } default: @@ -593,9 +582,9 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( 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, - sizeof(kernel_event_notifier->event.u.kprobe.symbol_name)); + kernel_event_notifier->event.u.kprobe.symbol_name, + symbol_name, + sizeof(kernel_event_notifier->event.u.kprobe.symbol_name)); if (strncpy_ret) { ret_code = LTTNG_ERR_INVALID; @@ -603,7 +592,8 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( } } - kernel_event_notifier->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_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_kprobe_get_event_name(rule, &name); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); @@ -612,8 +602,8 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( } 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; + const struct lttng_userspace_probe_location *location = nullptr; + const struct lttng_userspace_probe_location_lookup_method *lookup = nullptr; enum lttng_event_rule_status status; status = lttng_event_rule_kernel_uprobe_get_location(rule, &location); @@ -624,8 +614,7 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_UPROBE; - lookup = lttng_userspace_probe_location_get_lookup_method( - location); + lookup = lttng_userspace_probe_location_get_lookup_method(location); if (!lookup) { ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL; goto error; @@ -639,20 +628,19 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: /* Get the file descriptor on the target binary. */ kernel_event_notifier->event.u.uprobe.fd = - lttng_userspace_probe_location_function_get_binary_fd(location); + lttng_userspace_probe_location_function_get_binary_fd(location); break; case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: /* Get the file descriptor on the target binary. */ kernel_event_notifier->event.u.uprobe.fd = - lttng_userspace_probe_location_tracepoint_get_binary_fd(location); + lttng_userspace_probe_location_tracepoint_get_binary_fd(location); break; default: abort(); } - status = lttng_event_rule_kernel_uprobe_get_event_name( - rule, &name); + status = lttng_event_rule_kernel_uprobe_get_event_name(rule, &name); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); ret_code = LTTNG_OK; break; @@ -660,12 +648,10 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT: { const enum lttng_event_rule_status status = - lttng_event_rule_kernel_tracepoint_get_name_pattern( - rule, &name); + lttng_event_rule_kernel_tracepoint_get_name_pattern(rule, &name); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); - kernel_event_notifier->event.instrumentation = - LTTNG_KERNEL_ABI_TRACEPOINT; + kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_TRACEPOINT; ret_code = LTTNG_OK; break; @@ -673,17 +659,16 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: { const enum lttng_event_rule_status status = - 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_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; LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); - LTTNG_ASSERT(emission_site != LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN); + LTTNG_ASSERT(emission_site != + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN); - switch(emission_site) { + switch (emission_site) { case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRY; break; @@ -698,14 +683,10 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( break; } - kernel_event_notifier->event.instrumentation = - LTTNG_KERNEL_ABI_SYSCALL; - kernel_event_notifier->event.u.syscall.abi = - LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL; - kernel_event_notifier->event.u.syscall.entryexit = - entryexit; - kernel_event_notifier->event.u.syscall.match = - LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME; + kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_SYSCALL; + kernel_event_notifier->event.u.syscall.abi = LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL; + kernel_event_notifier->event.u.syscall.entryexit = entryexit; + kernel_event_notifier->event.u.syscall.match = LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME; ret_code = LTTNG_OK; break; } @@ -714,8 +695,8 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( break; } - strncpy_ret = lttng_strncpy(kernel_event_notifier->event.name, name, - LTTNG_KERNEL_ABI_SYM_NAME_LEN); + strncpy_ret = lttng_strncpy( + kernel_event_notifier->event.name, name, LTTNG_KERNEL_ABI_SYM_NAME_LEN); if (strncpy_ret) { ret_code = LTTNG_ERR_INVALID; goto error; @@ -729,24 +710,22 @@ error: * * Return pointer to structure or NULL. */ -struct ltt_kernel_metadata *trace_kernel_create_metadata(void) +struct ltt_kernel_metadata *trace_kernel_create_metadata() { int ret; struct ltt_kernel_metadata *lkm; struct lttng_channel *chan; - lkm = (ltt_kernel_metadata *) zmalloc(sizeof(struct ltt_kernel_metadata)); - chan = (lttng_channel *) zmalloc(sizeof(struct lttng_channel)); - if (lkm == NULL || chan == NULL) { + lkm = zmalloc(); + chan = zmalloc(); + if (lkm == nullptr || chan == nullptr) { PERROR("kernel metadata zmalloc"); goto error; } - ret = lttng_strncpy( - chan->name, DEFAULT_METADATA_NAME, sizeof(chan->name)); + ret = lttng_strncpy(chan->name, DEFAULT_METADATA_NAME, sizeof(chan->name)); if (ret) { - ERR("Failed to initialize metadata channel name to `%s`", - DEFAULT_METADATA_NAME); + ERR("Failed to initialize metadata channel name to `%s`", DEFAULT_METADATA_NAME); goto error; } @@ -755,8 +734,8 @@ struct ltt_kernel_metadata *trace_kernel_create_metadata(void) chan->attr.subbuf_size = default_get_metadata_subbuf_size(); chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM; chan->attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER; - chan->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER;; - + chan->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER; + ; /* * The metadata channel of kernel sessions must use the "mmap" @@ -784,7 +763,7 @@ struct ltt_kernel_metadata *trace_kernel_create_metadata(void) error: free(lkm); free(chan); - return NULL; + return nullptr; } /* @@ -793,16 +772,15 @@ error: * * Return pointer to structure or NULL. */ -struct ltt_kernel_stream *trace_kernel_create_stream(const char *name, - unsigned int count) +struct ltt_kernel_stream *trace_kernel_create_stream(const char *name, unsigned int count) { int ret; struct ltt_kernel_stream *lks; LTTNG_ASSERT(name); - lks = (ltt_kernel_stream *) zmalloc(sizeof(struct ltt_kernel_stream)); - if (lks == NULL) { + lks = zmalloc(); + if (lks == nullptr) { PERROR("kernel stream zmalloc"); goto error; } @@ -823,7 +801,7 @@ struct ltt_kernel_stream *trace_kernel_create_stream(const char *name, return lks; error: - return NULL; + return nullptr; } /* @@ -884,25 +862,23 @@ void trace_kernel_destroy_event(struct ltt_kernel_event *event) */ static void free_token_event_rule_rcu(struct rcu_head *rcu_node) { - struct ltt_kernel_event_notifier_rule *rule = caa_container_of(rcu_node, - struct ltt_kernel_event_notifier_rule, rcu_node); + struct ltt_kernel_event_notifier_rule *rule = + caa_container_of(rcu_node, struct ltt_kernel_event_notifier_rule, rcu_node); free(rule); } -void trace_kernel_destroy_event_notifier_rule( - struct ltt_kernel_event_notifier_rule *event) +void trace_kernel_destroy_event_notifier_rule(struct ltt_kernel_event_notifier_rule *event) { LTTNG_ASSERT(event); if (event->fd >= 0) { const int ret = close(event->fd); - DBG("Closing kernel event notifier rule file descriptor: fd = %d", - event->fd); + DBG("Closing kernel event notifier rule file descriptor: fd = %d", event->fd); if (ret) { PERROR("Failed to close kernel event notifier file descriptor: fd = %d", - event->fd); + event->fd); } } else { DBG("Destroying kernel event notifier rule (no associated file descriptor)"); @@ -947,28 +923,26 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) } /* For each stream in the channel list */ - cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) { + cds_list_for_each_entry_safe (stream, stmp, &channel->stream_list.head, list) { trace_kernel_destroy_stream(stream); } /* For each event in the channel list */ - cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) { + cds_list_for_each_entry_safe (event, etmp, &channel->events_list.head, list) { trace_kernel_destroy_event(event); } /* For each context in the channel list */ - cds_list_for_each_entry_safe(ctx, ctmp, &channel->ctx_list, list) { + cds_list_for_each_entry_safe (ctx, ctmp, &channel->ctx_list, list) { trace_kernel_destroy_context(ctx); } /* Remove from channel list */ cds_list_del(&channel->list); - if (the_notification_thread_handle && - channel->published_to_notification_thread) { + if (the_notification_thread_handle && channel->published_to_notification_thread) { status = notification_thread_command_remove_channel( - the_notification_thread_handle, channel->key, - LTTNG_DOMAIN_KERNEL); + the_notification_thread_handle, channel->key, LTTNG_DOMAIN_KERNEL); LTTNG_ASSERT(status == LTTNG_OK); } free(channel->channel->attr.extended.ptr); @@ -1025,11 +999,11 @@ void trace_kernel_destroy_session(struct ltt_kernel_session *session) } } - if (session->metadata != NULL) { + if (session->metadata != nullptr) { trace_kernel_destroy_metadata(session->metadata); } - cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) { + cds_list_for_each_entry_safe (channel, ctmp, &session->channel_list.head, list) { trace_kernel_destroy_channel(channel); } }