[lttng-tools.git] / src / common / event-rule / event-rule.cpp

/*
 * Copyright (C) 2019 Jonathan Rajotte
 * <jonathan.rajotte-julien@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <common/error.hpp>
#include <common/hashtable/hashtable.hpp>
#include <common/hashtable/utils.hpp>
#include <common/macros.hpp>
#include <common/mi-lttng.hpp>
#include <common/payload-view.hpp>
#include <common/payload.hpp>

#include <lttng/event-rule/event-rule-internal.hpp>
#include <lttng/event-rule/jul-logging-internal.hpp>
#include <lttng/event-rule/kernel-kprobe-internal.hpp>
#include <lttng/event-rule/kernel-syscall-internal.hpp>
#include <lttng/event-rule/kernel-tracepoint-internal.hpp>
#include <lttng/event-rule/kernel-uprobe-internal.hpp>
#include <lttng/event-rule/log4j-logging-internal.hpp>
#include <lttng/event-rule/log4j2-logging-internal.hpp>
#include <lttng/event-rule/python-logging-internal.hpp>
#include <lttng/event-rule/user-tracepoint-internal.hpp>

#include <stdbool.h>

enum lttng_event_rule_type lttng_event_rule_get_type(const struct lttng_event_rule *event_rule)
{
	return event_rule ? event_rule->type : LTTNG_EVENT_RULE_TYPE_UNKNOWN;
}

enum lttng_domain_type lttng_event_rule_get_domain_type(const struct lttng_event_rule *event_rule)
{
	enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;

	switch (lttng_event_rule_get_type(event_rule)) {
	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
		domain_type = LTTNG_DOMAIN_UST;
		break;
	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
		domain_type = LTTNG_DOMAIN_JUL;
		break;
	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
		domain_type = LTTNG_DOMAIN_LOG4J;
		break;
	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
		domain_type = LTTNG_DOMAIN_LOG4J2;
		break;
	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
		domain_type = LTTNG_DOMAIN_PYTHON;
		break;
	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
		domain_type = LTTNG_DOMAIN_KERNEL;
		break;
	case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
		domain_type = LTTNG_DOMAIN_NONE;
		break;
	}

	return domain_type;
}

static void lttng_event_rule_release(struct urcu_ref *ref)
{
	struct lttng_event_rule *event_rule =
		lttng::utils::container_of(ref, &lttng_event_rule::ref);

	LTTNG_ASSERT(event_rule->destroy);
	event_rule->destroy(event_rule);
}

void lttng_event_rule_destroy(struct lttng_event_rule *event_rule)
{
	lttng_event_rule_put(event_rule);
}

bool lttng_event_rule_validate(const struct lttng_event_rule *event_rule)
{
	bool valid;

	if (!event_rule) {
		valid = false;
		goto end;
	}

	if (!event_rule->validate) {
		/* Sub-class guarantees that it can never be invalid. */
		valid = true;
		goto end;
	}

	valid = event_rule->validate(event_rule);
end:
	return valid;
}

int lttng_event_rule_serialize(const struct lttng_event_rule *event_rule,
			       struct lttng_payload *payload)
{
	int ret;
	struct lttng_event_rule_comm event_rule_comm = {};

	if (!event_rule) {
		ret = -1;
		goto end;
	}

	event_rule_comm.event_rule_type = (int8_t) event_rule->type;

	ret = lttng_dynamic_buffer_append(
		&payload->buffer, &event_rule_comm, sizeof(event_rule_comm));
	if (ret) {
		goto end;
	}

	ret = event_rule->serialize(event_rule, payload);
	if (ret) {
		goto end;
	}
end:
	return ret;
}

bool lttng_event_rule_is_equal(const struct lttng_event_rule *a, const struct lttng_event_rule *b)
{
	bool is_equal = false;

	if (!a || !b) {
		goto end;
	}

	if (a->type != b->type) {
		goto end;
	}

	if (a == b) {
		is_equal = true;
		goto end;
	}

	is_equal = a->equal ? a->equal(a, b) : true;
end:
	return is_equal;
}

ssize_t lttng_event_rule_create_from_payload(struct lttng_payload_view *view,
					     struct lttng_event_rule **event_rule)
{
	ssize_t ret, consumed = 0;
	event_rule_create_from_payload_cb create_from_payload = nullptr;
	const struct lttng_event_rule_comm *event_rule_comm;
	const struct lttng_payload_view event_rule_comm_view =
		lttng_payload_view_from_view(view, 0, sizeof(*event_rule_comm));

