[lttng-tools.git] / src / bin / lttng-sessiond / event-notifier-error-accounting.c

/*
 * Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <urcu/compiler.h>

#include <common/error.h>
#include <common/hashtable/hashtable.h>
#include <common/index-allocator.h>
#include <common/kernel-ctl/kernel-ctl.h>
#include <lttng/trigger/trigger-internal.h>

#include "event-notifier-error-accounting.h"

#define ERROR_COUNTER_INDEX_HT_INITIAL_SIZE 16

struct index_ht_entry {
	struct lttng_ht_node_u64 node;
	uint64_t error_counter_index;
	struct rcu_head rcu_head;
};

struct kernel_error_account_entry {
	int kernel_event_notifier_error_counter_fd;
};

static struct kernel_error_account_entry kernel_error_accountant;

/* Hashtable mapping event notifier token to index_ht_entry. */
static struct lttng_ht *error_counter_indexes_ht;

static uint64_t error_counter_size;
static struct lttng_index_allocator *index_allocator;

static inline
const char *error_accounting_status_str(
		enum event_notifier_error_accounting_status status)
{
	switch (status) {
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
		return "OK";
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR:
		return "ERROR";
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND:
		return "NOT_FOUND";
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM:
		return "NOMEM";
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE:
		return "NO_INDEX_AVAILABLE";
	default:
		abort();
	}
}

enum event_notifier_error_accounting_status
event_notifier_error_accounting_init(uint64_t nb_bucket)
{
	enum event_notifier_error_accounting_status status;

	index_allocator = lttng_index_allocator_create(nb_bucket);
	if (!index_allocator) {
		ERR("Failed to allocate event notifier error counter index");
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
		goto error_index_allocator;
	}

	error_counter_indexes_ht = lttng_ht_new(
			ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, LTTNG_HT_TYPE_U64);
	if (!error_counter_indexes_ht) {
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
		goto error_index_allocator;
	}

	error_counter_size = nb_bucket;

	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;

error_index_allocator:
	return status;
}

static
enum event_notifier_error_accounting_status get_error_counter_index_for_token(
		uint64_t tracer_token, uint64_t *error_counter_index)
{
	struct lttng_ht_node_u64 *node;
	struct lttng_ht_iter iter;
	const struct index_ht_entry *index_entry;
	enum event_notifier_error_accounting_status status;

	rcu_read_lock();
	lttng_ht_lookup(error_counter_indexes_ht, &tracer_token, &iter);
	node = lttng_ht_iter_get_node_u64(&iter);
	if (node) {
		index_entry = caa_container_of(
				node, const struct index_ht_entry, node);
		*error_counter_index = index_entry->error_counter_index;
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
	} else {
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND;
	}

	rcu_read_unlock();
	return status;
}

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_counter_clear counter_clear = {};

	status = get_error_counter_index_for_token(
			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;
		const enum lttng_trigger_status trigger_status =
				lttng_trigger_get_owner_uid(
						trigger, &trigger_owner_uid);

		assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
		if (lttng_trigger_get_name(trigger, &trigger_name) !=
				LTTNG_TRIGGER_STATUS_OK) {
			trigger_name = "(unnamed)";
		}

		ERR("Failed to get event notifier error counter index: trigger owner uid = %d, trigger name = '%s'",
				trigger_owner_uid, trigger_name);
		goto end;
	}

	counter_clear.index.number_dimensions = 1;
	counter_clear.index.dimension_indexes[0] = error_counter_index;

	ret = kernctl_counter_clear(
			kernel_error_accountant.kernel_event_notifier_error_counter_fd,
			&counter_clear);
	if (ret) {
		ERR("Failed to clear event notifier error counter");
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
		goto end;
	}

	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
end:
	return status;
}

