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

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

#include <assert.h>
#include <common/credentials.h>
#include <common/error.h>
#include <common/macros.h>
#include <common/payload.h>
#include <common/payload-view.h>
#include <common/runas.h>
#include <common/hashtable/hashtable.h>
#include <common/hashtable/utils.h>
#include <lttng/event-rule/event-rule-internal.h>
#include <lttng/event-rule/uprobe-internal.h>
#include <lttng/userspace-probe-internal.h>

#define IS_UPROBE_EVENT_RULE(rule) \
	(lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE)

static void lttng_event_rule_userspace_probe_destroy(struct lttng_event_rule *rule)
{
	struct lttng_event_rule_userspace_probe *uprobe;

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);

	lttng_userspace_probe_location_destroy(uprobe->location);
	free(uprobe->name);
	free(uprobe);
}

static bool lttng_event_rule_userspace_probe_validate(
		const struct lttng_event_rule *rule)
{
	bool valid = false;
	struct lttng_event_rule_userspace_probe *uprobe;

	if (!rule) {
		goto end;
	}

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);

	/* Required field. */
	if (!uprobe->name) {
		ERR("Invalid uprobe event rule: a pattern must be set.");
		goto end;
	}

	if (!uprobe->location) {
		ERR("Invalid uprobe event rule: a location must be set.");
		goto end;
	}

	valid = true;
end:
	return valid;
}

static int lttng_event_rule_userspace_probe_serialize(
		const struct lttng_event_rule *rule,
		struct lttng_payload *payload)
{
	int ret;
	size_t name_len, header_offset, size_before_probe;
	struct lttng_event_rule_userspace_probe *uprobe;
	struct lttng_event_rule_userspace_probe_comm uprobe_comm = {};
	struct lttng_event_rule_userspace_probe_comm *header;

	if (!rule || !IS_UPROBE_EVENT_RULE(rule)) {
		ret = -1;
		goto end;
	}

	header_offset = payload->buffer.size;

	DBG("Serializing uprobe event rule.");
	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);

	name_len = strlen(uprobe->name) + 1;

	uprobe_comm.name_len = name_len;

	ret = lttng_dynamic_buffer_append(
			&payload->buffer, &uprobe_comm, sizeof(uprobe_comm));
	if (ret) {
		goto end;
	}
	ret = lttng_dynamic_buffer_append(
			&payload->buffer, uprobe->name, name_len);
	if (ret) {
		goto end;
	}

	size_before_probe = payload->buffer.size;

	/* This serialize return the size taken in the buffer. */
	ret = lttng_userspace_probe_location_serialize(
			uprobe->location, payload);
	if (ret < 0) {
		goto end;
	}

	/* Update the header regarding the probe size. */
	header = (struct lttng_event_rule_userspace_probe_comm
					*) ((char *) payload->buffer.data +
			header_offset);
	header->location_len = payload->buffer.size - size_before_probe;

	ret = 0;

end:
	return ret;
}

static bool lttng_event_rule_userspace_probe_is_equal(const struct lttng_event_rule *_a,
		const struct lttng_event_rule *_b)
{
	bool is_equal = false;
	struct lttng_event_rule_userspace_probe *a, *b;

	a = container_of(_a, struct lttng_event_rule_userspace_probe, parent);
	b = container_of(_b, struct lttng_event_rule_userspace_probe, parent);

	/* uprobe is invalid if this is not true. */
	assert(a->name);
	assert(b->name);
	if (strcmp(a->name, b->name)) {
		goto end;
	}

	assert(a->location);
	assert(b->location);
	is_equal = lttng_userspace_probe_location_is_equal(
			a->location, b->location);
end:
	return is_equal;
}

static enum lttng_error_code lttng_event_rule_userspace_probe_generate_filter_bytecode(
		struct lttng_event_rule *rule,
		const struct lttng_credentials *creds)
{
	/* Nothing to do. */
	return LTTNG_OK;
}

static const char *lttng_event_rule_userspace_probe_get_filter(
		const struct lttng_event_rule *rule)
{
	/* Unsupported. */
	return NULL;
}