	if (!view || !event_rule) {
		ret = -1;
		goto end;
	}

	if (!lttng_payload_view_is_valid(&event_rule_comm_view)) {
		ret = -1;
		goto end;
	}

	DBG("Deserializing event_rule from payload");
	event_rule_comm = (const struct lttng_event_rule_comm *) event_rule_comm_view.buffer.data;
	consumed += sizeof(*event_rule_comm);

	switch ((enum lttng_event_rule_type) event_rule_comm->event_rule_type) {
	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
		create_from_payload = lttng_event_rule_kernel_kprobe_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
		create_from_payload = lttng_event_rule_kernel_uprobe_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
		create_from_payload = lttng_event_rule_kernel_syscall_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
		create_from_payload = lttng_event_rule_kernel_tracepoint_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
		create_from_payload = lttng_event_rule_user_tracepoint_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
		create_from_payload = lttng_event_rule_jul_logging_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
		create_from_payload = lttng_event_rule_log4j_logging_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
		create_from_payload = lttng_event_rule_log4j2_logging_create_from_payload;
		break;
	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
		create_from_payload = lttng_event_rule_python_logging_create_from_payload;
		break;
	default:
		ERR("Attempted to create event rule of unknown type (%i)",
		    (int) event_rule_comm->event_rule_type);
		ret = -1;
		goto end;
	}

	LTTNG_ASSERT(create_from_payload);

	{
		struct lttng_payload_view child_view =
			lttng_payload_view_from_view(view, consumed, -1);

		ret = create_from_payload(&child_view, event_rule);
		if (ret < 0) {
			goto end;
		}

		consumed += ret;
	}

	if (!lttng_event_rule_validate(*event_rule)) {
		ret = -1;
		goto end;
	}

	ret = consumed;
end:
	return ret;
}

void lttng_event_rule_init(struct lttng_event_rule *event_rule, enum lttng_event_rule_type type)
{
	urcu_ref_init(&event_rule->ref);
	event_rule->type = type;
}

bool lttng_event_rule_get(struct lttng_event_rule *event_rule)
{
	return urcu_ref_get_unless_zero(&event_rule->ref);
}

void lttng_event_rule_put(struct lttng_event_rule *event_rule)
{
	if (!event_rule) {
		return;
	}

	LTTNG_ASSERT(event_rule->ref.refcount);
	urcu_ref_put(&event_rule->ref, lttng_event_rule_release);
}

enum lttng_error_code
lttng_event_rule_generate_filter_bytecode(struct lttng_event_rule *rule,
					  const struct lttng_credentials *creds)
{
	LTTNG_ASSERT(rule->generate_filter_bytecode);
	return rule->generate_filter_bytecode(rule, creds);
}

const char *lttng_event_rule_get_filter(const struct lttng_event_rule *rule)
{
	LTTNG_ASSERT(rule->get_filter);
	return rule->get_filter(rule);
}

const struct lttng_bytecode *
lttng_event_rule_get_filter_bytecode(const struct lttng_event_rule *rule)
{
	LTTNG_ASSERT(rule->get_filter_bytecode);
	return rule->get_filter_bytecode(rule);
}

enum lttng_event_rule_generate_exclusions_status
lttng_event_rule_generate_exclusions(const struct lttng_event_rule *rule,
				     struct lttng_event_exclusion **exclusions)
{
	LTTNG_ASSERT(rule->generate_exclusions);
	return rule->generate_exclusions(rule, exclusions);
}

struct lttng_event *lttng_event_rule_generate_lttng_event(const struct lttng_event_rule *rule)
{
	LTTNG_ASSERT(rule->generate_lttng_event);
	return rule->generate_lttng_event(rule);
}

bool lttng_event_rule_targets_agent_domain(const struct lttng_event_rule *rule)
{
	bool targets_agent_domain = false;
	const lttng_domain_type type = lttng_event_rule_get_domain_type(rule);

	switch (type) {
	case LTTNG_DOMAIN_JUL:
	case LTTNG_DOMAIN_LOG4J:
	case LTTNG_DOMAIN_LOG4J2:
	case LTTNG_DOMAIN_PYTHON:
		targets_agent_domain = true;
		break;
	case LTTNG_DOMAIN_UST:
	case LTTNG_DOMAIN_KERNEL:
		targets_agent_domain = false;
		break;
	default:
		abort();
	};

	return targets_agent_domain;
}

