[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/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, uid_t uid, gid_t gid)
{
	/* 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;
	}

	if (view->buffer.size < sizeof(*uprobe_comm)) {
		ERR("Failed to initialize from malformed event rule uprobe: buffer too short to contain header.");
		ret = -1;
		goto end;
	}

	current_buffer_view = lttng_buffer_view_from_view(
			&view->buffer, offset, sizeof(*uprobe_comm));
	uprobe_comm = (typeof(uprobe_comm)) current_buffer_view.data;

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

	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);
	name = current_buffer_view.data;
	if (!name) {
		ret = -1;
		goto end;
	}

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