static const struct lttng_bytecode *
lttng_event_rule_userspace_probe_get_filter_bytecode(const struct lttng_event_rule *rule)
{
	/* Unsupported. */
	return NULL;
}

static enum lttng_event_rule_generate_exclusions_status
lttng_event_rule_userspace_probe_generate_exclusions(const struct lttng_event_rule *rule,
		struct lttng_event_exclusion **exclusions)
{
	/* Unsupported. */
	*exclusions = NULL;
	return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
}

static unsigned long
lttng_event_rule_userspace_probe_hash(
		const struct lttng_event_rule *rule)
{
	unsigned long hash;
	struct lttng_event_rule_userspace_probe *urule =
			container_of(rule, typeof(*urule), parent);

	hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE,
			lttng_ht_seed);
	hash ^= hash_key_str(urule->name, lttng_ht_seed);
	hash ^= lttng_userspace_probe_location_hash(urule->location);

	return hash;
}

struct lttng_event_rule *lttng_event_rule_userspace_probe_create(void)
{
	struct lttng_event_rule *rule = NULL;
	struct lttng_event_rule_userspace_probe *urule;

	urule = zmalloc(sizeof(struct lttng_event_rule_userspace_probe));
	if (!urule) {
		goto end;
	}

	rule = &urule->parent;
	lttng_event_rule_init(&urule->parent, LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
	urule->parent.validate = lttng_event_rule_userspace_probe_validate;
	urule->parent.serialize = lttng_event_rule_userspace_probe_serialize;
	urule->parent.equal = lttng_event_rule_userspace_probe_is_equal;
	urule->parent.destroy = lttng_event_rule_userspace_probe_destroy;
	urule->parent.generate_filter_bytecode =
			lttng_event_rule_userspace_probe_generate_filter_bytecode;
	urule->parent.get_filter = lttng_event_rule_userspace_probe_get_filter;
	urule->parent.get_filter_bytecode =
			lttng_event_rule_userspace_probe_get_filter_bytecode;
	urule->parent.generate_exclusions =
			lttng_event_rule_userspace_probe_generate_exclusions;
	urule->parent.hash = lttng_event_rule_userspace_probe_hash;

end:
	return rule;
}

LTTNG_HIDDEN
ssize_t lttng_event_rule_userspace_probe_create_from_payload(
		struct lttng_payload_view *view,
		struct lttng_event_rule **_event_rule)
{
	ssize_t ret, offset = 0;
	const struct lttng_event_rule_userspace_probe_comm *uprobe_comm;
	const char *name;
	struct lttng_buffer_view current_buffer_view;
	struct lttng_event_rule *rule = NULL;
	struct lttng_userspace_probe_location *location;
	struct lttng_event_rule_userspace_probe *uprobe;
	enum lttng_event_rule_status status;

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

	current_buffer_view = lttng_buffer_view_from_view(
			&view->buffer, offset, sizeof(*uprobe_comm));
	if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
		ERR("Failed to initialize from malformed event rule uprobe: buffer too short to contain header");
		ret = -1;
		goto end;
	}

	uprobe_comm = (typeof(uprobe_comm)) current_buffer_view.data;
	rule = lttng_event_rule_userspace_probe_create();
	if (!rule) {
		ERR("Failed to create event rule uprobe");
		ret = -1;
		goto end;
	}

	/* Skip to payload. */
	offset += current_buffer_view.size;

	/* Map the name. */
	current_buffer_view = lttng_buffer_view_from_view(
			&view->buffer, offset, uprobe_comm->name_len);
	if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
		ret = -1;
		goto end;
	}

	name = current_buffer_view.data;
	if (!lttng_buffer_view_contains_string(&current_buffer_view, name,
			uprobe_comm->name_len)) {
		ret = -1;
		goto end;
	}

	/* Skip after the name. */
	offset += uprobe_comm->name_len;

	/* Map the location. */
	{
		struct lttng_payload_view current_payload_view =
				lttng_payload_view_from_view(view, offset,
						uprobe_comm->location_len);

		if (!lttng_payload_view_is_valid(&current_payload_view)) {
			ERR("Failed to initialize from malformed event rule uprobe: buffer too short to contain location");
			ret = -1;
			goto end;
		}

		ret = lttng_userspace_probe_location_create_from_payload(
				&current_payload_view, &location);
		if (ret < 0) {
			ret = -1;
			goto end;
		}
	}

	assert(ret == uprobe_comm->location_len);

	/* Skip after the location. */
	offset += uprobe_comm->location_len;

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
	uprobe->location = location;

	status = lttng_event_rule_userspace_probe_set_name(rule, name);
	if (status != LTTNG_EVENT_RULE_STATUS_OK) {
		ret = -1;
		goto end;
	}

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

	*_event_rule = rule;
	rule = NULL;
	ret = offset;