const char *lttng_event_rule_type_str(enum lttng_event_rule_type type)
{
	switch (type) {
	case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
		return "unknown";
	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
		return "kernel syscall";
	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
		return "kernel kprobe";
	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
		return "kernel uprobe";
	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
		return "kernel tracepoint";
	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
		return "user tracepoint";
	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
		return "jul logging";
	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
		return "log4j logging";
	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
		return "log4j2 logging";
	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
		return "python logging";

	default:
		abort();
	}
}

unsigned long lttng_event_rule_hash(const struct lttng_event_rule *rule)
{
	LTTNG_ASSERT(rule->hash);
	return rule->hash(rule);
}

enum lttng_error_code lttng_event_rule_mi_serialize(const struct lttng_event_rule *rule,
						    struct mi_writer *writer)
{
	int ret;
	enum lttng_error_code ret_code;

	LTTNG_ASSERT(rule);
	LTTNG_ASSERT(writer);
	LTTNG_ASSERT(rule->mi_serialize);

	/* Open event rule element. */
	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_rule);
	if (ret) {
		goto mi_error;
	}

	/* Serialize underlying event rule. */
	ret_code = rule->mi_serialize(rule, writer);
	if (ret_code != LTTNG_OK) {
		goto end;
	}

	/* Close event rule element. */
	ret = mi_lttng_writer_close_element(writer);
	if (ret) {
		goto mi_error;
	}

	ret_code = LTTNG_OK;
	goto end;

mi_error:
	ret_code = LTTNG_ERR_MI_IO_FAIL;
end:
	return ret_code;
}
Commit	Line	Data
7a3dcaf6 JR	1	/*
	2	* Copyright (C) 2019 Jonathan Rajotte
	3	* <jonathan.rajotte-julien@efficios.com>
	4	*
	5	* SPDX-License-Identifier: LGPL-2.1-only
	6	*
	7	*/
	8
c9e313bc SM	9	#include <common/error.hpp>
	10	#include <common/hashtable/hashtable.hpp>
	11	#include <common/hashtable/utils.hpp>
	12	#include <common/macros.hpp>
	13	#include <common/mi-lttng.hpp>
	14	#include <common/payload-view.hpp>
	15	#include <common/payload.hpp>
28ab034a	16
c9e313bc SM	17	#include <lttng/event-rule/event-rule-internal.hpp>
	18	#include <lttng/event-rule/jul-logging-internal.hpp>
	19	#include <lttng/event-rule/kernel-kprobe-internal.hpp>
	20	#include <lttng/event-rule/kernel-syscall-internal.hpp>
	21	#include <lttng/event-rule/kernel-tracepoint-internal.hpp>
	22	#include <lttng/event-rule/kernel-uprobe-internal.hpp>
	23	#include <lttng/event-rule/log4j-logging-internal.hpp>
47abf22b	24	#include <lttng/event-rule/log4j2-logging-internal.hpp>
c9e313bc SM	25	#include <lttng/event-rule/python-logging-internal.hpp>
c9e313bc SM	26	#include <lttng/event-rule/user-tracepoint-internal.hpp>
28ab034a	27
7a3dcaf6 JR	28	#include <stdbool.h>
7a3dcaf6 JR	29
28ab034a	30	enum lttng_event_rule_type lttng_event_rule_get_type(const struct lttng_event_rule *event_rule)
7a3dcaf6 JR	31	{
	32	return event_rule ? event_rule->type : LTTNG_EVENT_RULE_TYPE_UNKNOWN;
	33	}
	34
