event-rule: userspace probe: rename get/set_name to get/set_event_name
[lttng-tools.git] / src / common / event-rule / userspace-probe.c
CommitLineData
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>
16#include <common/hashtable/utils.h>
df08d338 17#include <lttng/event-rule/event-rule-internal.h>
e957bf98 18#include <lttng/event-rule/userspace-probe-internal.h>
df08d338
JR
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 24static 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 35static 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;
59end:
60 return valid;
61}
62
1f1567a5 63static 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
115end:
116 return ret;
117}
118
1f1567a5 119static 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);
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);
139end:
140 return is_equal;
141}
142
1f1567a5 143static enum lttng_error_code lttng_event_rule_userspace_probe_generate_filter_bytecode(
58daac01
JR
144 struct lttng_event_rule *rule,
145 const struct lttng_credentials *creds)
df08d338
JR
146{
147 /* Nothing to do. */
148 return LTTNG_OK;
149}
150
1f1567a5 151static 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 158static const struct lttng_bytecode *
1f1567a5 159lttng_event_rule_userspace_probe_get_filter_bytecode(const struct lttng_event_rule *rule)
df08d338
JR
160{
161 /* Unsupported. */
162 return NULL;
163}
164
993578ff 165static enum lttng_event_rule_generate_exclusions_status
1f1567a5 166lttng_event_rule_userspace_probe_generate_exclusions(const struct lttng_event_rule *rule,
993578ff 167 struct lttng_event_exclusion **exclusions)
df08d338
JR
168{
169 /* Unsupported. */
993578ff
JR
170 *exclusions = NULL;
171 return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
df08d338
JR
172}
173
959e3c66 174static unsigned long
1f1567a5 175lttng_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);
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 190struct lttng_event_rule *lttng_event_rule_userspace_probe_create(void)
df08d338
JR
191{
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;
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
215end:
216 return rule;
217}
218
219LTTNG_HIDDEN
1f1567a5 220ssize_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(
239 &view->buffer, offset, sizeof(*uprobe_comm));
3e6e0df2
JG
240 if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
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;
302
405f9e7d 303 status = lttng_event_rule_userspace_probe_set_event_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;
317end:
318 lttng_event_rule_destroy(rule);
319 return ret;
320}
321
1f1567a5 322enum 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;
348end:
349 lttng_userspace_probe_location_destroy(location_copy);
350 return status;
351}
352
1f1567a5 353enum 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
370end:
371 return status;
372}
373
374LTTNG_HIDDEN
375struct lttng_userspace_probe_location *
1f1567a5 376lttng_event_rule_userspace_probe_get_location_mutable(
df08d338
JR
377 const struct lttng_event_rule *rule)
378{
1f1567a5 379 struct lttng_event_rule_userspace_probe *uprobe;
df08d338
JR
380
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
405f9e7d 387enum lttng_event_rule_status lttng_event_rule_userspace_probe_set_event_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;
413end:
414 return status;
415}
416
405f9e7d 417enum lttng_event_rule_status lttng_event_rule_userspace_probe_get_event_name(
df08d338
JR
418 const struct lttng_event_rule *rule, const char **name)
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;
435end:
436 return status;
437}
This page took 0.064962 seconds and 4 git commands to generate.