end:
	lttng_event_rule_destroy(rule);
	return ret;
}

enum lttng_event_rule_status lttng_event_rule_userspace_probe_set_location(
		struct lttng_event_rule *rule,
		const struct lttng_userspace_probe_location *location)
{
	struct lttng_userspace_probe_location *location_copy = NULL;
	struct lttng_event_rule_userspace_probe *uprobe;
	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;

	if (!rule || !IS_UPROBE_EVENT_RULE(rule) || !location) {
		status = LTTNG_EVENT_RULE_STATUS_INVALID;
		goto end;
	}

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
	location_copy = lttng_userspace_probe_location_copy(location);
	if (!location_copy) {
		status = LTTNG_EVENT_RULE_STATUS_ERROR;
		goto end;
	}

	if (uprobe->location) {
		lttng_userspace_probe_location_destroy(uprobe->location);
	}

	uprobe->location = location_copy;
	location_copy = NULL;
end:
	lttng_userspace_probe_location_destroy(location_copy);
	return status;
}

enum lttng_event_rule_status lttng_event_rule_userspace_probe_get_location(
		const struct lttng_event_rule *rule,
		const struct lttng_userspace_probe_location **location)
{
	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;

	if (!rule || !IS_UPROBE_EVENT_RULE(rule) || !location) {
		status = LTTNG_EVENT_RULE_STATUS_INVALID;
		goto end;
	}

	*location = lttng_event_rule_userspace_probe_get_location_mutable(rule);
	if (!*location) {
		status = LTTNG_EVENT_RULE_STATUS_UNSET;
		goto end;
	}

end:
	return status;
}

LTTNG_HIDDEN
struct lttng_userspace_probe_location *
lttng_event_rule_userspace_probe_get_location_mutable(
		const struct lttng_event_rule *rule)
{
	struct lttng_event_rule_userspace_probe *uprobe;

	assert(rule);
	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);

	return uprobe->location;
}

enum lttng_event_rule_status lttng_event_rule_userspace_probe_set_name(
		struct lttng_event_rule *rule, const char *name)
{
	char *name_copy = NULL;
	struct lttng_event_rule_userspace_probe *uprobe;
	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;

	if (!rule || !IS_UPROBE_EVENT_RULE(rule) || !name ||
			strlen(name) == 0) {
		status = LTTNG_EVENT_RULE_STATUS_INVALID;
		goto end;
	}

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
	name_copy = strdup(name);
	if (!name_copy) {
		status = LTTNG_EVENT_RULE_STATUS_ERROR;
		goto end;
	}

	if (uprobe->name) {
		free(uprobe->name);
	}

	uprobe->name = name_copy;
	name_copy = NULL;
end:
	return status;
}

enum lttng_event_rule_status lttng_event_rule_userspace_probe_get_name(
		const struct lttng_event_rule *rule, const char **name)
{
	struct lttng_event_rule_userspace_probe *uprobe;
	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;

	if (!rule || !IS_UPROBE_EVENT_RULE(rule) || !name) {
		status = LTTNG_EVENT_RULE_STATUS_INVALID;
		goto end;
	}

	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
	if (!uprobe->name) {
		status = LTTNG_EVENT_RULE_STATUS_UNSET;
		goto end;
	}

	*name = uprobe->name;
end:
	return status;
}
Commit	Line	Data
df08d338 JR	1	/*
	2	* Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
	3	*
	4	* SPDX-License-Identifier: LGPL-2.1-only
	5	*
	6	*/
	7
	8	#include <assert.h>