28ab034a	35	enum lttng_domain_type lttng_event_rule_get_domain_type(const struct lttng_event_rule *event_rule)
7a3dcaf6 JR	36	{
	37	enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
	38
	39	switch (lttng_event_rule_get_type(event_rule)) {
0a23a07d JR	40	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
	41	domain_type = LTTNG_DOMAIN_UST;
	42	break;
b47b01d8 JR	43	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
	44	domain_type = LTTNG_DOMAIN_JUL;
	45	break;
138d6838 JR	46	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
	47	domain_type = LTTNG_DOMAIN_LOG4J;
	48	break;
47abf22b MJ	49	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
	50	domain_type = LTTNG_DOMAIN_LOG4J2;
	51	break;
6530ec7d JR	52	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
	53	domain_type = LTTNG_DOMAIN_PYTHON;
	54	break;
4f7da553	55	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
85522de5	56	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
46fd07ac	57	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
af0818ef	58	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
7a3dcaf6 JR	59	domain_type = LTTNG_DOMAIN_KERNEL;
	60	break;
	61	case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
	62	domain_type = LTTNG_DOMAIN_NONE;
	63	break;
	64	}
	65
	66	return domain_type;
	67	}
	68
	69	static void lttng_event_rule_release(struct urcu_ref *ref)
	70	{
	71	struct lttng_event_rule *event_rule =
28ab034a	72	lttng::utils::container_of(ref, &lttng_event_rule::ref);
7a3dcaf6	73
a0377dfe	74	LTTNG_ASSERT(event_rule->destroy);
7a3dcaf6 JR	75	event_rule->destroy(event_rule);
	76	}
	77
	78	void lttng_event_rule_destroy(struct lttng_event_rule *event_rule)
	79	{
	80	lttng_event_rule_put(event_rule);
	81	}
	82
7a3dcaf6 JR	83	bool lttng_event_rule_validate(const struct lttng_event_rule *event_rule)
	84	{
	85	bool valid;
	86
	87	if (!event_rule) {
	88	valid = false;
	89	goto end;
	90	}
	91
	92	if (!event_rule->validate) {
	93	/* Sub-class guarantees that it can never be invalid. */
	94	valid = true;
	95	goto end;
	96	}
	97
	98	valid = event_rule->validate(event_rule);
	99	end:
	100	return valid;
	101	}
	102
7a3dcaf6	103	int lttng_event_rule_serialize(const struct lttng_event_rule *event_rule,
28ab034a	104	struct lttng_payload *payload)
7a3dcaf6 JR	105	{
	106	int ret;
	107	struct lttng_event_rule_comm event_rule_comm = {};
	108
	109	if (!event_rule) {
	110	ret = -1;
	111	goto end;
	112	}
	113
	114	event_rule_comm.event_rule_type = (int8_t) event_rule->type;
	115
	116	ret = lttng_dynamic_buffer_append(
28ab034a	117	&payload->buffer, &event_rule_comm, sizeof(event_rule_comm));
7a3dcaf6 JR	118	if (ret) {
	119	goto end;
	120	}
	121
	122	ret = event_rule->serialize(event_rule, payload);
	123	if (ret) {
	124	goto end;
	125	}
	126	end:
	127	return ret;
	128	}
	129
28ab034a	130	bool lttng_event_rule_is_equal(const struct lttng_event_rule a, const struct lttng_event_rule b)
7a3dcaf6 JR	131	{
	132	bool is_equal = false;
	133
	134	if (!a \|\| !b) {
	135	goto end;
	136	}
	137
	138	if (a->type != b->type) {
	139	goto end;
	140	}
	141
	142	if (a == b) {
	143	is_equal = true;
	144	goto end;
	145	}
	146
	147	is_equal = a->equal ? a->equal(a, b) : true;
	148	end:
	149	return is_equal;
	150	}
	151