enum event_notifier_error_accounting_status
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;
	const struct lttng_kernel_counter_conf error_counter_conf = {
		.arithmetic = LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR,
		.bitness = sizeof(void *) == sizeof(uint32_t) ?
				LTTNG_KERNEL_COUNTER_BITNESS_32 :
				LTTNG_KERNEL_COUNTER_BITNESS_64,
		.global_sum_step = 0,
		.number_dimensions = 1,
		.dimensions[0].size = error_counter_size,
		.dimensions[0].has_underflow = false,
		.dimensions[0].has_overflow = false,
	};

	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);
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
		goto error;
	}

	error_counter_fd = ret;

	/* Prevent fd duplication after execlp(). */
	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);
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
		goto error;
	}

	DBG("Created kernel event notifier group error counter: fd = %d",
			error_counter_fd);

	kernel_error_accountant.kernel_event_notifier_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(
		uint64_t tracer_token, uint64_t *error_counter_index)
{
	struct index_ht_entry *index_entry;
	enum lttng_index_allocator_status index_alloc_status;
	uint64_t local_error_counter_index;
	enum event_notifier_error_accounting_status status;

	/* Allocate a new index for that counter. */
	index_alloc_status = lttng_index_allocator_alloc(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(
					index_allocator));
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE;
		goto end;
	case LTTNG_INDEX_ALLOCATOR_STATUS_OK:
		break;
	default:
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
		goto end;
	}

	index_entry = zmalloc(sizeof(*index_entry));
	if (index_entry == NULL) {
		PERROR("Failed to allocate event notifier error counter hash table entry");
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
		goto end;
	}

	index_entry->error_counter_index = local_error_counter_index;
	lttng_ht_node_init_u64(&index_entry->node, tracer_token);
	lttng_ht_add_unique_u64(error_counter_indexes_ht, &index_entry->node);

	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:
	return status;
}

enum event_notifier_error_accounting_status
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;

	/*
	 * Check if this event notifier already has a error counter index
	 * assigned.
	 */
	status = get_error_counter_index_for_token(
			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;
		const enum lttng_trigger_status trigger_status =
				lttng_trigger_get_owner_uid(
						trigger, &trigger_owner_uid);

		assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
		if (lttng_trigger_get_name(trigger, &trigger_name) !=
				LTTNG_TRIGGER_STATUS_OK) {
			trigger_name = "(unnamed)";
		}

		DBG("Event notifier error counter index not found for tracer token (allocating a new one): trigger owner = %d, trigger name = '%s', tracer token = %" PRIu64,
				trigger_owner_uid, trigger_name,
				lttng_trigger_get_tracer_token(trigger));
		status = create_error_counter_index_for_token(
				lttng_trigger_get_tracer_token(trigger),
				&local_error_counter_index);
		if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
			goto end;
		}
		/* fall-through. */
	}
	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
		*error_counter_index = local_error_counter_index;
		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
		break;
	default:
		break;
	}

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)
{
	struct lttng_kernel_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(
			lttng_trigger_get_tracer_token(trigger), &error_counter_index);
	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
		goto end;
	}

	counter_aggregate.index.number_dimensions = 1;
	counter_aggregate.index.dimension_indexes[0] = error_counter_index;

	assert(kernel_error_accountant.kernel_event_notifier_error_counter_fd);

	ret = kernctl_counter_get_aggregate_value(
			kernel_error_accountant.kernel_event_notifier_error_counter_fd,
			&counter_aggregate);
	if (ret || counter_aggregate.value.value < 0) {
		uid_t trigger_owner_uid;
		const char *trigger_name;
		const enum lttng_trigger_status trigger_status =
				lttng_trigger_get_owner_uid(
						trigger, &trigger_owner_uid);

		assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
		if (lttng_trigger_get_name(trigger, &trigger_name) !=
				LTTNG_TRIGGER_STATUS_OK) {
			trigger_name = "(unnamed)";
		}

		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);
		} else {
			ERR("Failed to getting event notifier error count: trigger owner = %d, trigger name = '%s', ret = %d",
					trigger_owner_uid, trigger_name, ret);
		}

		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
		goto end;
	}

	/* Error count can't be negative. */
	assert(counter_aggregate.value.value >= 0);
	*count = (uint64_t) counter_aggregate.value.value;

	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;

end:
	return status;
}

enum event_notifier_error_accounting_status
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);
	case LTTNG_DOMAIN_UST:
		return EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
	default:
		abort();
	}
}

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)) {
	case LTTNG_DOMAIN_KERNEL:
		return event_notifier_error_accounting_kernel_clear(trigger);
	case LTTNG_DOMAIN_UST:
		return EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
	default:
		abort();
	}
}

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);

	free(entry);
}