58daac01	9	#include <common/credentials.h>
df08d338 JR	10	#include <common/error.h>
	11	#include <common/macros.h>
	12	#include <common/payload.h>
	13	#include <common/payload-view.h>
	14	#include <common/runas.h>
959e3c66 JR	15	#include <common/hashtable/hashtable.h>
959e3c66 JR	16	#include <common/hashtable/utils.h>
df08d338 JR	17	#include <lttng/event-rule/event-rule-internal.h>
	18	#include <lttng/event-rule/uprobe-internal.h>
	19	#include <lttng/userspace-probe-internal.h>
	20
	21	#define IS_UPROBE_EVENT_RULE(rule) \
1f1567a5	22	(lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE)
df08d338	23
1f1567a5	24	static void lttng_event_rule_userspace_probe_destroy(struct lttng_event_rule *rule)
df08d338	25	{
1f1567a5	26	struct lttng_event_rule_userspace_probe *uprobe;
df08d338	27
1f1567a5	28	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	29
	30	lttng_userspace_probe_location_destroy(uprobe->location);
	31	free(uprobe->name);
	32	free(uprobe);
	33	}
	34
1f1567a5	35	static bool lttng_event_rule_userspace_probe_validate(
df08d338 JR	36	const struct lttng_event_rule *rule)
	37	{
	38	bool valid = false;
1f1567a5	39	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	40
	41	if (!rule) {
	42	goto end;
	43	}
	44
1f1567a5	45	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	46
	47	/* Required field. */
	48	if (!uprobe->name) {
	49	ERR("Invalid uprobe event rule: a pattern must be set.");
	50	goto end;
	51	}
	52
	53	if (!uprobe->location) {
	54	ERR("Invalid uprobe event rule: a location must be set.");
	55	goto end;
	56	}
	57
	58	valid = true;
	59	end:
	60	return valid;
	61	}
	62
1f1567a5	63	static int lttng_event_rule_userspace_probe_serialize(
df08d338 JR	64	const struct lttng_event_rule *rule,
	65	struct lttng_payload *payload)
	66	{
	67	int ret;
	68	size_t name_len, header_offset, size_before_probe;
1f1567a5 JR	69	struct lttng_event_rule_userspace_probe *uprobe;
	70	struct lttng_event_rule_userspace_probe_comm uprobe_comm = {};
	71	struct lttng_event_rule_userspace_probe_comm *header;
df08d338 JR	72
	73	if (!rule \|\| !IS_UPROBE_EVENT_RULE(rule)) {
	74	ret = -1;
	75	goto end;
	76	}
	77
	78	header_offset = payload->buffer.size;
	79
	80	DBG("Serializing uprobe event rule.");
1f1567a5	81	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	82
	83	name_len = strlen(uprobe->name) + 1;
	84
	85	uprobe_comm.name_len = name_len;
	86
	87	ret = lttng_dynamic_buffer_append(
	88	&payload->buffer, &uprobe_comm, sizeof(uprobe_comm));
	89	if (ret) {
	90	goto end;
	91	}
	92	ret = lttng_dynamic_buffer_append(
	93	&payload->buffer, uprobe->name, name_len);
	94	if (ret) {
	95	goto end;
	96	}
	97
	98	size_before_probe = payload->buffer.size;
	99
	100	/* This serialize return the size taken in the buffer. */
	101	ret = lttng_userspace_probe_location_serialize(
	102	uprobe->location, payload);
	103	if (ret < 0) {
	104	goto end;
	105	}
	106
	107	/* Update the header regarding the probe size. */
1f1567a5	108	header = (struct lttng_event_rule_userspace_probe_comm
df08d338 JR	109	) ((char ) payload->buffer.data +
	110	header_offset);
	111	header->location_len = payload->buffer.size - size_before_probe;
	112
	113	ret = 0;
	114
	115	end:
	116	return ret;
	117	}
	118