28ab034a JG	152	ssize_t lttng_event_rule_create_from_payload(struct lttng_payload_view *view,
28ab034a JG	153	struct lttng_event_rule **event_rule)
7a3dcaf6 JR	154	{
7a3dcaf6 JR	155	ssize_t ret, consumed = 0;
cd9adb8b	156	event_rule_create_from_payload_cb create_from_payload = nullptr;
3e6e0df2 JG	157	const struct lttng_event_rule_comm *event_rule_comm;
3e6e0df2 JG	158	const struct lttng_payload_view event_rule_comm_view =
28ab034a	159	lttng_payload_view_from_view(view, 0, sizeof(*event_rule_comm));
7a3dcaf6 JR	160
	161	if (!view \|\| !event_rule) {
	162	ret = -1;
	163	goto end;
	164	}
	165
3e6e0df2 JG	166	if (!lttng_payload_view_is_valid(&event_rule_comm_view)) {
	167	ret = -1;
	168	goto end;
	169	}
	170
683d081a	171	DBG("Deserializing event_rule from payload");
3e6e0df2	172	event_rule_comm = (const struct lttng_event_rule_comm *) event_rule_comm_view.buffer.data;
7a3dcaf6 JR	173	consumed += sizeof(*event_rule_comm);
	174
	175	switch ((enum lttng_event_rule_type) event_rule_comm->event_rule_type) {
85522de5 JR	176	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
85522de5 JR	177	create_from_payload = lttng_event_rule_kernel_kprobe_create_from_payload;
7a3dcaf6	178	break;
46fd07ac JR	179	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
46fd07ac JR	180	create_from_payload = lttng_event_rule_kernel_uprobe_create_from_payload;
7a3dcaf6	181	break;
4f7da553	182	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
28ab034a	183	create_from_payload = lttng_event_rule_kernel_syscall_create_from_payload;
7a3dcaf6	184	break;
af0818ef	185	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
28ab034a	186	create_from_payload = lttng_event_rule_kernel_tracepoint_create_from_payload;
af0818ef	187	break;
0a23a07d	188	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
28ab034a	189	create_from_payload = lttng_event_rule_user_tracepoint_create_from_payload;
0a23a07d	190	break;
b47b01d8	191	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
28ab034a	192	create_from_payload = lttng_event_rule_jul_logging_create_from_payload;
b47b01d8	193	break;
138d6838	194	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
28ab034a	195	create_from_payload = lttng_event_rule_log4j_logging_create_from_payload;
138d6838	196	break;
47abf22b MJ	197	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
	198	create_from_payload = lttng_event_rule_log4j2_logging_create_from_payload;
	199	break;
6530ec7d	200	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
28ab034a	201	create_from_payload = lttng_event_rule_python_logging_create_from_payload;
6530ec7d	202	break;
7a3dcaf6 JR	203	default:
7a3dcaf6 JR	204	ERR("Attempted to create event rule of unknown type (%i)",
28ab034a	205	(int) event_rule_comm->event_rule_type);
7a3dcaf6 JR	206	ret = -1;
	207	goto end;
	208	}
	209
a0377dfe	210	LTTNG_ASSERT(create_from_payload);
7a3dcaf6 JR	211
	212	{
	213	struct lttng_payload_view child_view =
28ab034a	214	lttng_payload_view_from_view(view, consumed, -1);
7a3dcaf6 JR	215
	216	ret = create_from_payload(&child_view, event_rule);
	217	if (ret < 0) {
	218	goto end;
	219	}
	220
	221	consumed += ret;
	222	}
	223
	224	if (!lttng_event_rule_validate(*event_rule)) {
	225	ret = -1;
	226	goto end;
	227	}
	228
	229	ret = consumed;
	230	end:
	231	return ret;
	232	}
	233
28ab034a	234	void lttng_event_rule_init(struct lttng_event_rule *event_rule, enum lttng_event_rule_type type)
7a3dcaf6 JR	235	{
	236	urcu_ref_init(&event_rule->ref);
	237	event_rule->type = type;
	238	}
	239
7a3dcaf6 JR	240	bool lttng_event_rule_get(struct lttng_event_rule *event_rule)
	241	{
	242	return urcu_ref_get_unless_zero(&event_rule->ref);
	243	}
	244
7a3dcaf6 JR	245	void lttng_event_rule_put(struct lttng_event_rule *event_rule)
	246	{
	247	if (!event_rule) {
	248	return;
	249	}
	250
a0377dfe	251	LTTNG_ASSERT(event_rule->ref.refcount);
7a3dcaf6 JR	252	urcu_ref_put(&event_rule->ref, lttng_event_rule_release);
	253	}
	254
28ab034a JG	255	enum lttng_error_code
	256	lttng_event_rule_generate_filter_bytecode(struct lttng_event_rule *rule,
	257	const struct lttng_credentials *creds)
7a3dcaf6	258	{
a0377dfe	259	LTTNG_ASSERT(rule->generate_filter_bytecode);
58daac01	260	return rule->generate_filter_bytecode(rule, creds);
7a3dcaf6 JR	261	}
7a3dcaf6 JR	262
7a3dcaf6 JR	263	const char lttng_event_rule_get_filter(const struct lttng_event_rule rule)
7a3dcaf6 JR	264	{
a0377dfe	265	LTTNG_ASSERT(rule->get_filter);
7a3dcaf6 JR	266	return rule->get_filter(rule);
	267	}
	268
28ab034a JG	269	const struct lttng_bytecode *
28ab034a JG	270	lttng_event_rule_get_filter_bytecode(const struct lttng_event_rule *rule)
7a3dcaf6	271	{
a0377dfe	272	LTTNG_ASSERT(rule->get_filter_bytecode);
7a3dcaf6 JR	273	return rule->get_filter_bytecode(rule);
	274	}
	275