void event_notifier_error_accounting_unregister_event_notifier(
		const struct lttng_trigger *trigger)
{
	struct lttng_ht_iter iter;
	struct lttng_ht_node_u64 *node;
	struct index_ht_entry *index_entry;
	enum event_notifier_error_accounting_status status;
	enum lttng_index_allocator_status index_alloc_status;
	uint64_t tracer_token = lttng_trigger_get_tracer_token(trigger);

	status = event_notifier_error_accounting_clear(trigger);
	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
		ERR("Failed to clear event notifier error counter index");
	}

	rcu_read_lock();
	lttng_ht_lookup(error_counter_indexes_ht, &tracer_token, &iter);
	node = lttng_ht_iter_get_node_u64(&iter);
	if(node) {
		index_entry = caa_container_of(node, struct index_ht_entry, node);
		index_alloc_status = lttng_index_allocator_release(
				index_allocator,
				index_entry->error_counter_index);
		if (index_alloc_status != LTTNG_INDEX_ALLOCATOR_STATUS_OK) {
			ERR("Failed to release event notifier error counter index: index = %" PRIu64,
					index_entry->error_counter_index);
		}

		lttng_ht_del(error_counter_indexes_ht, &iter);
		call_rcu(&index_entry->rcu_head, free_index_ht_entry);
	}

	rcu_read_unlock();
}