1f1567a5	119	static bool lttng_event_rule_userspace_probe_is_equal(const struct lttng_event_rule *_a,
df08d338 JR	120	const struct lttng_event_rule *_b)
	121	{
	122	bool is_equal = false;
1f1567a5	123	struct lttng_event_rule_userspace_probe a, b;
df08d338	124
1f1567a5 JR	125	a = container_of(_a, struct lttng_event_rule_userspace_probe, parent);
1f1567a5 JR	126	b = container_of(_b, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	127
	128	/* uprobe is invalid if this is not true. */
	129	assert(a->name);
	130	assert(b->name);
	131	if (strcmp(a->name, b->name)) {
	132	goto end;
	133	}
	134
	135	assert(a->location);
	136	assert(b->location);
	137	is_equal = lttng_userspace_probe_location_is_equal(
	138	a->location, b->location);
	139	end:
	140	return is_equal;
	141	}
	142
1f1567a5	143	static enum lttng_error_code lttng_event_rule_userspace_probe_generate_filter_bytecode(
58daac01 JR	144	struct lttng_event_rule *rule,
58daac01 JR	145	const struct lttng_credentials *creds)
df08d338 JR	146	{
	147	/* Nothing to do. */
	148	return LTTNG_OK;
	149	}
	150
1f1567a5	151	static const char *lttng_event_rule_userspace_probe_get_filter(
df08d338 JR	152	const struct lttng_event_rule *rule)
	153	{
	154	/* Unsupported. */
	155	return NULL;
	156	}
	157
2b00d462	158	static const struct lttng_bytecode *
1f1567a5	159	lttng_event_rule_userspace_probe_get_filter_bytecode(const struct lttng_event_rule *rule)
df08d338 JR	160	{
	161	/* Unsupported. */
	162	return NULL;
	163	}
	164
993578ff	165	static enum lttng_event_rule_generate_exclusions_status
1f1567a5	166	lttng_event_rule_userspace_probe_generate_exclusions(const struct lttng_event_rule *rule,
993578ff	167	struct lttng_event_exclusion **exclusions)
df08d338 JR	168	{
df08d338 JR	169	/* Unsupported. */
993578ff JR	170	*exclusions = NULL;
993578ff JR	171	return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
df08d338 JR	172	}
df08d338 JR	173
959e3c66	174	static unsigned long
1f1567a5	175	lttng_event_rule_userspace_probe_hash(
959e3c66 JR	176	const struct lttng_event_rule *rule)
	177	{
	178	unsigned long hash;
1f1567a5	179	struct lttng_event_rule_userspace_probe *urule =
959e3c66 JR	180	container_of(rule, typeof(*urule), parent);
959e3c66 JR	181
1f1567a5	182	hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE,
959e3c66 JR	183	lttng_ht_seed);
	184	hash ^= hash_key_str(urule->name, lttng_ht_seed);
	185	hash ^= lttng_userspace_probe_location_hash(urule->location);
	186
	187	return hash;
	188	}
	189
