X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fevent-notifier-error-accounting.c;h=1488d801c8f360cef8a341a2c4d5cbaa1156223f;hb=8f0646a03fbf31c19b85ec367dc2c3db56e6dbf7;hp=70fa39e023d4466431614e9499fde0d8797de2c7;hpb=a5a212809b470aafd9c7f4cacbebfb4652feb16b;p=lttng-tools.git

diff --git a/src/bin/lttng-sessiond/event-notifier-error-accounting.c b/src/bin/lttng-sessiond/event-notifier-error-accounting.c
index 70fa39e02..1488d801c 100644
--- a/src/bin/lttng-sessiond/event-notifier-error-accounting.c
+++ b/src/bin/lttng-sessiond/event-notifier-error-accounting.c
@@ -36,13 +36,13 @@ struct ust_error_accounting_entry {
 	struct urcu_ref ref;
 	struct lttng_ht_node_u64 node;
 	struct rcu_head rcu_head;
-	struct ustctl_daemon_counter *daemon_counter;
+	struct lttng_ust_ctl_daemon_counter *daemon_counter;
 	/*
 	 * Those `lttng_ust_abi_object_data` are anonymous handles to the
 	 * counters objects.
 	 * They are only used to be duplicated for each new applications of the
 	 * user. To destroy them, call with the `sock` parameter set to -1.
-	 * e.g. `ustctl_release_object(-1, data)`;
+	 * e.g. `lttng_ust_ctl_release_object(-1, data)`;
 	 */
 	struct lttng_ust_abi_object_data *counter;
 	struct lttng_ust_abi_object_data **cpu_counters;
@@ -87,7 +87,7 @@ static inline void get_trigger_info_for_log(const struct lttng_trigger *trigger,
 
 	trigger_status = lttng_trigger_get_owner_uid(trigger,
 			trigger_owner_uid);
-	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
+	LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 }
 
 static inline
@@ -127,16 +127,16 @@ static void free_ust_error_accounting_entry(struct rcu_head *head)
 			caa_container_of(head, typeof(*entry), rcu_head);
 
 	for (i = 0; i < entry->nr_counter_cpu_fds; i++) {
-		ustctl_release_object(-1, entry->cpu_counters[i]);
+		lttng_ust_ctl_release_object(-1, entry->cpu_counters[i]);
 		free(entry->cpu_counters[i]);
 	}
 
 	free(entry->cpu_counters);
 
-	ustctl_release_object(-1, entry->counter);
+	lttng_ust_ctl_release_object(-1, entry->counter);
 	free(entry->counter);
 
-	ustctl_destroy_counter(entry->daemon_counter);
+	lttng_ust_ctl_destroy_counter(entry->daemon_counter);
 
 	free(entry);
 }
