[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 <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_UPROBE)

static void lttng_event_rule_uprobe_destroy(struct lttng_event_rule *rule)
{
	struct lttng_event_rule_uprobe *uprobe;

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

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

static bool lttng_event_rule_uprobe_validate(
		const struct lttng_event_rule *rule)
{
	bool valid = false;
	struct lttng_event_rule_uprobe *uprobe;

	if (!rule) {
		goto end;
	}

	uprobe = container_of(rule, struct lttng_event_rule_uprobe, 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_uprobe_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_uprobe *uprobe;
	struct lttng_event_rule_uprobe_comm uprobe_comm = {};
	struct lttng_event_rule_uprobe_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_uprobe, 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_uprobe_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_uprobe_is_equal(const struct lttng_event_rule *_a,
		const struct lttng_event_rule *_b)
{
	bool is_equal = false;
	struct lttng_event_rule_uprobe *a, *b;

	a = container_of(_a, struct lttng_event_rule_uprobe, parent);
	b = container_of(_b, struct lttng_event_rule_uprobe, 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_uprobe_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_uprobe_get_filter(
		const struct lttng_event_rule *rule)
{
	/* Unsupported. */
	return NULL;
}

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

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

struct lttng_event_rule *lttng_event_rule_uprobe_create()
{
	struct lttng_event_rule *rule = NULL;
	struct lttng_event_rule_uprobe *urule;

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

	rule = &urule->parent;
	lttng_event_rule_init(&urule->parent, LTTNG_EVENT_RULE_TYPE_UPROBE);
	urule->parent.validate = lttng_event_rule_uprobe_validate;
	urule->parent.serialize = lttng_event_rule_uprobe_serialize;
	urule->parent.equal = lttng_event_rule_uprobe_is_equal;
	urule->parent.destroy = lttng_event_rule_uprobe_destroy;
	urule->parent.generate_filter_bytecode =
			lttng_event_rule_uprobe_generate_filter_bytecode;
	urule->parent.get_filter = lttng_event_rule_uprobe_get_filter;
	urule->parent.get_filter_bytecode =
			lttng_event_rule_uprobe_get_filter_bytecode;
	urule->parent.generate_exclusions =
			lttng_event_rule_uprobe_generate_exclusions;
end:
	return rule;
}

LTTNG_HIDDEN
ssize_t lttng_event_rule_uprobe_create_from_payload(
		struct lttng_payload_view *view,
		struct lttng_event_rule **_event_rule)
{
	ssize_t ret, offset = 0;
	const struct lttng_event_rule_uprobe_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_uprobe *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_uprobe_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_uprobe, parent);
	uprobe->location = location;

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

	if (!lttng_event_rule_uprobe_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_uprobe_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_uprobe *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_uprobe, 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_uprobe_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_uprobe_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_uprobe_get_location_mutable(
		const struct lttng_event_rule *rule)
{
	struct lttng_event_rule_uprobe *uprobe;

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

	return uprobe->location;
}

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