X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fevent-notifier-error-accounting.cpp;fp=src%2Fbin%2Flttng-sessiond%2Fevent-notifier-error-accounting.cpp;h=93ecca853af7a4ecdf76f841f499d7a9072273a1;hp=85327c2167b648d38541dcb282cdf2ca613f7908;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/src/bin/lttng-sessiond/event-notifier-error-accounting.cpp b/src/bin/lttng-sessiond/event-notifier-error-accounting.cpp index 85327c216..93ecca853 100644 --- a/src/bin/lttng-sessiond/event-notifier-error-accounting.cpp +++ b/src/bin/lttng-sessiond/event-notifier-error-accounting.cpp @@ -5,23 +5,24 @@ * */ -#include -#include -#include -#include -#include -#include +#include "event-notifier-error-accounting.hpp" +#include "lttng-ust-error.hpp" +#include "ust-app.hpp" #include #include #include #include #include + #include -#include "event-notifier-error-accounting.hpp" -#include "lttng-ust-error.hpp" -#include "ust-app.hpp" +#include +#include +#include +#include +#include +#include #define ERROR_COUNTER_INDEX_HT_INITIAL_SIZE 16 @@ -71,8 +72,8 @@ struct error_accounting_state kernel_state; } /* namespace */ static inline void get_trigger_info_for_log(const struct lttng_trigger *trigger, - const char **trigger_name, - uid_t *trigger_owner_uid) + const char **trigger_name, + uid_t *trigger_owner_uid) { enum lttng_trigger_status trigger_status; @@ -87,14 +88,12 @@ static inline void get_trigger_info_for_log(const struct lttng_trigger *trigger, abort(); } - trigger_status = lttng_trigger_get_owner_uid(trigger, - trigger_owner_uid); + trigger_status = lttng_trigger_get_owner_uid(trigger, trigger_owner_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); } -static inline -const char *error_accounting_status_str( - enum event_notifier_error_accounting_status status) +static inline const char * +error_accounting_status_str(enum event_notifier_error_accounting_status status) { switch (status) { case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK: @@ -128,7 +127,7 @@ static void free_ust_error_accounting_entry(struct rcu_head *head) { int i; struct ust_error_accounting_entry *entry = - lttng::utils::container_of(head, &ust_error_accounting_entry::rcu_head); + lttng::utils::container_of(head, &ust_error_accounting_entry::rcu_head); for (i = 0; i < entry->nr_counter_cpu_fds; i++) { lttng_ust_ctl_release_object(-1, entry->cpu_counters[i]); @@ -145,17 +144,15 @@ static void free_ust_error_accounting_entry(struct rcu_head *head) free(entry); } -static -bool ust_error_accounting_entry_get(struct ust_error_accounting_entry *entry) +static bool ust_error_accounting_entry_get(struct ust_error_accounting_entry *entry) { return urcu_ref_get_unless_zero(&entry->ref); } -static -void ust_error_accounting_entry_release(struct urcu_ref *entry_ref) +static void ust_error_accounting_entry_release(struct urcu_ref *entry_ref) { struct ust_error_accounting_entry *entry = - lttng::utils::container_of(entry_ref, &ust_error_accounting_entry::ref); + lttng::utils::container_of(entry_ref, &ust_error_accounting_entry::ref); rcu_read_lock(); cds_lfht_del(error_counter_uid_ht->ht, &entry->node.node); @@ -163,9 +160,7 @@ void ust_error_accounting_entry_release(struct urcu_ref *entry_ref) rcu_read_unlock(); } - -static -void ust_error_accounting_entry_put(struct ust_error_accounting_entry *entry) +static void ust_error_accounting_entry_put(struct ust_error_accounting_entry *entry) { if (!entry) { return; @@ -177,8 +172,7 @@ void ust_error_accounting_entry_put(struct ust_error_accounting_entry *entry) /* * Put one reference to every UID entries. */ -static -void put_ref_all_ust_error_accounting_entry(void) +static void put_ref_all_ust_error_accounting_entry(void) { struct lttng_ht_iter iter; struct ust_error_accounting_entry *uid_entry; @@ -186,9 +180,8 @@ void put_ref_all_ust_error_accounting_entry(void) ASSERT_LOCKED(the_event_notifier_counter.lock); rcu_read_lock(); - cds_lfht_for_each_entry(error_counter_uid_ht->ht, &iter.iter, - uid_entry, node.node) { - ust_error_accounting_entry_put(uid_entry); + cds_lfht_for_each_entry (error_counter_uid_ht->ht, &iter.iter, uid_entry, node.node) { + ust_error_accounting_entry_put(uid_entry); } rcu_read_unlock(); @@ -197,8 +190,7 @@ void put_ref_all_ust_error_accounting_entry(void) /* * Get one reference to every UID entries. */ -static -void get_ref_all_ust_error_accounting_entry(void) +static void get_ref_all_ust_error_accounting_entry(void) { struct lttng_ht_iter iter; struct ust_error_accounting_entry *uid_entry; @@ -206,9 +198,8 @@ void get_ref_all_ust_error_accounting_entry(void) ASSERT_LOCKED(the_event_notifier_counter.lock); rcu_read_lock(); - cds_lfht_for_each_entry(error_counter_uid_ht->ht, &iter.iter, - uid_entry, node.node) { - ust_error_accounting_entry_get(uid_entry); + cds_lfht_for_each_entry (error_counter_uid_ht->ht, &iter.iter, uid_entry, node.node) { + ust_error_accounting_entry_get(uid_entry); } rcu_read_unlock(); @@ -216,10 +207,8 @@ void get_ref_all_ust_error_accounting_entry(void) #endif /* HAVE_LIBLTTNG_UST_CTL */ -static -enum event_notifier_error_accounting_status -init_error_accounting_state(struct error_accounting_state *state, - uint64_t index_count) +static enum event_notifier_error_accounting_status +init_error_accounting_state(struct error_accounting_state *state, uint64_t index_count) { enum event_notifier_error_accounting_status status; @@ -234,8 +223,7 @@ init_error_accounting_state(struct error_accounting_state *state, goto end; } - state->indices_ht = lttng_ht_new(ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, - LTTNG_HT_TYPE_U64); + state->indices_ht = lttng_ht_new(ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, LTTNG_HT_TYPE_U64); if (!state->indices_ht) { ERR("Failed to allocate error counter indices hash table"); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM; @@ -252,8 +240,7 @@ end: return status; } -static -void fini_error_accounting_state(struct error_accounting_state *state) +static void fini_error_accounting_state(struct error_accounting_state *state) { LTTNG_ASSERT(state); @@ -266,27 +253,25 @@ void fini_error_accounting_state(struct error_accounting_state *state) } enum event_notifier_error_accounting_status -event_notifier_error_accounting_init(uint64_t buffer_size_kernel, - uint64_t buffer_size_ust) +event_notifier_error_accounting_init(uint64_t buffer_size_kernel, uint64_t buffer_size_ust) { enum event_notifier_error_accounting_status status; status = init_error_accounting_state(&kernel_state, buffer_size_kernel); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { ERR("Failed to initialize kernel event notifier accounting state: status = %s", - error_accounting_status_str(status)); + error_accounting_status_str(status)); goto end; } status = init_error_accounting_state(&ust_state, buffer_size_ust); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { ERR("Failed to initialize UST event notifier accounting state: status = %s", - error_accounting_status_str(status)); + error_accounting_status_str(status)); goto error_ust_state; } - error_counter_uid_ht = lttng_ht_new( - ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, LTTNG_HT_TYPE_U64); + error_counter_uid_ht = lttng_ht_new(ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, LTTNG_HT_TYPE_U64); if (!error_counter_uid_ht) { ERR("Failed to allocate UID to error counter accountant hash table"); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM; @@ -308,10 +293,8 @@ end: * Return the error counteur index associated to this event notifier tracer * token. Returns _STATUS_OK if found and _STATUS_NOT_FOUND otherwise. */ -static -enum event_notifier_error_accounting_status get_error_counter_index_for_token( - struct error_accounting_state *state, uint64_t tracer_token, - uint64_t *error_counter_index) +static enum event_notifier_error_accounting_status get_error_counter_index_for_token( + struct error_accounting_state *state, uint64_t tracer_token, uint64_t *error_counter_index) { struct lttng_ht_node_u64 *node; struct lttng_ht_iter iter; @@ -338,9 +321,8 @@ enum event_notifier_error_accounting_status get_error_counter_index_for_token( * Find the entry for this app's UID, the caller acquires a reference if the * entry is found. */ -static -struct ust_error_accounting_entry *ust_error_accounting_entry_find( - struct lttng_ht *uid_ht, const struct ust_app *app) +static struct ust_error_accounting_entry *ust_error_accounting_entry_find(struct lttng_ht *uid_ht, + const struct ust_app *app) { struct ust_error_accounting_entry *entry; struct lttng_ht_node_u64 *node; @@ -349,13 +331,12 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_find( lttng_ht_lookup(uid_ht, &key, &iter); node = lttng_ht_iter_get_node_u64(&iter); - if(node == NULL) { + if (node == NULL) { entry = NULL; } else { bool got_ref; - entry = caa_container_of(node, - struct ust_error_accounting_entry, node); + entry = caa_container_of(node, struct ust_error_accounting_entry, node); got_ref = ust_error_accounting_entry_get(entry); if (!got_ref) { @@ -370,9 +351,8 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_find( * Create the entry for this app's UID, the caller acquires a reference to the * entry, */ -static -struct ust_error_accounting_entry *ust_error_accounting_entry_create( - const struct ust_app *app) +static struct ust_error_accounting_entry * +ust_error_accounting_entry_create(const struct ust_app *app) { int i, ret, *cpu_counter_fds = NULL; struct lttng_ust_ctl_daemon_counter *daemon_counter; @@ -386,7 +366,8 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( if (!ust_app_supports_counters(app)) { DBG("Refusing to create accounting entry for application (unsupported feature): app name = '%s', app ppid = %d", - app->name, (int) app->ppid); + app->name, + (int) app->ppid); goto error; } @@ -403,8 +384,10 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( cpu_counter_fds = calloc(entry->nr_counter_cpu_fds); if (!cpu_counter_fds) { PERROR("Failed to allocate event notifier error counter file descriptors array: application uid = %d, application name = '%s', pid = %d, allocation size = %zu", - (int) app->uid, app->name, (int) app->pid, - entry->nr_counter_cpu_fds * sizeof(*cpu_counter_fds)); + (int) app->uid, + app->name, + (int) app->pid, + entry->nr_counter_cpu_fds * sizeof(*cpu_counter_fds)); goto error_counter_cpu_fds_alloc; } @@ -416,8 +399,10 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( cpu_counters = calloc(entry->nr_counter_cpu_fds); if (!cpu_counters) { PERROR("Failed to allocate event notifier error counter lttng_ust_abi_object_data array: application uid = %d, application name = '%s', pid = %d, allocation size = %zu", - (int) app->uid, app->name, (int) app->pid, - entry->nr_counter_cpu_fds * sizeof(struct lttng_ust_abi_object_data *)); + (int) app->uid, + app->name, + (int) app->pid, + entry->nr_counter_cpu_fds * sizeof(struct lttng_ust_abi_object_data *)); goto error_counter_cpus_alloc; } @@ -425,7 +410,9 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( cpu_counter_fds[i] = shm_create_anonymous("event-notifier-error-accounting"); if (cpu_counter_fds[i] == -1) { ERR("Failed to create event notifier error accounting shared memory for application user: application uid = %d, pid = %d, application name = '%s'", - (int) app->uid, (int) app->pid, app->name); + (int) app->uid, + (int) app->pid, + app->name); goto error_shm_alloc; } } @@ -433,12 +420,16 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( /* * Ownership of the file descriptors transferred to the ustctl object. */ - daemon_counter = lttng_ust_ctl_create_counter(1, &dimension, 0, -1, - entry->nr_counter_cpu_fds, cpu_counter_fds, - LTTNG_UST_CTL_COUNTER_BITNESS_32, - LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR, - LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU, - false); + daemon_counter = lttng_ust_ctl_create_counter(1, + &dimension, + 0, + -1, + entry->nr_counter_cpu_fds, + cpu_counter_fds, + LTTNG_UST_CTL_COUNTER_BITNESS_32, + LTTNG_UST_CTL_COUNTER_ARITHMETIC_MODULAR, + LTTNG_UST_CTL_COUNTER_ALLOC_PER_CPU, + false); if (!daemon_counter) { goto error_create_daemon_counter; } @@ -446,17 +437,19 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create( ret = lttng_ust_ctl_create_counter_data(daemon_counter, &counter); if (ret) { ERR("Failed to create userspace tracer counter data for application user: uid = %d, pid = %d, application name = '%s'", - (int) app->uid, (int) app->pid, app->name); + (int) app->uid, + (int) app->pid, + app->name); goto error_create_counter_data; } for (i = 0; i < entry->nr_counter_cpu_fds; i++) { - ret = lttng_ust_ctl_create_counter_cpu_data(daemon_counter, i, - &cpu_counters[i]); + ret = lttng_ust_ctl_create_counter_cpu_data(daemon_counter, i, &cpu_counters[i]); if (ret) { ERR("Failed to create userspace tracer counter cpu data for application user: uid = %d, pid = %d, application name = '%s'", - (int) app->uid, (int) app->pid, - app->name); + (int) app->uid, + (int) app->pid, + app->name); goto error_create_counter_cpu_data; } } @@ -505,7 +498,7 @@ error_shm_alloc: ret = close(cpu_counter_fds[i]); if (ret) { PERROR("Failed to close error counter per-CPU shm file descriptor: fd = %d", - cpu_counter_fds[i]); + cpu_counter_fds[i]); } } } @@ -521,27 +514,29 @@ end: return entry; } -static -enum event_notifier_error_accounting_status send_counter_data_to_ust( - struct ust_app *app, - struct lttng_ust_abi_object_data *new_counter) +static enum event_notifier_error_accounting_status +send_counter_data_to_ust(struct ust_app *app, struct lttng_ust_abi_object_data *new_counter) { int ret; enum event_notifier_error_accounting_status status; /* Attach counter to trigger group. */ pthread_mutex_lock(&app->sock_lock); - ret = lttng_ust_ctl_send_counter_data_to_ust(app->sock, - app->event_notifier_group.object->handle, new_counter); + ret = lttng_ust_ctl_send_counter_data_to_ust( + app->sock, app->event_notifier_group.object->handle, new_counter); pthread_mutex_unlock(&app->sock_lock); if (ret < 0) { if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) { ERR("Failed to send counter data to application: application name = '%s', pid = %d, ret = %d", - app->name, app->pid, ret); + app->name, + app->pid, + ret); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; } else { DBG3("Failed to send counter data to application (application is dead): application name = '%s', pid = %d, ret = %d", - app->name, app->pid, ret); + app->name, + app->pid, + ret); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_APP_DEAD; } @@ -553,27 +548,29 @@ end: return status; } -static -enum event_notifier_error_accounting_status send_counter_cpu_data_to_ust( - struct ust_app *app, - struct lttng_ust_abi_object_data *counter, - struct lttng_ust_abi_object_data *counter_cpu) +static enum event_notifier_error_accounting_status +send_counter_cpu_data_to_ust(struct ust_app *app, + struct lttng_ust_abi_object_data *counter, + struct lttng_ust_abi_object_data *counter_cpu) { int ret; enum event_notifier_error_accounting_status status; pthread_mutex_lock(&app->sock_lock); - ret = lttng_ust_ctl_send_counter_cpu_data_to_ust(app->sock, - counter, counter_cpu); + ret = lttng_ust_ctl_send_counter_cpu_data_to_ust(app->sock, counter, counter_cpu); pthread_mutex_unlock(&app->sock_lock); if (ret < 0) { if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) { ERR("Failed to send counter CPU data to application: application name = '%s', pid = %d, ret = %d", - app->name, app->pid, ret); + app->name, + app->pid, + ret); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; } else { DBG3("Failed to send counter CPU data to application: application name = '%s', pid = %d, ret = %d", - app->name, app->pid, ret); + app->name, + app->pid, + ret); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_APP_DEAD; } @@ -634,11 +631,12 @@ event_notifier_error_accounting_register_app(struct ust_app *app) } /* Duplicate counter object data. */ - ret = lttng_ust_ctl_duplicate_ust_object_data(&new_counter, - entry->counter); + ret = lttng_ust_ctl_duplicate_ust_object_data(&new_counter, entry->counter); if (ret) { ERR("Failed to duplicate event notifier error accounting counter for application user: application uid = %d, pid = %d, application name = '%s'", - (int) app->uid, (int) app->pid, app->name); + (int) app->uid, + (int) app->pid, + app->name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto error_duplicate_counter; } @@ -650,8 +648,10 @@ event_notifier_error_accounting_register_app(struct ust_app *app) } ERR("Failed to send counter data to application tracer: status = %s, application uid = %d, pid = %d, application name = '%s'", - error_accounting_status_str(status), - (int) app->uid, (int) app->pid, app->name); + error_accounting_status_str(status), + (int) app->uid, + (int) app->pid, + app->name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto error_send_counter_data; } @@ -659,8 +659,10 @@ event_notifier_error_accounting_register_app(struct ust_app *app) cpu_counters = calloc(entry->nr_counter_cpu_fds); if (!cpu_counters) { PERROR("Failed to allocate event notifier error counter lttng_ust_abi_object_data array: application uid = %d, application name = '%s', pid = %d, allocation size = %zu", - (int) app->uid, app->name, (int) app->pid, - entry->nr_counter_cpu_fds * sizeof(**cpu_counters)); + (int) app->uid, + app->name, + (int) app->pid, + entry->nr_counter_cpu_fds * sizeof(**cpu_counters)); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM; goto error_allocate_cpu_counters; } @@ -669,28 +671,29 @@ event_notifier_error_accounting_register_app(struct ust_app *app) struct lttng_ust_abi_object_data *new_counter_cpu = NULL; ret = lttng_ust_ctl_duplicate_ust_object_data(&new_counter_cpu, - entry->cpu_counters[i]); + entry->cpu_counters[i]); if (ret) { ERR("Failed to duplicate userspace tracer counter cpu data for application user: uid = %d, pid = %d, application name = '%s'", - (int) app->uid, (int) app->pid, - app->name); + (int) app->uid, + (int) app->pid, + app->name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM; goto error_duplicate_cpu_counter; } cpu_counters[i] = new_counter_cpu; - status = send_counter_cpu_data_to_ust(app, new_counter, - new_counter_cpu); + status = send_counter_cpu_data_to_ust(app, new_counter, new_counter_cpu); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { if (status == EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_APP_DEAD) { goto error_send_cpu_counter_data; } ERR("Failed to send counter cpu data to application tracer: status = %s, application uid = %d, pid = %d, application name = '%s'", - error_accounting_status_str(status), - (int) app->uid, (int) app->pid, - app->name); + error_accounting_status_str(status), + (int) app->uid, + (int) app->pid, + app->name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto error_send_cpu_counter_data; } @@ -753,7 +756,8 @@ event_notifier_error_accounting_unregister_app(struct ust_app *app) entry = ust_error_accounting_entry_find(error_counter_uid_ht, app); if (entry == NULL) { ERR("Failed to find event notitifier error accounting entry on application teardown: pid = %d, application name = '%s'", - app->pid, app->name); + app->pid, + app->name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto end; } else { @@ -766,8 +770,7 @@ event_notifier_error_accounting_unregister_app(struct ust_app *app) } for (i = 0; i < app->event_notifier_group.nr_counter_cpu; i++) { - lttng_ust_ctl_release_object(app->sock, - app->event_notifier_group.counter_cpu[i]); + lttng_ust_ctl_release_object(app->sock, app->event_notifier_group.counter_cpu[i]); free(app->event_notifier_group.counter_cpu[i]); } @@ -782,10 +785,8 @@ end: return status; } -static -enum event_notifier_error_accounting_status -event_notifier_error_accounting_ust_get_count( - const struct lttng_trigger *trigger, uint64_t *count) +static enum event_notifier_error_accounting_status +event_notifier_error_accounting_ust_get_count(const struct lttng_trigger *trigger, uint64_t *count) { struct lttng_ht_iter iter; struct ust_error_accounting_entry *uid_entry; @@ -796,19 +797,18 @@ event_notifier_error_accounting_ust_get_count( uid_t trigger_owner_uid; const char *trigger_name; - rcu_read_lock(); get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); - status = get_error_counter_index_for_token(&ust_state, tracer_token, - &error_counter_index); + status = get_error_counter_index_for_token(&ust_state, tracer_token, &error_counter_index); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { - - ERR("Failed to retrieve index for tracer token: token = %" PRIu64 ", trigger name = '%s', trigger owner uid = %d, status = %s", - tracer_token, trigger_name, - (int) trigger_owner_uid, - error_accounting_status_str(status)); + ERR("Failed to retrieve index for tracer token: token = %" PRIu64 + ", trigger name = '%s', trigger owner uid = %d, status = %s", + tracer_token, + trigger_name, + (int) trigger_owner_uid, + error_accounting_status_str(status)); goto end; } @@ -821,25 +821,26 @@ event_notifier_error_accounting_ust_get_count( * a trigger to a given sessiond is also allowed to create an event * notifier on all apps that this sessiond is aware of. */ - cds_lfht_for_each_entry(error_counter_uid_ht->ht, &iter.iter, - uid_entry, node.node) { + cds_lfht_for_each_entry (error_counter_uid_ht->ht, &iter.iter, uid_entry, node.node) { int ret; int64_t local_value = 0; bool overflow = false, underflow = false; ret = lttng_ust_ctl_counter_aggregate(uid_entry->daemon_counter, - dimension_indexes, &local_value, &overflow, - &underflow); + dimension_indexes, + &local_value, + &overflow, + &underflow); if (ret || local_value < 0) { if (ret) { ERR("Failed to aggregate event notifier error counter values of trigger: trigger name = '%s', trigger owner uid = %d", - trigger_name, - (int) trigger_owner_uid); + trigger_name, + (int) trigger_owner_uid); } else if (local_value < 0) { ERR("Negative event notifier error counter value encountered during aggregation: trigger name = '%s', trigger owner uid = %d, value = %" PRId64, - trigger_name, - (int) trigger_owner_uid, - local_value); + trigger_name, + (int) trigger_owner_uid, + local_value); } else { abort(); } @@ -860,9 +861,8 @@ end: return status; } -static -enum event_notifier_error_accounting_status event_notifier_error_accounting_ust_clear( - const struct lttng_trigger *trigger) +static enum event_notifier_error_accounting_status +event_notifier_error_accounting_ust_clear(const struct lttng_trigger *trigger) { struct lttng_ht_iter iter; struct ust_error_accounting_entry *uid_entry; @@ -872,19 +872,19 @@ enum event_notifier_error_accounting_status event_notifier_error_accounting_ust_ const uint64_t tracer_token = lttng_trigger_get_tracer_token(trigger); rcu_read_lock(); - status = get_error_counter_index_for_token(&ust_state, tracer_token, - &error_counter_index); + status = get_error_counter_index_for_token(&ust_state, tracer_token, &error_counter_index); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log(trigger, &trigger_name, - &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); - ERR("Failed to retrieve index for tracer token: token = %" PRIu64 ", trigger name = '%s', trigger owner uid = %d, status = %s", - tracer_token, trigger_name, - (int) trigger_owner_uid, - error_accounting_status_str(status)); + ERR("Failed to retrieve index for tracer token: token = %" PRIu64 + ", trigger name = '%s', trigger owner uid = %d, status = %s", + tracer_token, + trigger_name, + (int) trigger_owner_uid, + error_accounting_status_str(status)); goto end; } @@ -895,20 +895,19 @@ enum event_notifier_error_accounting_status event_notifier_error_accounting_ust_ * errors) can be generated from any applications that this session * daemon is managing. */ - cds_lfht_for_each_entry(error_counter_uid_ht->ht, &iter.iter, - uid_entry, node.node) { - const int ret = lttng_ust_ctl_counter_clear(uid_entry->daemon_counter, - &dimension_index); + cds_lfht_for_each_entry (error_counter_uid_ht->ht, &iter.iter, uid_entry, node.node) { + const int ret = + lttng_ust_ctl_counter_clear(uid_entry->daemon_counter, &dimension_index); if (ret) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log(trigger, &trigger_name, - &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); ERR("Failed to clear event notifier counter value for trigger: counter uid = %d, trigger name = '%s', trigger owner uid = %d", - (int) uid_entry->node.key, trigger_name, - (int) trigger_owner_uid); + (int) uid_entry->node.key, + trigger_name, + (int) trigger_owner_uid); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto end; } @@ -921,47 +920,42 @@ end: } #endif /* HAVE_LIBLTTNG_UST_CTL */ -static -enum event_notifier_error_accounting_status -event_notifier_error_accounting_kernel_clear( - const struct lttng_trigger *trigger) +static enum event_notifier_error_accounting_status +event_notifier_error_accounting_kernel_clear(const struct lttng_trigger *trigger) { int ret; uint64_t error_counter_index; enum event_notifier_error_accounting_status status; struct lttng_kernel_abi_counter_clear counter_clear = {}; - status = get_error_counter_index_for_token(&kernel_state, - lttng_trigger_get_tracer_token(trigger), - &error_counter_index); + status = get_error_counter_index_for_token( + &kernel_state, lttng_trigger_get_tracer_token(trigger), &error_counter_index); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log( - trigger, &trigger_name, &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); ERR("Failed to get event notifier error counter index: trigger owner uid = %d, trigger name = '%s', status = '%s'", - trigger_owner_uid, trigger_name, - error_accounting_status_str(status)); + trigger_owner_uid, + trigger_name, + error_accounting_status_str(status)); goto end; } counter_clear.index.number_dimensions = 1; counter_clear.index.dimension_indexes[0] = error_counter_index; - ret = kernctl_counter_clear( - kernel_error_accounting_entry.error_counter_fd, - &counter_clear); + ret = kernctl_counter_clear(kernel_error_accounting_entry.error_counter_fd, &counter_clear); if (ret) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log( - trigger, &trigger_name, &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); ERR("Failed to clear kernel event notifier error counter: trigger owner uid = %d, trigger name = '%s'", - trigger_owner_uid, trigger_name); + trigger_owner_uid, + trigger_name); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto end; } @@ -972,16 +966,15 @@ end: } enum event_notifier_error_accounting_status -event_notifier_error_accounting_register_kernel( - int kernel_event_notifier_group_fd) +event_notifier_error_accounting_register_kernel(int kernel_event_notifier_group_fd) { int error_counter_fd = -1, ret; enum event_notifier_error_accounting_status status; lttng_kernel_abi_counter_conf error_counter_conf = { .arithmetic = LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR, .bitness = sizeof(void *) == sizeof(uint32_t) ? - LTTNG_KERNEL_ABI_COUNTER_BITNESS_32 : - LTTNG_KERNEL_ABI_COUNTER_BITNESS_64, + LTTNG_KERNEL_ABI_COUNTER_BITNESS_32 : + LTTNG_KERNEL_ABI_COUNTER_BITNESS_64, .number_dimensions = 1, .global_sum_step = 0, .dimensions = {}, @@ -992,11 +985,11 @@ event_notifier_error_accounting_register_kernel( error_counter_conf.dimensions[0].has_underflow = false; error_counter_conf.dimensions[0].has_overflow = false; - ret = kernctl_create_event_notifier_group_error_counter( - kernel_event_notifier_group_fd, &error_counter_conf); + ret = kernctl_create_event_notifier_group_error_counter(kernel_event_notifier_group_fd, + &error_counter_conf); if (ret < 0) { PERROR("Failed to create event notifier group error counter through kernel ioctl: kernel_event_notifier_group_fd = %d", - kernel_event_notifier_group_fd); + kernel_event_notifier_group_fd); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto error; } @@ -1007,26 +1000,22 @@ event_notifier_error_accounting_register_kernel( ret = fcntl(error_counter_fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { PERROR("Failed to set FD_CLOEXEC flag on event notifier error counter file descriptor: error_counter_fd = %d", - error_counter_fd); + error_counter_fd); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; goto error; } - DBG("Created kernel event notifier group error counter: fd = %d", - error_counter_fd); + DBG("Created kernel event notifier group error counter: fd = %d", error_counter_fd); - kernel_error_accounting_entry.error_counter_fd = - error_counter_fd; + kernel_error_accounting_entry.error_counter_fd = error_counter_fd; status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK; error: return status; } -static -enum event_notifier_error_accounting_status create_error_counter_index_for_token( - struct error_accounting_state *state, uint64_t tracer_token, - uint64_t *error_counter_index) +static enum event_notifier_error_accounting_status create_error_counter_index_for_token( + struct error_accounting_state *state, uint64_t tracer_token, uint64_t *error_counter_index) { struct index_ht_entry *index_entry; enum lttng_index_allocator_status index_alloc_status; @@ -1036,14 +1025,13 @@ enum event_notifier_error_accounting_status create_error_counter_index_for_token LTTNG_ASSERT(state); /* Allocate a new index for that counter. */ - index_alloc_status = lttng_index_allocator_alloc(state->index_allocator, - &local_error_counter_index); + index_alloc_status = + lttng_index_allocator_alloc(state->index_allocator, &local_error_counter_index); switch (index_alloc_status) { case LTTNG_INDEX_ALLOCATOR_STATUS_EMPTY: DBG("No indices left in the configured event notifier error counter: " - "number-of-indices = %" PRIu64, - lttng_index_allocator_get_index_count( - state->index_allocator)); + "number-of-indices = %" PRIu64, + lttng_index_allocator_get_index_count(state->index_allocator)); status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE; goto end; case LTTNG_INDEX_ALLOCATOR_STATUS_OK: @@ -1064,8 +1052,10 @@ enum event_notifier_error_accounting_status create_error_counter_index_for_token lttng_ht_node_init_u64(&index_entry->node, tracer_token); lttng_ht_add_unique_u64(state->indices_ht, &index_entry->node); - DBG("Allocated error counter index for tracer token: tracer token = %" PRIu64 ", index = %" PRIu64, - tracer_token, local_error_counter_index); + DBG("Allocated error counter index for tracer token: tracer token = %" PRIu64 + ", index = %" PRIu64, + tracer_token, + local_error_counter_index); *error_counter_index = local_error_counter_index; status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK; end: @@ -1073,9 +1063,8 @@ end: } enum event_notifier_error_accounting_status -event_notifier_error_accounting_register_event_notifier( - const struct lttng_trigger *trigger, - uint64_t *error_counter_index) +event_notifier_error_accounting_register_event_notifier(const struct lttng_trigger *trigger, + uint64_t *error_counter_index) { enum event_notifier_error_accounting_status status; uint64_t local_error_counter_index; @@ -1099,29 +1088,28 @@ event_notifier_error_accounting_register_event_notifier( * Check if this event notifier already has a error counter index * assigned. */ - status = get_error_counter_index_for_token(state, - lttng_trigger_get_tracer_token(trigger), - &local_error_counter_index); + status = get_error_counter_index_for_token( + state, lttng_trigger_get_tracer_token(trigger), &local_error_counter_index); switch (status) { case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND: { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log( - trigger, &trigger_name, &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); DBG("Event notifier error counter index not found for tracer token (allocating a new one): trigger name = '%s', trigger owner uid = %d, tracer token = %" PRIu64, - trigger_name, trigger_owner_uid, - lttng_trigger_get_tracer_token(trigger)); + trigger_name, + trigger_owner_uid, + lttng_trigger_get_tracer_token(trigger)); - status = create_error_counter_index_for_token(state, - lttng_trigger_get_tracer_token(trigger), - &local_error_counter_index); + status = create_error_counter_index_for_token( + state, lttng_trigger_get_tracer_token(trigger), &local_error_counter_index); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { ERR("Error creating index for token: status = %s, trigger name = '%s', trigger owner uid = %d", - error_accounting_status_str(status), - trigger_name, trigger_owner_uid); + error_accounting_status_str(status), + trigger_name, + trigger_owner_uid); goto end; } } @@ -1158,27 +1146,24 @@ event_notifier_error_accounting_register_event_notifier( } #endif /* HAVE_LIBLTTNG_UST_CTL */ - end: return status; } -static -enum event_notifier_error_accounting_status -event_notifier_error_accounting_kernel_get_count( - const struct lttng_trigger *trigger, uint64_t *count) +static enum event_notifier_error_accounting_status +event_notifier_error_accounting_kernel_get_count(const struct lttng_trigger *trigger, + uint64_t *count) { struct lttng_kernel_abi_counter_aggregate counter_aggregate = {}; enum event_notifier_error_accounting_status status; uint64_t error_counter_index; int ret; - status = get_error_counter_index_for_token(&kernel_state, - lttng_trigger_get_tracer_token(trigger), - &error_counter_index); + status = get_error_counter_index_for_token( + &kernel_state, lttng_trigger_get_tracer_token(trigger), &error_counter_index); if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { ERR("Error getting index for token: status=%s", - error_accounting_status_str(status)); + error_accounting_status_str(status)); goto end; } @@ -1187,23 +1172,24 @@ event_notifier_error_accounting_kernel_get_count( LTTNG_ASSERT(kernel_error_accounting_entry.error_counter_fd); - ret = kernctl_counter_get_aggregate_value( - kernel_error_accounting_entry.error_counter_fd, - &counter_aggregate); + ret = kernctl_counter_get_aggregate_value(kernel_error_accounting_entry.error_counter_fd, + &counter_aggregate); if (ret || counter_aggregate.value.value < 0) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log(trigger, &trigger_name, - &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); if (counter_aggregate.value.value < 0) { ERR("Invalid negative event notifier error counter value: trigger owner = %d, trigger name = '%s', value = %" PRId64, - trigger_owner_uid, trigger_name, - counter_aggregate.value.value); + trigger_owner_uid, + trigger_name, + counter_aggregate.value.value); } else { ERR("Failed to getting event notifier error count: trigger owner = %d, trigger name = '%s', ret = %d", - trigger_owner_uid, trigger_name, ret); + trigger_owner_uid, + trigger_name, + ret); } status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR; @@ -1221,20 +1207,17 @@ end: } enum event_notifier_error_accounting_status -event_notifier_error_accounting_get_count( - const struct lttng_trigger *trigger, uint64_t *count) +event_notifier_error_accounting_get_count(const struct lttng_trigger *trigger, uint64_t *count) { switch (lttng_trigger_get_underlying_domain_type_restriction(trigger)) { case LTTNG_DOMAIN_KERNEL: - return event_notifier_error_accounting_kernel_get_count( - trigger, count); + return event_notifier_error_accounting_kernel_get_count(trigger, count); case LTTNG_DOMAIN_UST: case LTTNG_DOMAIN_PYTHON: case LTTNG_DOMAIN_JUL: case LTTNG_DOMAIN_LOG4J: #ifdef HAVE_LIBLTTNG_UST_CTL - return event_notifier_error_accounting_ust_get_count(trigger, - count); + return event_notifier_error_accounting_ust_get_count(trigger, count); #else *count = 0; return EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK; @@ -1244,8 +1227,7 @@ event_notifier_error_accounting_get_count( } } -static -enum event_notifier_error_accounting_status +static enum event_notifier_error_accounting_status event_notifier_error_accounting_clear(const struct lttng_trigger *trigger) { switch (lttng_trigger_get_underlying_domain_type_restriction(trigger)) { @@ -1267,14 +1249,12 @@ event_notifier_error_accounting_clear(const struct lttng_trigger *trigger) static void free_index_ht_entry(struct rcu_head *head) { - struct index_ht_entry *entry = caa_container_of(head, - struct index_ht_entry, rcu_head); + struct index_ht_entry *entry = caa_container_of(head, struct index_ht_entry, rcu_head); free(entry); } -void event_notifier_error_accounting_unregister_event_notifier( - const struct lttng_trigger *trigger) +void event_notifier_error_accounting_unregister_event_notifier(const struct lttng_trigger *trigger) { struct lttng_ht_iter iter; struct lttng_ht_node_u64 *node; @@ -1286,7 +1266,7 @@ void event_notifier_error_accounting_unregister_event_notifier( if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) { /* Trigger details already logged by callee on error. */ ERR("Failed to clear event notifier error counter during unregistration of event notifier: status = '%s'", - error_accounting_status_str(status)); + error_accounting_status_str(status)); goto end; } @@ -1306,7 +1286,6 @@ void event_notifier_error_accounting_unregister_event_notifier( pthread_mutex_lock(&the_event_notifier_counter.lock); the_event_notifier_counter.count--; if (the_event_notifier_counter.count == 0) { - /* * When unregistering the last event notifier, put one * reference to every uid entries on the behalf of all @@ -1328,22 +1307,22 @@ void event_notifier_error_accounting_unregister_event_notifier( if (node) { int del_ret; struct index_ht_entry *index_entry = - lttng::utils::container_of(node, &index_ht_entry::node); + lttng::utils::container_of(node, &index_ht_entry::node); enum lttng_index_allocator_status index_alloc_status; index_alloc_status = lttng_index_allocator_release( - state->index_allocator, - index_entry->error_counter_index); + state->index_allocator, index_entry->error_counter_index); if (index_alloc_status != LTTNG_INDEX_ALLOCATOR_STATUS_OK) { uid_t trigger_owner_uid; const char *trigger_name; - get_trigger_info_for_log(trigger, &trigger_name, - &trigger_owner_uid); + get_trigger_info_for_log(trigger, &trigger_name, &trigger_owner_uid); - ERR("Failed to release event notifier error counter index: index = %" PRIu64 ", trigger name = '%s', trigger owner uid = %d", - index_entry->error_counter_index, - trigger_name, (int) trigger_owner_uid); + ERR("Failed to release event notifier error counter index: index = %" PRIu64 + ", trigger name = '%s', trigger owner uid = %d", + index_entry->error_counter_index, + trigger_name, + (int) trigger_owner_uid); /* Don't exit, perform the rest of the clean-up. */ }