@@ -219,7 +219,7 @@ init_error_accounting_state(struct error_accounting_state *state,
 {
 	enum event_notifier_error_accounting_status status;
 
-	assert(state);
+	LTTNG_ASSERT(state);
 
 	state->number_indices = index_count;
 
@@ -251,7 +251,7 @@ end:
 static
 void fini_error_accounting_state(struct error_accounting_state *state)
 {
-	assert(state);
+	LTTNG_ASSERT(state);
 
 	/*
 	 * Will assert if some error counter indices were not released (an
@@ -372,15 +372,21 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create(
 		struct lttng_ht *uid_ht, const struct ust_app *app)
 {
 	int i, ret, *cpu_counter_fds = NULL;
-	struct ustctl_daemon_counter *daemon_counter;
+	struct lttng_ust_ctl_daemon_counter *daemon_counter;
 	struct lttng_ust_abi_object_data *counter, **cpu_counters;
 	struct ust_error_accounting_entry *entry = NULL;
-	const struct ustctl_counter_dimension dimension = {
+	const struct lttng_ust_ctl_counter_dimension dimension = {
 		.size = ust_state.number_indices,
 		.has_underflow = false,
 		.has_overflow = false,
 	};
 
+	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);
+		goto error;
+	}
+
 	entry = zmalloc(sizeof(struct ust_error_accounting_entry));
 	if (!entry) {
 		PERROR("Failed to allocate event notifier error acounting entry")
@@ -389,7 +395,7 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create(
 
 	urcu_ref_init(&entry->ref);
 	entry->uid = app->uid;
-	entry->nr_counter_cpu_fds = ustctl_get_nr_cpu_per_counter();
+	entry->nr_counter_cpu_fds = lttng_ust_ctl_get_nr_cpu_per_counter();
 
 	cpu_counter_fds = zmalloc(entry->nr_counter_cpu_fds * sizeof(*cpu_counter_fds));
 	if (!cpu_counter_fds) {
@@ -424,17 +430,17 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create(
 	/*
 	 * Ownership of the file descriptors transferred to the ustctl object.
 	 */
-	daemon_counter = ustctl_create_counter(1, &dimension, 0, -1,
+	daemon_counter = lttng_ust_ctl_create_counter(1, &dimension, 0, -1,
 			entry->nr_counter_cpu_fds, cpu_counter_fds,
-			USTCTL_COUNTER_BITNESS_32,
-			USTCTL_COUNTER_ARITHMETIC_MODULAR,
-			USTCTL_COUNTER_ALLOC_PER_CPU,
+			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;
 	}
 
-	ret = ustctl_create_counter_data(daemon_counter, &counter);
+	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);
@@ -442,7 +448,7 @@ struct ust_error_accounting_entry *ust_error_accounting_entry_create(
 	}
 
 	for (i = 0; i < entry->nr_counter_cpu_fds; i++) {
-		ret = ustctl_create_counter_cpu_data(daemon_counter, 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'",
@@ -472,17 +478,17 @@ error_create_counter_cpu_data:
 			break;
 		}
 
-		ustctl_release_object(-1, cpu_counters[i]);
+		lttng_ust_ctl_release_object(-1, cpu_counters[i]);
 		free(cpu_counters[i]);
 	}
 
-	ustctl_release_object(-1, entry->counter);
+	lttng_ust_ctl_release_object(-1, entry->counter);
 	free(entry->counter);
 error_create_counter_data:
-	ustctl_destroy_counter(daemon_counter);
+	lttng_ust_ctl_destroy_counter(daemon_counter);
 error_create_daemon_counter:
 error_shm_alloc:
-	/* Error occured before per-cpu SHMs were handed-off to ustctl. */
+	/* Error occurred before per-cpu SHMs were handed-off to ustctl. */
 	if (cpu_counter_fds) {
 		for (i = 0; i < entry->nr_counter_cpu_fds; i++) {
 			if (cpu_counter_fds[i] < 0) {
@@ -522,7 +528,7 @@ enum event_notifier_error_accounting_status send_counter_data_to_ust(
 
 	/* Attach counter to trigger group. */
 	pthread_mutex_lock(&app->sock_lock);
-	ret = ustctl_send_counter_data_to_ust(app->sock,
+	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) {
@@ -554,7 +560,7 @@ enum event_notifier_error_accounting_status send_counter_cpu_data_to_ust(
 	enum event_notifier_error_accounting_status status;
 
 	pthread_mutex_lock(&app->sock_lock);
-	ret = ustctl_send_counter_cpu_data_to_ust(app->sock,
+	ret = lttng_ust_ctl_send_counter_cpu_data_to_ust(app->sock,
 			counter, counter_cpu);
 	pthread_mutex_unlock(&app->sock_lock);
 	if (ret < 0) {
@@ -586,6 +592,11 @@ event_notifier_error_accounting_register_app(struct ust_app *app)
 	enum event_notifier_error_accounting_status status;
 	struct lttng_ust_abi_object_data **cpu_counters;
 
+	if (!ust_app_supports_counters(app)) {
+		status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_UNSUPPORTED;
+		goto end;
+	}
+
 	/*
 	 * Check if we already have a error counter for the user id of this
 	 * app. If not, create one.
@@ -621,7 +632,7 @@ event_notifier_error_accounting_register_app(struct ust_app *app)
 	}
 
 	/* Duplicate counter object data. */
-	ret = ustctl_duplicate_ust_object_data(&new_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'",
@@ -655,7 +666,7 @@ event_notifier_error_accounting_register_app(struct ust_app *app)
 	for (i = 0; i < entry->nr_counter_cpu_fds; i++) {
 		struct lttng_ust_abi_object_data *new_counter_cpu = NULL;
 
-		ret = ustctl_duplicate_ust_object_data(&new_counter_cpu,
+		ret = lttng_ust_ctl_duplicate_ust_object_data(&new_counter_cpu,
 				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'",
@@ -688,7 +699,7 @@ event_notifier_error_accounting_register_app(struct ust_app *app)
 	app->event_notifier_group.nr_counter_cpu = entry->nr_counter_cpu_fds;
 	app->event_notifier_group.counter_cpu = cpu_counters;
 	cpu_counters = NULL;
-	goto end;
+	goto end_unlock;
 
 error_send_cpu_counter_data:
 error_duplicate_cpu_counter:
@@ -702,7 +713,7 @@ error_duplicate_cpu_counter:
 			break;
 		}
 
-		ustctl_release_object(-1, cpu_counters[i]);
+		lttng_ust_ctl_release_object(-1, cpu_counters[i]);
 		free(cpu_counters[i]);
 	}
 
@@ -710,14 +721,15 @@ error_duplicate_cpu_counter:
 
 error_allocate_cpu_counters:
 error_send_counter_data:
-	ustctl_release_object(-1, new_counter);
+	lttng_ust_ctl_release_object(-1, new_counter);
 	free(new_counter);
 error_duplicate_counter:
 	ust_error_accounting_entry_put(entry);
 error_creating_entry:
 	app->event_notifier_group.counter = NULL;
-end:
+end_unlock:
 	rcu_read_unlock();
+end:
 	return status;
 }
 
@@ -752,14 +764,14 @@ event_notifier_error_accounting_unregister_app(struct ust_app *app)
 	}
 
 	for (i = 0; i < app->event_notifier_group.nr_counter_cpu; i++) {
-		ustctl_release_object(app->sock,
+		lttng_ust_ctl_release_object(app->sock,
 				app->event_notifier_group.counter_cpu[i]);
 		free(app->event_notifier_group.counter_cpu[i]);
 	}
 
 	free(app->event_notifier_group.counter_cpu);
 
-	ustctl_release_object(app->sock, app->event_notifier_group.counter);
+	lttng_ust_ctl_release_object(app->sock, app->event_notifier_group.counter);
 	free(app->event_notifier_group.counter);
 
 	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
@@ -813,7 +825,7 @@ event_notifier_error_accounting_ust_get_count(
 		int64_t local_value = 0;
 		bool overflow = false, underflow = false;
 
-		ret = ustctl_counter_aggregate(uid_entry->daemon_counter,
+		ret = lttng_ust_ctl_counter_aggregate(uid_entry->daemon_counter,
 				dimension_indexes, &local_value, &overflow,
 				&underflow);
 		if (ret || local_value < 0) {
@@ -883,7 +895,7 @@ enum event_notifier_error_accounting_status event_notifier_error_accounting_ust_
 	 */
 	cds_lfht_for_each_entry(error_counter_uid_ht->ht, &iter.iter,
 			uid_entry, node.node) {
-		const int ret = ustctl_counter_clear(uid_entry->daemon_counter,
+		const int ret = lttng_ust_ctl_counter_clear(uid_entry->daemon_counter,
 				&dimension_index);
 
 		if (ret) {
@@ -915,7 +927,7 @@ event_notifier_error_accounting_kernel_clear(
 	int ret;
 	uint64_t error_counter_index;
 	enum event_notifier_error_accounting_status status;
-	struct lttng_kernel_counter_clear counter_clear = {};
+	struct lttng_kernel_abi_counter_clear counter_clear = {};
 
 	status = get_error_counter_index_for_token(&kernel_state,
 			lttng_trigger_get_tracer_token(trigger),
@@ -963,11 +975,11 @@ event_notifier_error_accounting_register_kernel(
 {
 	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,
+	const struct lttng_kernel_abi_counter_conf error_counter_conf = {
+		.arithmetic = LTTNG_KERNEL_ABI_COUNTER_ARITHMETIC_MODULAR,
 		.bitness = sizeof(void *) == sizeof(uint32_t) ?
-				LTTNG_KERNEL_COUNTER_BITNESS_32 :
-				LTTNG_KERNEL_COUNTER_BITNESS_64,
+				LTTNG_KERNEL_ABI_COUNTER_BITNESS_32 :
+				LTTNG_KERNEL_ABI_COUNTER_BITNESS_64,
 		.global_sum_step = 0,
 		.number_dimensions = 1,
 		.dimensions[0].size = kernel_state.number_indices,
@@ -1016,7 +1028,7 @@ enum event_notifier_error_accounting_status create_error_counter_index_for_token
 	uint64_t local_error_counter_index;
 	enum event_notifier_error_accounting_status status;
 
-	assert(state);
+	LTTNG_ASSERT(state);
 
 	/* Allocate a new index for that counter. */
 	index_alloc_status = lttng_index_allocator_alloc(state->index_allocator,
@@ -1069,6 +1081,9 @@ event_notifier_error_accounting_register_event_notifier(
 		state = &kernel_state;
 		break;
 	case LTTNG_DOMAIN_UST:
+	case LTTNG_DOMAIN_PYTHON:
+	case LTTNG_DOMAIN_JUL:
+	case LTTNG_DOMAIN_LOG4J:
 		state = &ust_state;
 		break;
 	default:
@@ -1117,6 +1132,9 @@ event_notifier_error_accounting_register_event_notifier(
 #ifdef HAVE_LIBLTTNG_UST_CTL
 	switch (lttng_trigger_get_underlying_domain_type_restriction(trigger)) {
 	case LTTNG_DOMAIN_UST:
+	case LTTNG_DOMAIN_PYTHON:
+	case LTTNG_DOMAIN_JUL:
+	case LTTNG_DOMAIN_LOG4J:
 		pthread_mutex_lock(&the_event_notifier_counter.lock);
 		the_event_notifier_counter.count++;
 		if (the_event_notifier_counter.count == 1) {
@@ -1145,7 +1163,7 @@ 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 = {};
+	struct lttng_kernel_abi_counter_aggregate counter_aggregate = {};
 	enum event_notifier_error_accounting_status status;
 	uint64_t error_counter_index;
 	int ret;
@@ -1162,7 +1180,7 @@ event_notifier_error_accounting_kernel_get_count(
 	counter_aggregate.index.number_dimensions = 1;
 	counter_aggregate.index.dimension_indexes[0] = error_counter_index;
 
-	assert(kernel_error_accounting_entry.error_counter_fd);
+	LTTNG_ASSERT(kernel_error_accounting_entry.error_counter_fd);
 
 	ret = kernctl_counter_get_aggregate_value(
 			kernel_error_accounting_entry.error_counter_fd,
@@ -1188,7 +1206,7 @@ event_notifier_error_accounting_kernel_get_count(
 	}
 
 	/* Error count can't be negative. */
-	assert(counter_aggregate.value.value >= 0);
+	LTTNG_ASSERT(counter_aggregate.value.value >= 0);
 	*count = (uint64_t) counter_aggregate.value.value;
 
 	status = EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK;
@@ -1206,6 +1224,9 @@ event_notifier_error_accounting_get_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);
@@ -1226,6 +1247,9 @@ event_notifier_error_accounting_clear(const struct lttng_trigger *trigger)
 	case LTTNG_DOMAIN_KERNEL:
 		return event_notifier_error_accounting_kernel_clear(trigger);
 	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_clear(trigger);
 #else
@@ -1269,6 +1293,9 @@ void event_notifier_error_accounting_unregister_event_notifier(
 		break;
 #ifdef HAVE_LIBLTTNG_UST_CTL
 	case LTTNG_DOMAIN_UST:
+	case LTTNG_DOMAIN_PYTHON:
+	case LTTNG_DOMAIN_JUL:
+	case LTTNG_DOMAIN_LOG4J:
 		state = &ust_state;
 
 		pthread_mutex_lock(&the_event_notifier_counter.lock);
@@ -1316,7 +1343,7 @@ void event_notifier_error_accounting_unregister_event_notifier(
 		}
 
 		del_ret = lttng_ht_del(state->indices_ht, &iter);
-		assert(!del_ret);
+		LTTNG_ASSERT(!del_ret);
 		call_rcu(&index_entry->rcu_head, free_index_ht_entry);
 	}