1f1567a5	190	struct lttng_event_rule *lttng_event_rule_userspace_probe_create(void)
df08d338 JR	191	{
df08d338 JR	192	struct lttng_event_rule *rule = NULL;
1f1567a5	193	struct lttng_event_rule_userspace_probe *urule;
df08d338	194
1f1567a5	195	urule = zmalloc(sizeof(struct lttng_event_rule_userspace_probe));
df08d338 JR	196	if (!urule) {
	197	goto end;
	198	}
	199
	200	rule = &urule->parent;
1f1567a5 JR	201	lttng_event_rule_init(&urule->parent, LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
	202	urule->parent.validate = lttng_event_rule_userspace_probe_validate;
	203	urule->parent.serialize = lttng_event_rule_userspace_probe_serialize;
	204	urule->parent.equal = lttng_event_rule_userspace_probe_is_equal;
	205	urule->parent.destroy = lttng_event_rule_userspace_probe_destroy;
df08d338	206	urule->parent.generate_filter_bytecode =
1f1567a5 JR	207	lttng_event_rule_userspace_probe_generate_filter_bytecode;
1f1567a5 JR	208	urule->parent.get_filter = lttng_event_rule_userspace_probe_get_filter;
df08d338	209	urule->parent.get_filter_bytecode =
1f1567a5	210	lttng_event_rule_userspace_probe_get_filter_bytecode;
df08d338	211	urule->parent.generate_exclusions =
1f1567a5 JR	212	lttng_event_rule_userspace_probe_generate_exclusions;
	213	urule->parent.hash = lttng_event_rule_userspace_probe_hash;
	214
df08d338 JR	215	end:
	216	return rule;
	217	}
	218
	219	LTTNG_HIDDEN
1f1567a5	220	ssize_t lttng_event_rule_userspace_probe_create_from_payload(
df08d338 JR	221	struct lttng_payload_view *view,
	222	struct lttng_event_rule **_event_rule)
	223	{
	224	ssize_t ret, offset = 0;
1f1567a5	225	const struct lttng_event_rule_userspace_probe_comm *uprobe_comm;
df08d338 JR	226	const char *name;
	227	struct lttng_buffer_view current_buffer_view;
	228	struct lttng_event_rule *rule = NULL;
	229	struct lttng_userspace_probe_location *location;
1f1567a5	230	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	231	enum lttng_event_rule_status status;
	232
	233	if (!_event_rule) {
	234	ret = -1;
	235	goto end;
	236	}
	237
df08d338 JR	238	current_buffer_view = lttng_buffer_view_from_view(
df08d338 JR	239	&view->buffer, offset, sizeof(*uprobe_comm));
3e6e0df2 JG	240	if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
3e6e0df2 JG	241	ERR("Failed to initialize from malformed event rule uprobe: buffer too short to contain header");
df08d338 JR	242	ret = -1;
	243	goto end;
	244	}
	245
3e6e0df2	246	uprobe_comm = (typeof(uprobe_comm)) current_buffer_view.data;
1f1567a5	247	rule = lttng_event_rule_userspace_probe_create();
df08d338	248	if (!rule) {
3e6e0df2	249	ERR("Failed to create event rule uprobe");
df08d338 JR	250	ret = -1;
	251	goto end;
	252	}
	253
	254	/* Skip to payload. */
	255	offset += current_buffer_view.size;
	256
	257	/* Map the name. */
	258	current_buffer_view = lttng_buffer_view_from_view(
	259	&view->buffer, offset, uprobe_comm->name_len);
3e6e0df2	260	if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
df08d338 JR	261	ret = -1;
	262	goto end;
	263	}
	264
3e6e0df2	265	name = current_buffer_view.data;
df08d338 JR	266	if (!lttng_buffer_view_contains_string(&current_buffer_view, name,
	267	uprobe_comm->name_len)) {
	268	ret = -1;
	269	goto end;
	270	}
	271
	272	/* Skip after the name. */
	273	offset += uprobe_comm->name_len;
	274
	275	/* Map the location. */
3e6e0df2 JG	276	{
	277	struct lttng_payload_view current_payload_view =
	278	lttng_payload_view_from_view(view, offset,
	279	uprobe_comm->location_len);
	280
	281	if (!lttng_payload_view_is_valid(&current_payload_view)) {
	282	ERR("Failed to initialize from malformed event rule uprobe: buffer too short to contain location");
	283	ret = -1;
	284	goto end;
	285	}
	286
	287	ret = lttng_userspace_probe_location_create_from_payload(
	288	&current_payload_view, &location);
	289	if (ret < 0) {
	290	ret = -1;
	291	goto end;
	292	}
df08d338 JR	293	}
	294
	295	assert(ret == uprobe_comm->location_len);
	296
	297	/* Skip after the location. */
	298	offset += uprobe_comm->location_len;
	299
1f1567a5	300	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	301	uprobe->location = location;
df08d338 JR	302
1f1567a5	303	status = lttng_event_rule_userspace_probe_set_name(rule, name);
df08d338 JR	304	if (status != LTTNG_EVENT_RULE_STATUS_OK) {
	305	ret = -1;
	306	goto end;
	307	}
	308
1f1567a5	309	if (!lttng_event_rule_userspace_probe_validate(rule)) {
df08d338 JR	310	ret = -1;
	311	goto end;
	312	}
	313
	314	*_event_rule = rule;
	315	rule = NULL;
	316	ret = offset;
	317	end:
	318	lttng_event_rule_destroy(rule);
	319	return ret;
	320	}
	321