993578ff JR	276	enum lttng_event_rule_generate_exclusions_status
993578ff JR	277	lttng_event_rule_generate_exclusions(const struct lttng_event_rule *rule,
28ab034a	278	struct lttng_event_exclusion **exclusions)
7a3dcaf6	279	{
a0377dfe	280	LTTNG_ASSERT(rule->generate_exclusions);
993578ff	281	return rule->generate_exclusions(rule, exclusions);
7a3dcaf6 JR	282	}
7a3dcaf6 JR	283
28ab034a	284	struct lttng_event lttng_event_rule_generate_lttng_event(const struct lttng_event_rule rule)
44760c20	285	{
a0377dfe	286	LTTNG_ASSERT(rule->generate_lttng_event);
44760c20 JR	287	return rule->generate_lttng_event(rule);
	288	}
	289
44760c20 JR	290	bool lttng_event_rule_targets_agent_domain(const struct lttng_event_rule *rule)
	291	{
	292	bool targets_agent_domain = false;
07c4863f	293	const lttng_domain_type type = lttng_event_rule_get_domain_type(rule);
44760c20 JR	294
	295	switch (type) {
	296	case LTTNG_DOMAIN_JUL:
	297	case LTTNG_DOMAIN_LOG4J:
47abf22b	298	case LTTNG_DOMAIN_LOG4J2:
44760c20 JR	299	case LTTNG_DOMAIN_PYTHON:
	300	targets_agent_domain = true;
	301	break;
	302	case LTTNG_DOMAIN_UST:
	303	case LTTNG_DOMAIN_KERNEL:
	304	targets_agent_domain = false;
	305	break;
	306	default:
	307	abort();
	308	};
	309
	310	return targets_agent_domain;
	311	}
	312
7a3dcaf6 JR	313	const char *lttng_event_rule_type_str(enum lttng_event_rule_type type)
	314	{
	315	switch (type) {
	316	case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
	317	return "unknown";
4f7da553 JR	318	case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
4f7da553 JR	319	return "kernel syscall";
85522de5 JR	320	case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
85522de5 JR	321	return "kernel kprobe";
46fd07ac JR	322	case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
46fd07ac JR	323	return "kernel uprobe";
af0818ef JR	324	case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
af0818ef JR	325	return "kernel tracepoint";
0a23a07d JR	326	case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
0a23a07d JR	327	return "user tracepoint";
b47b01d8 JR	328	case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
b47b01d8 JR	329	return "jul logging";
138d6838 JR	330	case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
138d6838 JR	331	return "log4j logging";
47abf22b MJ	332	case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING:
47abf22b MJ	333	return "log4j2 logging";
6530ec7d JR	334	case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
	335	return "python logging";
	336
7a3dcaf6 JR	337	default:
	338	abort();
	339	}
	340	}
959e3c66	341
959e3c66 JR	342	unsigned long lttng_event_rule_hash(const struct lttng_event_rule *rule)
959e3c66 JR	343	{
a0377dfe	344	LTTNG_ASSERT(rule->hash);
959e3c66 JR	345	return rule->hash(rule);
959e3c66 JR	346	}
6a751b95	347
28ab034a JG	348	enum lttng_error_code lttng_event_rule_mi_serialize(const struct lttng_event_rule *rule,
28ab034a JG	349	struct mi_writer *writer)
6a751b95 JR	350	{
	351	int ret;
	352	enum lttng_error_code ret_code;
	353
a0377dfe FD	354	LTTNG_ASSERT(rule);
	355	LTTNG_ASSERT(writer);
	356	LTTNG_ASSERT(rule->mi_serialize);
6a751b95 JR	357
	358	/* Open event rule element. */
	359	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_rule);
	360	if (ret) {
	361	goto mi_error;
	362	}
	363
	364	/* Serialize underlying event rule. */
	365	ret_code = rule->mi_serialize(rule, writer);
	366	if (ret_code != LTTNG_OK) {
	367	goto end;
	368	}
	369
	370	/* Close event rule element. */
	371	ret = mi_lttng_writer_close_element(writer);
	372	if (ret) {
	373	goto mi_error;
	374	}
	375
	376	ret_code = LTTNG_OK;
	377	goto end;
	378
	379	mi_error:
	380	ret_code = LTTNG_ERR_MI_IO_FAIL;
	381	end:
	382	return ret_code;
	383	}