X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Flist_triggers.c;h=8be31933629a27ba8f92bd79f72d3b66da2f4c08;hb=57739a6b3247c7ded74522906e214eff0d6dc14c;hp=d208f4ff68cb66b71fe4db70b36498ed19379991;hpb=7f4d5b07cf7be895b38b69073389a4fcc318ec29;p=lttng-tools.git

diff --git a/src/bin/lttng/commands/list_triggers.c b/src/bin/lttng/commands/list_triggers.c
index d208f4ff6..8be319336 100644
--- a/src/bin/lttng/commands/list_triggers.c
+++ b/src/bin/lttng/commands/list_triggers.c
@@ -18,7 +18,10 @@
 #include "lttng/condition/on-event-internal.h"
 /* For lttng_domain_type_str(). */
 #include "lttng/domain-internal.h"
+/* For lttng_event_rule_syscall_emission_site_str() */
+#include "lttng/event-rule/syscall-internal.h"
 #include "../loglevel.h"
+#include <lttng/lttng.h>
 
 #ifdef LTTNG_EMBED_HELP
 static const char help_msg[] =
@@ -38,6 +41,81 @@ struct argpar_opt_descr list_trigger_options[] = {
 	ARGPAR_OPT_DESCR_SENTINEL,
 };
 
+static void print_condition_session_consumed_size(
+		const struct lttng_condition *condition)
+{
+	enum lttng_condition_status condition_status;
+	const char *session_name;
+	uint64_t threshold;
+
+	condition_status =
+			lttng_condition_session_consumed_size_get_session_name(
+					condition, &session_name);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	lttng_condition_session_consumed_size_get_threshold(
+			condition, &threshold);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	MSG("    session name: %s", session_name);
+	MSG("    threshold: %" PRIu64 " bytes", threshold);
+}
+
+static void print_condition_buffer_usage(
+		const struct lttng_condition *condition)
+{
+	enum lttng_condition_status condition_status;
+	const char *session_name, *channel_name;
+	enum lttng_domain_type domain_type;
+	uint64_t threshold;
+
+	condition_status = lttng_condition_buffer_usage_get_session_name(
+			condition, &session_name);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	condition_status = lttng_condition_buffer_usage_get_channel_name(
+			condition, &channel_name);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	condition_status = lttng_condition_buffer_usage_get_domain_type(
+			condition, &domain_type);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	MSG("    session name: %s", session_name);
+	MSG("    channel name: %s", channel_name);
+	MSG("    domain: %s", lttng_domain_type_str(domain_type));
+
+	condition_status = lttng_condition_buffer_usage_get_threshold(
+			condition, &threshold);
+	if (condition_status == LTTNG_CONDITION_STATUS_OK) {
+		MSG("    threshold (bytes): %" PRIu64, threshold);
+	} else {
+		double threshold_ratio;
+
+		assert(condition_status == LTTNG_CONDITION_STATUS_UNSET);
+
+		condition_status =
+				lttng_condition_buffer_usage_get_threshold_ratio(
+						condition, &threshold_ratio);
+		assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+		MSG("    threshold (ratio): %.2f", threshold_ratio);
+	}
+}
+
+static void print_condition_session_rotation(
+		const struct lttng_condition *condition)
+{
+	enum lttng_condition_status condition_status;
+	const char *session_name;
+
+	condition_status = lttng_condition_session_rotation_get_session_name(
+			condition, &session_name);
+	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
+
+	MSG("    session name: %s", session_name);
+}
+
 /*
  * Returns the human-readable log level name associated with a numerical value
  * if there is one. The Log4j and JUL domains have discontinuous log level
@@ -265,7 +343,7 @@ void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule)
 		goto end;
 	}
 
-	_MSG("    rule: %s (type: userspace probe, location: ", name);
+	_MSG("    rule: %s (type: userspace probe, ", name);
 
 	userspace_probe_location_type =
 			lttng_userspace_probe_location_get_type(location);
@@ -280,12 +358,22 @@ void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule)
 		function_name = lttng_userspace_probe_location_function_get_function_name(
 				location);
 
-		_MSG("%s:%s", binary_path, function_name);
+		_MSG("location type: ELF, location: %s:%s", binary_path, function_name);
 		break;
 	}
 	case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
-		_MSG("SDT not implemented yet");
+	{
+		const char *binary_path, *provider_name, *probe_name;
+
+		binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(
+				location);
+		provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
+				location);
+		probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
+				location);
+		_MSG("location type: SDT, location: %s:%s:%s", binary_path, provider_name, probe_name);
 		break;
+	}
 	default:
 		abort();
 	}
@@ -301,14 +389,20 @@ void print_event_rule_syscall(const struct lttng_event_rule *event_rule)
 {
 	const char *pattern, *filter;
 	enum lttng_event_rule_status event_rule_status;
+	enum lttng_event_rule_syscall_emission_site_type emission_site_type;
 
 	assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_SYSCALL);
 
+	emission_site_type =
+		lttng_event_rule_syscall_get_emission_site_type(event_rule);
+
 	event_rule_status = lttng_event_rule_syscall_get_pattern(
 			event_rule, &pattern);
 	assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
 
-	_MSG("    rule: %s (type: syscall", pattern);
+	_MSG("    rule: %s (type: syscall:%s", pattern,
+			lttng_event_rule_syscall_emission_site_str(
+					emission_site_type));
 
 	event_rule_status = lttng_event_rule_syscall_get_filter(
 			event_rule, &filter);
@@ -418,7 +512,6 @@ void print_condition_on_event(const struct lttng_condition *condition)
 	const struct lttng_event_rule *event_rule;
 	enum lttng_condition_status condition_status;
 	unsigned int cap_desc_count, i;
-	uint64_t error_count;
 
 	condition_status =
 		lttng_condition_on_event_get_rule(condition, &event_rule);
@@ -431,9 +524,6 @@ void print_condition_on_event(const struct lttng_condition *condition)
 					condition, &cap_desc_count);
 	assert(condition_status == LTTNG_CONDITION_STATUS_OK);
 
-	error_count = lttng_condition_on_event_get_error_count(condition);
-	MSG("    tracer notifications discarded: %" PRIu64, error_count);
-
 	if (cap_desc_count > 0) {
 		MSG("    captures:");
 
@@ -450,7 +540,93 @@ void print_condition_on_event(const struct lttng_condition *condition)
 }
 
 static
-void print_one_action(const struct lttng_action *action)
+void print_action_errors(const struct lttng_trigger *trigger,
+		const struct lttng_action *action)
+{
+	unsigned int i, count, printed_errors_count = 0;
+	enum lttng_error_code error_query_ret;
+	enum lttng_error_query_results_status results_status;
+	struct lttng_error_query_results *results = NULL;
+	const char *trigger_name;
+	uid_t trigger_uid;
+	enum lttng_trigger_status trigger_status;
+	struct lttng_error_query *query =
+			lttng_error_query_action_create(trigger, action);
+
+	assert(query);
+
+	trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
+	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
+
+	trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
+	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
+
+	error_query_ret = lttng_error_query_execute(
+			query, lttng_session_daemon_command_endpoint, &results);
+	if (error_query_ret != LTTNG_OK) {
+		ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
+				trigger_name, (int) trigger_uid,
+				lttng_strerror(-error_query_ret));
+		goto end;
+	}
+
+	results_status = lttng_error_query_results_get_count(results, &count);
+	assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+	_MSG("      errors:");
+
+	for (i = 0; i < count; i++) {
+		const struct lttng_error_query_result *result;
+		enum lttng_error_query_result_status result_status;
+		const char *result_name;
+		const char *result_description;
+		uint64_t result_value;
+
+		results_status = lttng_error_query_results_get_result(
+				results, &result, i);
+		assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+		result_status = lttng_error_query_result_get_name(
+				result, &result_name);
+		assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+		result_status = lttng_error_query_result_get_description(
+				result, &result_description);
+		assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+
+		if (lttng_error_query_result_get_type(result) ==
+				LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
+			result_status = lttng_error_query_result_counter_get_value(
+					result, &result_value);
+			assert(result_status ==
+					LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+			if (result_value == 0) {
+				continue;
+			}
+
+			MSG("");
+			_MSG("        %s: %" PRIu64, result_name,
+					result_value);
+			printed_errors_count++;
+		} else {
+			_MSG("        Unknown error query result type for result '%s' (%s)",
+					result_name, result_description);
+			continue;
+		}
+	}
+
+	if (printed_errors_count == 0) {
+		_MSG(" none");
+	}
+
+end:
+	MSG("");
+	lttng_error_query_destroy(query);
+	lttng_error_query_results_destroy(results);
+}
+
+static
+void print_one_action(const struct lttng_trigger *trigger,
+		const struct lttng_action *action)
 {
 	enum lttng_action_type action_type;
 	enum lttng_action_status action_status;
@@ -616,10 +792,96 @@ void print_one_action(const struct lttng_action *action)
 	}
 
 	MSG("");
+	print_action_errors(trigger, action);
+
 end:
 	return;
 }
 
+static
+void print_trigger_errors(const struct lttng_trigger *trigger)
+{
+	unsigned int i, count, printed_errors_count = 0;
+	enum lttng_error_code error_query_ret;
+	enum lttng_error_query_results_status results_status;
+	struct lttng_error_query_results *results = NULL;
+	enum lttng_trigger_status trigger_status;
+	const char *trigger_name;
+	uid_t trigger_uid;
+	struct lttng_error_query *query =
+			lttng_error_query_trigger_create(trigger);
+
+	assert(query);
+
+	trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
+	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
+
+	trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
+	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
+
+	error_query_ret = lttng_error_query_execute(
+			query, lttng_session_daemon_command_endpoint, &results);
+	if (error_query_ret != LTTNG_OK) {
+		ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
+				trigger_name, (int) trigger_uid,
+				lttng_strerror(-error_query_ret));
+		goto end;
+	}
+
+	results_status = lttng_error_query_results_get_count(results, &count);
+	assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+	_MSG("  errors:");
+
+	for (i = 0; i < count; i++) {
+		const struct lttng_error_query_result *result;
+		enum lttng_error_query_result_status result_status;
+		const char *result_name;
+		const char *result_description;
+		uint64_t result_value;
+
+		results_status = lttng_error_query_results_get_result(
+				results, &result, i);
+		assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+		result_status = lttng_error_query_result_get_name(
+				result, &result_name);
+		assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+		result_status = lttng_error_query_result_get_description(
+				result, &result_description);
+		assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+
+		if (lttng_error_query_result_get_type(result) ==
+				LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
+			result_status = lttng_error_query_result_counter_get_value(
+					result, &result_value);
+			assert(result_status ==
+					LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+			if (result_value == 0) {
+				continue;
+			}
+
+			MSG("");
+			_MSG("    %s: %" PRIu64, result_name,
+					result_value);
+			printed_errors_count++;
+		} else {
+			_MSG("    Unknown error query result type for result '%s' (%s)",
+					result_name, result_description);
+			continue;
+		}
+	}
+
+	if (printed_errors_count == 0) {
+		_MSG(" none");
+	}
+
+end:
+	MSG("");
+	lttng_error_query_destroy(query);
+	lttng_error_query_results_destroy(results);
+}
+
 static
 void print_one_trigger(const struct lttng_trigger *trigger)
 {
@@ -637,19 +899,29 @@ void print_one_trigger(const struct lttng_trigger *trigger)
 	trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
 	assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 
-	MSG("- id: %s", name);
-	MSG("  user id: %d", trigger_uid);
+	MSG("- name: %s", name);
+	MSG("  owner uid: %d", trigger_uid);
 
 	condition = lttng_trigger_get_const_condition(trigger);
 	condition_type = lttng_condition_get_type(condition);
 	MSG("  condition: %s", lttng_condition_type_str(condition_type));
 	switch (condition_type) {
+	case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
+		print_condition_session_consumed_size(condition);
+		break;
+	case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
+	case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
+		print_condition_buffer_usage(condition);
+		break;
+	case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
+	case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
+		print_condition_session_rotation(condition);
+		break;
 	case LTTNG_CONDITION_TYPE_ON_EVENT:
 		print_condition_on_event(condition);
 		break;
 	default:
-		MSG("  (condition type not handled in %s)", __func__);
-		break;
+		abort();
 	}
 
 	action = lttng_trigger_get_const_action(trigger);
@@ -669,13 +941,14 @@ void print_one_trigger(const struct lttng_trigger *trigger)
 							action, i);
 
 			_MSG("    ");
-			print_one_action(subaction);
+			print_one_action(trigger, subaction);
 		}
 	} else {
 		_MSG(" action:");
-		print_one_action(action);
+		print_one_action(trigger, action);
 	}
 
+	print_trigger_errors(trigger);
 }
 
 static