1f1567a5	322	enum lttng_event_rule_status lttng_event_rule_userspace_probe_set_location(
df08d338 JR	323	struct lttng_event_rule *rule,
	324	const struct lttng_userspace_probe_location *location)
	325	{
	326	struct lttng_userspace_probe_location *location_copy = NULL;
1f1567a5	327	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	328	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
	329
	330	if (!rule \|\| !IS_UPROBE_EVENT_RULE(rule) \|\| !location) {
	331	status = LTTNG_EVENT_RULE_STATUS_INVALID;
	332	goto end;
	333	}
	334
1f1567a5	335	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	336	location_copy = lttng_userspace_probe_location_copy(location);
	337	if (!location_copy) {
	338	status = LTTNG_EVENT_RULE_STATUS_ERROR;
	339	goto end;
	340	}
	341
	342	if (uprobe->location) {
	343	lttng_userspace_probe_location_destroy(uprobe->location);
	344	}
	345
	346	uprobe->location = location_copy;
	347	location_copy = NULL;
	348	end:
	349	lttng_userspace_probe_location_destroy(location_copy);
	350	return status;
	351	}
	352
1f1567a5	353	enum lttng_event_rule_status lttng_event_rule_userspace_probe_get_location(
df08d338 JR	354	const struct lttng_event_rule *rule,
	355	const struct lttng_userspace_probe_location **location)
	356	{
	357	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
	358
	359	if (!rule \|\| !IS_UPROBE_EVENT_RULE(rule) \|\| !location) {
	360	status = LTTNG_EVENT_RULE_STATUS_INVALID;
	361	goto end;
	362	}
	363
1f1567a5	364	*location = lttng_event_rule_userspace_probe_get_location_mutable(rule);
df08d338 JR	365	if (!*location) {
	366	status = LTTNG_EVENT_RULE_STATUS_UNSET;
	367	goto end;
	368	}
	369
	370	end:
	371	return status;
	372	}
	373
	374	LTTNG_HIDDEN
	375	struct lttng_userspace_probe_location *
1f1567a5	376	lttng_event_rule_userspace_probe_get_location_mutable(
df08d338 JR	377	const struct lttng_event_rule *rule)
df08d338 JR	378	{
1f1567a5	379	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	380
df08d338 JR	381	assert(rule);
1f1567a5	382	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	383
	384	return uprobe->location;
	385	}
	386
1f1567a5	387	enum lttng_event_rule_status lttng_event_rule_userspace_probe_set_name(
df08d338 JR	388	struct lttng_event_rule rule, const char name)
	389	{
	390	char *name_copy = NULL;
1f1567a5	391	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	392	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
	393
	394	if (!rule \|\| !IS_UPROBE_EVENT_RULE(rule) \|\| !name \|\|
	395	strlen(name) == 0) {
	396	status = LTTNG_EVENT_RULE_STATUS_INVALID;
	397	goto end;
	398	}
	399
1f1567a5	400	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	401	name_copy = strdup(name);
	402	if (!name_copy) {
	403	status = LTTNG_EVENT_RULE_STATUS_ERROR;
	404	goto end;
	405	}
	406
	407	if (uprobe->name) {
	408	free(uprobe->name);
	409	}
	410
	411	uprobe->name = name_copy;
	412	name_copy = NULL;
	413	end:
	414	return status;
	415	}
	416
1f1567a5	417	enum lttng_event_rule_status lttng_event_rule_userspace_probe_get_name(
df08d338 JR	418	const struct lttng_event_rule rule, const char *name)
df08d338 JR	419	{
1f1567a5	420	struct lttng_event_rule_userspace_probe *uprobe;
df08d338 JR	421	enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
	422
	423	if (!rule \|\| !IS_UPROBE_EVENT_RULE(rule) \|\| !name) {
	424	status = LTTNG_EVENT_RULE_STATUS_INVALID;
	425	goto end;
	426	}
	427
1f1567a5	428	uprobe = container_of(rule, struct lttng_event_rule_userspace_probe, parent);
df08d338 JR	429	if (!uprobe->name) {
	430	status = LTTNG_EVENT_RULE_STATUS_UNSET;
	431	goto end;
	432	}
	433
	434	*name = uprobe->name;
	435	end:
	436	return status;
	437	}