void event_notifier_error_accounting_fini(void)
{
	lttng_index_allocator_destroy(index_allocator);

	if (kernel_error_accountant.kernel_event_notifier_error_counter_fd) {
		const int ret = close(kernel_error_accountant.kernel_event_notifier_error_counter_fd);

		if (ret) {
			PERROR("Failed to close kernel event notifier error counter");
		}
	}

	/*
	 * Will assert if some error counters were not released (an internal
	 * error).
	 */
	lttng_ht_destroy(error_counter_indexes_ht);
}
Commit	Line	Data
90aa04a1 FD	1	/*
	2	* Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0-only
	5	*
	6	*/
	7
	8	#include <fcntl.h>
	9	#include <sys/mman.h>
	10	#include <sys/stat.h>
	11	#include <unistd.h>
	12	#include <urcu/compiler.h>
	13
	14	#include <common/error.h>
	15	#include <common/hashtable/hashtable.h>
	16	#include <common/index-allocator.h>
	17	#include <common/kernel-ctl/kernel-ctl.h>
	18	#include <lttng/trigger/trigger-internal.h>
	19
	20	#include "event-notifier-error-accounting.h"
	21
	22	#define ERROR_COUNTER_INDEX_HT_INITIAL_SIZE 16
	23
	24	struct index_ht_entry {
	25	struct lttng_ht_node_u64 node;
	26	uint64_t error_counter_index;
	27	struct rcu_head rcu_head;
	28	};
	29
	30	struct kernel_error_account_entry {
	31	int kernel_event_notifier_error_counter_fd;
	32	};
	33
	34	static struct kernel_error_account_entry kernel_error_accountant;
	35
	36	/* Hashtable mapping event notifier token to index_ht_entry. */
	37	static struct lttng_ht *error_counter_indexes_ht;
	38
	39	static uint64_t error_counter_size;
	40	static struct lttng_index_allocator *index_allocator;
	41
	42	static inline
	43	const char *error_accounting_status_str(
	44	enum event_notifier_error_accounting_status status)
	45	{
	46	switch (status) {
	47	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
	48	return "OK";
	49	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR:
	50	return "ERROR";
	51	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND:
	52	return "NOT_FOUND";
	53	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM:
	54	return "NOMEM";
	55	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE:
	56	return "NO_INDEX_AVAILABLE";
	57	default:
	58	abort();
	59	}
	60	}
	61
	62	enum event_notifier_error_accounting_status
	63	event_notifier_error_accounting_init(uint64_t nb_bucket)
	64	{
65	enum event_notifier_error_accounting_status status;
66
67	index_allocator = lttng_index_allocator_create(nb_bucket);
68	if (!index_allocator) {
69	ERR("Failed to allocate event notifier error counter index");
70	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
71	goto error_index_allocator;
72	}
73
74	error_counter_indexes_ht = lttng_ht_new(
75	ERROR_COUNTER_INDEX_HT_INITIAL_SIZE, LTTNG_HT_TYPE_U64);
76	if (!error_counter_indexes_ht) {
77	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
78	goto error_index_allocator;
79	}
80
81	error_counter_size = nb_bucket;
82
83	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
84
85	error_index_allocator:
86	return status;
87	}
88
89	static
90	enum event_notifier_error_accounting_status get_error_counter_index_for_token(
91	uint64_t tracer_token, uint64_t *error_counter_index)
92	{
93	struct lttng_ht_node_u64 *node;
94	struct lttng_ht_iter iter;
95	const struct index_ht_entry *index_entry;
96	enum event_notifier_error_accounting_status status;
97
98	rcu_read_lock();
99	lttng_ht_lookup(error_counter_indexes_ht, &tracer_token, &iter);
100	node = lttng_ht_iter_get_node_u64(&iter);
101	if (node) {
102	index_entry = caa_container_of(
103	node, const struct index_ht_entry, node);
104	*error_counter_index = index_entry->error_counter_index;
105	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
106	} else {
107	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND;
108	}
109
110	rcu_read_unlock();
111	return status;
112	}
113
114	static
115	enum event_notifier_error_accounting_status
116	event_notifier_error_accounting_kernel_clear(
117	const struct lttng_trigger *trigger)
118	{
119	int ret;
120	uint64_t error_counter_index;
121	enum event_notifier_error_accounting_status status;
122	struct lttng_kernel_counter_clear counter_clear = {};
123
124	status = get_error_counter_index_for_token(
125	lttng_trigger_get_tracer_token(trigger),
126	&error_counter_index);
127	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
128	uid_t trigger_owner_uid;
129	const char *trigger_name;
130	const enum lttng_trigger_status trigger_status =
131	lttng_trigger_get_owner_uid(
132	trigger, &trigger_owner_uid);
133
134	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
135	if (lttng_trigger_get_name(trigger, &trigger_name) !=
136	LTTNG_TRIGGER_STATUS_OK) {
137	trigger_name = "(unnamed)";
138	}
139
140	ERR("Failed to get event notifier error counter index: trigger owner uid = %d, trigger name = '%s'",
141	trigger_owner_uid, trigger_name);
142	goto end;
143	}
144
145	counter_clear.index.number_dimensions = 1;
146	counter_clear.index.dimension_indexes[0] = error_counter_index;
147
148	ret = kernctl_counter_clear(
149	kernel_error_accountant.kernel_event_notifier_error_counter_fd,
150	&counter_clear);
151	if (ret) {
152	ERR("Failed to clear event notifier error counter");
153	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
154	goto end;
155	}
156
157	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
158	end:
159	return status;
160	}
161
162	enum event_notifier_error_accounting_status
163	event_notifier_error_accounting_register_kernel(
164	int kernel_event_notifier_group_fd)
165	{
166	int error_counter_fd = -1, ret;
167	enum event_notifier_error_accounting_status status;
168	const struct lttng_kernel_counter_conf error_counter_conf = {
169	.arithmetic = LTTNG_KERNEL_COUNTER_ARITHMETIC_MODULAR,
170	.bitness = sizeof(void *) == sizeof(uint32_t) ?
171	LTTNG_KERNEL_COUNTER_BITNESS_32 :
172	LTTNG_KERNEL_COUNTER_BITNESS_64,
173	.global_sum_step = 0,
174	.number_dimensions = 1,
175	.dimensions[0].size = error_counter_size,
176	.dimensions[0].has_underflow = false,
177	.dimensions[0].has_overflow = false,
178	};
179
180	ret = kernctl_create_event_notifier_group_error_counter(
181	kernel_event_notifier_group_fd, &error_counter_conf);
182	if (ret < 0) {
183	PERROR("Failed to create event notifier group error counter through kernel ioctl: kernel_event_notifier_group_fd = %d",
184	kernel_event_notifier_group_fd);
185	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
186	goto error;
187	}
188
189	error_counter_fd = ret;
190
191	/* Prevent fd duplication after execlp(). */
192	ret = fcntl(error_counter_fd, F_SETFD, FD_CLOEXEC);
193	if (ret < 0) {
194	PERROR("Failed to set FD_CLOEXEC flag on event notifier error counter file descriptor: error_counter_fd = %d",
195	error_counter_fd);
196	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
197	goto error;
198	}
199
200	DBG("Created kernel event notifier group error counter: fd = %d",
201	error_counter_fd);
202
203	kernel_error_accountant.kernel_event_notifier_error_counter_fd =
204	error_counter_fd;
205	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
206
207	error:
208	return status;
209	}
210
211	static
212	enum event_notifier_error_accounting_status create_error_counter_index_for_token(
213	uint64_t tracer_token, uint64_t *error_counter_index)
214	{
215	struct index_ht_entry *index_entry;
216	enum lttng_index_allocator_status index_alloc_status;
217	uint64_t local_error_counter_index;
218	enum event_notifier_error_accounting_status status;
219
220	/* Allocate a new index for that counter. */
221	index_alloc_status = lttng_index_allocator_alloc(index_allocator,
222	&local_error_counter_index);
223	switch (index_alloc_status) {
224	case LTTNG_INDEX_ALLOCATOR_STATUS_EMPTY:
225	DBG("No indices left in the configured event notifier error counter: "
226	"number-of-indices = %"PRIu64,
227	lttng_index_allocator_get_index_count(
228	index_allocator));
229	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE;
230	goto end;
231	case LTTNG_INDEX_ALLOCATOR_STATUS_OK:
232	break;
233	default:
234	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
235	goto end;
236	}
237
238	index_entry = zmalloc(sizeof(*index_entry));
239	if (index_entry == NULL) {
240	PERROR("Failed to allocate event notifier error counter hash table entry");
241	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOMEM;
242	goto end;
243	}
244
245	index_entry->error_counter_index = local_error_counter_index;
246	lttng_ht_node_init_u64(&index_entry->node, tracer_token);
247	lttng_ht_add_unique_u64(error_counter_indexes_ht, &index_entry->node);
248
249	DBG("Allocated error counter index for tracer token: tracer token = %" PRIu64 ", index = %" PRIu64,
250	tracer_token, local_error_counter_index);
251	*error_counter_index = local_error_counter_index;
252	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
253	end:
254	return status;
255	}
256
257	enum event_notifier_error_accounting_status
258	event_notifier_error_accounting_register_event_notifier(
259	const struct lttng_trigger *trigger,
260	uint64_t *error_counter_index)
261	{
262	enum event_notifier_error_accounting_status status;
263	uint64_t local_error_counter_index;
264
265	/*
266	* Check if this event notifier already has a error counter index
267	* assigned.
268	*/
269	status = get_error_counter_index_for_token(
270	lttng_trigger_get_tracer_token(trigger),
271	&local_error_counter_index);
272	switch (status) {
273	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NOT_FOUND:
274	{
275	uid_t trigger_owner_uid;
276	const char *trigger_name;
277	const enum lttng_trigger_status trigger_status =
278	lttng_trigger_get_owner_uid(
279	trigger, &trigger_owner_uid);
280
281	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
282	if (lttng_trigger_get_name(trigger, &trigger_name) !=
283	LTTNG_TRIGGER_STATUS_OK) {
284	trigger_name = "(unnamed)";
285	}
286
287	DBG("Event notifier error counter index not found for tracer token (allocating a new one): trigger owner = %d, trigger name = '%s', tracer token = %" PRIu64,
288	trigger_owner_uid, trigger_name,
289	lttng_trigger_get_tracer_token(trigger));
290	status = create_error_counter_index_for_token(
291	lttng_trigger_get_tracer_token(trigger),
292	&local_error_counter_index);
293	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
294	goto end;
295	}
296	/* fall-through. */
297	}
298	case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
299	*error_counter_index = local_error_counter_index;
300	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
301	break;
302	default:
303	break;
304	}
305
306	end:
307	return status;
308	}
309
310	static
311	enum event_notifier_error_accounting_status
312	event_notifier_error_accounting_kernel_get_count(
313	const struct lttng_trigger trigger, uint64_t count)
314	{
315	struct lttng_kernel_counter_aggregate counter_aggregate = {};
316	enum event_notifier_error_accounting_status status;
317	uint64_t error_counter_index;
318	int ret;
319
320	status = get_error_counter_index_for_token(
321	lttng_trigger_get_tracer_token(trigger), &error_counter_index);
322	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
323	goto end;
324	}
325
326	counter_aggregate.index.number_dimensions = 1;
327	counter_aggregate.index.dimension_indexes[0] = error_counter_index;
328
329	assert(kernel_error_accountant.kernel_event_notifier_error_counter_fd);
330
331	ret = kernctl_counter_get_aggregate_value(
332	kernel_error_accountant.kernel_event_notifier_error_counter_fd,
333	&counter_aggregate);
334	if (ret \|\| counter_aggregate.value.value < 0) {
335	uid_t trigger_owner_uid;
336	const char *trigger_name;
337	const enum lttng_trigger_status trigger_status =
338	lttng_trigger_get_owner_uid(
339	trigger, &trigger_owner_uid);
340
341	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
342	if (lttng_trigger_get_name(trigger, &trigger_name) !=
343	LTTNG_TRIGGER_STATUS_OK) {
344	trigger_name = "(unnamed)";
345	}
346
347	if (counter_aggregate.value.value < 0) {
348	ERR("Invalid negative event notifier error counter value: trigger owner = %d, trigger name = '%s', value = %" PRId64,
349	trigger_owner_uid, trigger_name,
350	counter_aggregate.value.value);
351	} else {
352	ERR("Failed to getting event notifier error count: trigger owner = %d, trigger name = '%s', ret = %d",
353	trigger_owner_uid, trigger_name, ret);
354	}
355
356	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_ERR;
357	goto end;
358	}
359
360	/* Error count can't be negative. */
361	assert(counter_aggregate.value.value >= 0);
362	*count = (uint64_t) counter_aggregate.value.value;
363
364	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
365
366	end:
367	return status;
368	}
369
370	enum event_notifier_error_accounting_status
371	event_notifier_error_accounting_get_count(
372	const struct lttng_trigger trigger, uint64_t count)
373	{
374	switch (lttng_trigger_get_underlying_domain_type_restriction(trigger)) {
375	case LTTNG_DOMAIN_KERNEL:
376	return event_notifier_error_accounting_kernel_get_count(
377	trigger, count);
378	case LTTNG_DOMAIN_UST:
379	return EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
380	default:
381	abort();
382	}
383	}
384
385	static
386	enum event_notifier_error_accounting_status
387	event_notifier_error_accounting_clear(const struct lttng_trigger *trigger)
388	{
389	switch (lttng_trigger_get_underlying_domain_type_restriction(trigger)) {
390	case LTTNG_DOMAIN_KERNEL:
391	return event_notifier_error_accounting_kernel_clear(trigger);
392	case LTTNG_DOMAIN_UST:
393	return EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
394	default:
395	abort();
396	}
397	}
398
399	static void free_index_ht_entry(struct rcu_head *head)
400	{
401	struct index_ht_entry *entry = caa_container_of(head,
402	struct index_ht_entry, rcu_head);
403
404	free(entry);
405	}
406
407	void event_notifier_error_accounting_unregister_event_notifier(
408	const struct lttng_trigger *trigger)
409	{
410	struct lttng_ht_iter iter;
411	struct lttng_ht_node_u64 *node;
412	struct index_ht_entry *index_entry;
413	enum event_notifier_error_accounting_status status;
414	enum lttng_index_allocator_status index_alloc_status;
415	uint64_t tracer_token = lttng_trigger_get_tracer_token(trigger);
416
417	status = event_notifier_error_accounting_clear(trigger);
418	if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
419	ERR("Failed to clear event notifier error counter index");
420	}
421
422	rcu_read_lock();
423	lttng_ht_lookup(error_counter_indexes_ht, &tracer_token, &iter);
424	node = lttng_ht_iter_get_node_u64(&iter);
425	if(node) {
426	index_entry = caa_container_of(node, struct index_ht_entry, node);
427	index_alloc_status = lttng_index_allocator_release(
428	index_allocator,
429	index_entry->error_counter_index);
430	if (index_alloc_status != LTTNG_INDEX_ALLOCATOR_STATUS_OK) {
431	ERR("Failed to release event notifier error counter index: index = %" PRIu64,
432	index_entry->error_counter_index);
433	}
434
435	lttng_ht_del(error_counter_indexes_ht, &iter);
436	call_rcu(&index_entry->rcu_head, free_index_ht_entry);
437	}
438
439	rcu_read_unlock();
440	}
441
442	void event_notifier_error_accounting_fini(void)
443	{
444	lttng_index_allocator_destroy(index_allocator);
445
446	if (kernel_error_accountant.kernel_event_notifier_error_counter_fd) {
447	const int ret = close(kernel_error_accountant.kernel_event_notifier_error_counter_fd);
448
449	if (ret) {
450	PERROR("Failed to close kernel event notifier error counter");
451	}
452	}
453
454	/*
455	* Will assert if some error counters were not released (an internal
456	* error).
457	*/
458	lttng_ht_destroy(error_counter_indexes_ht);
459	}