Cleanup: namespace 'align' macros
[lttng-tools.git] / src / common / userspace-probe.c
CommitLineData
1ce46cfe 1/*
ab5be9fa 2 * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
1ce46cfe 3 *
ab5be9fa 4 * SPDX-License-Identifier: LGPL-2.1-only
1ce46cfe 5 *
1ce46cfe
JG
6 */
7
e368fb43 8#include "lttng/lttng-error.h"
dfcfa983 9#include <common/compat/string.h>
1cbd136b 10#include <common/align.h>
1ce46cfe 11#include <common/error.h>
959e3c66
JR
12#include <common/hashtable/hashtable.h>
13#include <common/hashtable/utils.h>
6a751b95
JR
14#include <common/macros.h>
15#include <common/mi-lttng.h>
16#include <common/payload-view.h>
17#include <common/payload.h>
1ce46cfe
JG
18#include <fcntl.h>
19#include <lttng/constant.h>
20#include <lttng/userspace-probe-internal.h>
dfcfa983
JR
21#include <sys/stat.h>
22#include <sys/types.h>
23#include <sys/unistd.h>
1ce46cfe 24
fe489250 25static
2cde0510 26int lttng_userspace_probe_location_function_set_binary_fd_handle(
fe489250 27 struct lttng_userspace_probe_location *location,
2cde0510 28 struct fd_handle *binary_fd_handle);
fe489250
JG
29
30static
2cde0510 31int lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(
fe489250 32 struct lttng_userspace_probe_location *location,
2cde0510 33 struct fd_handle *binary_fd_handle);
fe489250 34
6a751b95
JR
35static
36enum lttng_error_code lttng_userspace_probe_location_lookup_method_mi_serialize(
37 const struct lttng_userspace_probe_location_lookup_method
38 *method,
39 struct mi_writer *writer);
40
41static
42enum lttng_error_code lttng_userspace_probe_location_tracepoint_mi_serialize(
43 const struct lttng_userspace_probe_location *location,
44 struct mi_writer *writer);
45
46static
47enum lttng_error_code lttng_userspace_probe_location_function_mi_serialize(
48 const struct lttng_userspace_probe_location *location,
49 struct mi_writer *writer);
50
1ce46cfe
JG
51enum lttng_userspace_probe_location_lookup_method_type
52lttng_userspace_probe_location_lookup_method_get_type(
53 const struct lttng_userspace_probe_location_lookup_method *lookup_method)
54{
55 return lookup_method ? lookup_method->type :
56 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_UNKNOWN;
57}
58
59void lttng_userspace_probe_location_lookup_method_destroy(
60 struct lttng_userspace_probe_location_lookup_method *lookup_method)
61{
62 if (!lookup_method){
63 return;
64 }
65
5d21f143 66 free(lookup_method);
1ce46cfe
JG
67}
68
69struct lttng_userspace_probe_location_lookup_method *
70lttng_userspace_probe_location_lookup_method_function_elf_create(void)
71{
72 struct lttng_userspace_probe_location_lookup_method *ret = NULL;
73 struct lttng_userspace_probe_location_lookup_method_elf *elf_method;
74
75 elf_method = zmalloc(sizeof(*elf_method));
76 if (!elf_method) {
77 PERROR("zmalloc");
78 goto end;
79 }
80
81 ret = &elf_method->parent;
82 ret->type = LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF;
83end:
84 return ret;
85}
86
f4d0bb2e
FD
87struct lttng_userspace_probe_location_lookup_method *
88lttng_userspace_probe_location_lookup_method_tracepoint_sdt_create(void)
89{
90 struct lttng_userspace_probe_location_lookup_method *ret = NULL;
91 struct lttng_userspace_probe_location_lookup_method_sdt *sdt_method;
92
93 sdt_method = zmalloc(sizeof(*sdt_method));
94 if (!sdt_method) {
95 PERROR("zmalloc");
96 goto end;
97 }
98
99 ret = &sdt_method->parent;
100 ret->type = LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT;
101end:
102 return ret;
103}
104
1ce46cfe
JG
105enum lttng_userspace_probe_location_type lttng_userspace_probe_location_get_type(
106 const struct lttng_userspace_probe_location *location)
107{
108 return location ? location->type :
109 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN;
110}
111
112static
113void lttng_userspace_probe_location_function_destroy(
114 struct lttng_userspace_probe_location *location)
115{
116 struct lttng_userspace_probe_location_function *location_function = NULL;
117
a0377dfe 118 LTTNG_ASSERT(location);
1ce46cfe
JG
119
120 location_function = container_of(location,
121 struct lttng_userspace_probe_location_function, parent);
122
a0377dfe 123 LTTNG_ASSERT(location_function);
1ce46cfe
JG
124
125 free(location_function->function_name);
126 free(location_function->binary_path);
2cde0510 127 fd_handle_put(location_function->binary_fd_handle);
1ce46cfe
JG
128 free(location);
129}
130
f4d0bb2e
FD
131static
132void lttng_userspace_probe_location_tracepoint_destroy(
133 struct lttng_userspace_probe_location *location)
134{
135 struct lttng_userspace_probe_location_tracepoint *location_tracepoint = NULL;
136
a0377dfe 137 LTTNG_ASSERT(location);
f4d0bb2e
FD
138
139 location_tracepoint = container_of(location,
140 struct lttng_userspace_probe_location_tracepoint,
141 parent);
142
a0377dfe 143 LTTNG_ASSERT(location_tracepoint);
f4d0bb2e
FD
144
145 free(location_tracepoint->probe_name);
146 free(location_tracepoint->provider_name);
147 free(location_tracepoint->binary_path);
2cde0510 148 fd_handle_put(location_tracepoint->binary_fd_handle);
f4d0bb2e
FD
149 free(location);
150}
151
1ce46cfe
JG
152void lttng_userspace_probe_location_destroy(
153 struct lttng_userspace_probe_location *location)
154{
155 if (!location) {
156 return;
157 }
158
159 lttng_userspace_probe_location_lookup_method_destroy(
160 location->lookup_method);
161
162 switch (location->type) {
163 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
164 lttng_userspace_probe_location_function_destroy(location);
165 break;
f4d0bb2e
FD
166 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
167 lttng_userspace_probe_location_tracepoint_destroy(location);
168 break;
1ce46cfe 169 default:
adf53c67 170 abort();
1ce46cfe
JG
171 }
172}
173
dfcfa983
JR
174/* Compare two file descriptors based on their inode and device numbers. */
175static bool fd_is_equal(int a, int b)
176{
177 int ret;
178 bool is_equal = false;
179 struct stat a_stat, b_stat;
180
181 if (a < 0 && b >= 0) {
182 goto end;
183 }
184
185 if (b < 0 && a >= 0) {
186 goto end;
187 }
188
189 if (a < 0 && b < 0) {
190 if (a == -1 && b == -1) {
191 is_equal = true;
192 goto end;
193 }
194
195 /* Invalid state, abort. */
196 abort();
197 }
198
199 /* Both are valid file descriptors. */
200 ret = fstat(a, &a_stat);
201 if (ret) {
202 PERROR("Failed to fstat userspace probe location binary fd %d",
203 a);
204 goto end;
205 }
206
207 ret = fstat(b, &b_stat);
208 if (ret) {
209 PERROR("Failed to fstat userspace probe location binary fd %d",
210 b);
211 goto end;
212 }
213
214 is_equal = (a_stat.st_ino == b_stat.st_ino) &&
215 (a_stat.st_dev == b_stat.st_dev);
216
217end:
218 return is_equal;
219}
220
959e3c66
JR
221static unsigned long lttng_userspace_probe_location_function_hash(
222 const struct lttng_userspace_probe_location *location)
223{
224 unsigned long hash = hash_key_ulong(
225 (void *) LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION,
226 lttng_ht_seed);
227 struct lttng_userspace_probe_location_function *function_location =
228 container_of(location, typeof(*function_location),
229 parent);
230
231 hash ^= hash_key_str(function_location->function_name, lttng_ht_seed);
232 hash ^= hash_key_str(function_location->binary_path, lttng_ht_seed);
233 /*
234 * No need to hash on the fd. Worst comes to worse,
235 * the equal function will discriminate.
236 */
237 return hash;
238}
239
dfcfa983
JR
240static bool lttng_userspace_probe_location_function_is_equal(
241 const struct lttng_userspace_probe_location *_a,
242 const struct lttng_userspace_probe_location *_b)
243{
244 bool is_equal = false;
245 struct lttng_userspace_probe_location_function *a, *b;
246
247 a = container_of(_a, struct lttng_userspace_probe_location_function,
248 parent);
249 b = container_of(_b, struct lttng_userspace_probe_location_function,
250 parent);
251
252 if (a->instrumentation_type != b->instrumentation_type) {
253 goto end;
254 }
255
a0377dfe
FD
256 LTTNG_ASSERT(a->function_name);
257 LTTNG_ASSERT(b->function_name);
dfcfa983
JR
258 if (strcmp(a->function_name, b->function_name)) {
259 goto end;
260 }
261
a0377dfe
FD
262 LTTNG_ASSERT(a->binary_path);
263 LTTNG_ASSERT(b->binary_path);
dfcfa983
JR
264 if (strcmp(a->binary_path, b->binary_path)) {
265 goto end;
266 }
267
2cde0510
JG
268 is_equal = fd_is_equal(a->binary_fd_handle ? fd_handle_get_fd(a->binary_fd_handle) : -1,
269 b->binary_fd_handle ? fd_handle_get_fd(b->binary_fd_handle) : -1);
dfcfa983
JR
270end:
271 return is_equal;
272}
273
1ce46cfe
JG
274static struct lttng_userspace_probe_location *
275lttng_userspace_probe_location_function_create_no_check(const char *binary_path,
276 const char *function_name,
277 struct lttng_userspace_probe_location_lookup_method *lookup_method,
278 bool open_binary)
279{
280 int binary_fd = -1;
fe489250 281 struct fd_handle *binary_fd_handle = NULL;
1ce46cfe
JG
282 char *function_name_copy = NULL, *binary_path_copy = NULL;
283 struct lttng_userspace_probe_location *ret = NULL;
284 struct lttng_userspace_probe_location_function *location;
285
286 if (open_binary) {
287 binary_fd = open(binary_path, O_RDONLY);
288 if (binary_fd < 0) {
289 PERROR("Error opening the binary");
290 goto error;
291 }
fe489250
JG
292
293 binary_fd_handle = fd_handle_create(binary_fd);
294 if (!binary_fd) {
295 goto error;
296 }
297
298 /* Ownership transferred to fd_handle. */
1ce46cfe
JG
299 binary_fd = -1;
300 }
301
302 function_name_copy = lttng_strndup(function_name, LTTNG_SYMBOL_NAME_LEN);
303 if (!function_name_copy) {
304 PERROR("Error duplicating the function name");
305 goto error;
306 }
307
308 binary_path_copy = lttng_strndup(binary_path, LTTNG_PATH_MAX);
309 if (!binary_path_copy) {
310 PERROR("Error duplicating the function name");
311 goto error;
312 }
313
314 location = zmalloc(sizeof(*location));
315 if (!location) {
316 PERROR("Error allocating userspace probe location");
317 goto error;
318 }
319
320 location->function_name = function_name_copy;
321 location->binary_path = binary_path_copy;
2cde0510 322 location->binary_fd_handle = binary_fd_handle;
fe489250 323 binary_fd_handle = NULL;
9d3981b5
JG
324 location->instrumentation_type =
325 LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_ENTRY;
1ce46cfe
JG
326
327 ret = &location->parent;
328 ret->lookup_method = lookup_method;
329 ret->type = LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION;
dfcfa983 330 ret->equal = lttng_userspace_probe_location_function_is_equal;
959e3c66 331 ret->hash = lttng_userspace_probe_location_function_hash;
1ce46cfe
JG
332 goto end;
333
334error:
335 free(function_name_copy);
336 free(binary_path_copy);
337 if (binary_fd >= 0) {
338 if (close(binary_fd)) {
339 PERROR("Error closing binary fd in error path");
340 }
341 }
fe489250 342 fd_handle_put(binary_fd_handle);
1ce46cfe
JG
343end:
344 return ret;
345}
346
959e3c66
JR
347static unsigned long lttng_userspace_probe_location_tracepoint_hash(
348 const struct lttng_userspace_probe_location *location)
349{
350 unsigned long hash = hash_key_ulong(
351 (void *) LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT,
352 lttng_ht_seed);
353 struct lttng_userspace_probe_location_tracepoint *tp_location =
354 container_of(location, typeof(*tp_location), parent);
355
356 hash ^= hash_key_str(tp_location->probe_name, lttng_ht_seed);
357 hash ^= hash_key_str(tp_location->provider_name, lttng_ht_seed);
358 hash ^= hash_key_str(tp_location->binary_path, lttng_ht_seed);
359 /*
360 * No need to hash on the fd. Worst comes to worse,
361 * the equal function will discriminate.
362 */
363 return hash;
364}
365
dfcfa983
JR
366static bool lttng_userspace_probe_location_tracepoint_is_equal(
367 const struct lttng_userspace_probe_location *_a,
368 const struct lttng_userspace_probe_location *_b)
369{
370 bool is_equal = false;
371 struct lttng_userspace_probe_location_tracepoint *a, *b;
372
373 a = container_of(_a, struct lttng_userspace_probe_location_tracepoint,
374 parent);
375 b = container_of(_b, struct lttng_userspace_probe_location_tracepoint,
376 parent);
377
a0377dfe
FD
378 LTTNG_ASSERT(a->probe_name);
379 LTTNG_ASSERT(b->probe_name);
dfcfa983
JR
380 if (strcmp(a->probe_name, b->probe_name)) {
381 goto end;
382 }
383
a0377dfe
FD
384 LTTNG_ASSERT(a->provider_name);
385 LTTNG_ASSERT(b->provider_name);
dfcfa983
JR
386 if (strcmp(a->provider_name, b->provider_name)) {
387 goto end;
388 }
389
a0377dfe
FD
390 LTTNG_ASSERT(a->binary_path);
391 LTTNG_ASSERT(b->binary_path);
dfcfa983
JR
392 if (strcmp(a->binary_path, b->binary_path)) {
393 goto end;
394 }
395
2cde0510
JG
396 is_equal = fd_is_equal(a->binary_fd_handle ? fd_handle_get_fd(a->binary_fd_handle) : -1,
397 b->binary_fd_handle ? fd_handle_get_fd(b->binary_fd_handle) : -1);
dfcfa983
JR
398
399end:
400 return is_equal;
401}
402
f4d0bb2e
FD
403static struct lttng_userspace_probe_location *
404lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_path,
405 const char *provider_name, const char *probe_name,
406 struct lttng_userspace_probe_location_lookup_method *lookup_method,
407 bool open_binary)
408{
409 int binary_fd = -1;
fe489250 410 struct fd_handle *binary_fd_handle = NULL;
f4d0bb2e
FD
411 char *probe_name_copy = NULL;
412 char *provider_name_copy = NULL;
413 char *binary_path_copy = NULL;
414 struct lttng_userspace_probe_location *ret = NULL;
415 struct lttng_userspace_probe_location_tracepoint *location;
416
417 if (open_binary) {
418 binary_fd = open(binary_path, O_RDONLY);
419 if (binary_fd < 0) {
420 PERROR("open");
421 goto error;
422 }
fe489250
JG
423
424 binary_fd_handle = fd_handle_create(binary_fd);
425 if (!binary_fd) {
426 goto error;
427 }
428
429 /* Ownership transferred to fd_handle. */
f4d0bb2e
FD
430 binary_fd = -1;
431 }
432
433 probe_name_copy = lttng_strndup(probe_name, LTTNG_SYMBOL_NAME_LEN);
434 if (!probe_name_copy) {
435 PERROR("lttng_strndup");
436 goto error;
437 }
438
439 provider_name_copy = lttng_strndup(provider_name, LTTNG_SYMBOL_NAME_LEN);
440 if (!provider_name_copy) {
441 PERROR("lttng_strndup");
442 goto error;
443 }
444
445 binary_path_copy = lttng_strndup(binary_path, LTTNG_PATH_MAX);
446 if (!binary_path_copy) {
447 PERROR("lttng_strndup");
448 goto error;
449 }
450
451 location = zmalloc(sizeof(*location));
452 if (!location) {
453 PERROR("zmalloc");
454 goto error;
455 }
456
457 location->probe_name = probe_name_copy;
458 location->provider_name = provider_name_copy;
459 location->binary_path = binary_path_copy;
2cde0510 460 location->binary_fd_handle = binary_fd_handle;
fe489250 461 binary_fd_handle = NULL;
f4d0bb2e
FD
462
463 ret = &location->parent;
464 ret->lookup_method = lookup_method;
465 ret->type = LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT;
dfcfa983 466 ret->equal = lttng_userspace_probe_location_tracepoint_is_equal;
959e3c66 467 ret->hash = lttng_userspace_probe_location_tracepoint_hash;
f4d0bb2e
FD
468 goto end;
469
470error:
471 free(probe_name_copy);
472 free(provider_name_copy);
7c86453b 473 free(binary_path_copy);
f4d0bb2e
FD
474 if (binary_fd >= 0) {
475 if (close(binary_fd)) {
476 PERROR("Error closing binary fd in error path");
477 }
478 }
fe489250 479 fd_handle_put(binary_fd_handle);
f4d0bb2e
FD
480end:
481 return ret;
482}
483
1ce46cfe
JG
484struct lttng_userspace_probe_location *
485lttng_userspace_probe_location_function_create(const char *binary_path,
486 const char *function_name,
487 struct lttng_userspace_probe_location_lookup_method *lookup_method)
488{
489 struct lttng_userspace_probe_location *ret = NULL;
490
491 if (!binary_path || !function_name) {
f04a8200 492 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
493 goto end;
494 }
495
496 switch (lttng_userspace_probe_location_lookup_method_get_type(
497 lookup_method)) {
498 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
499 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
500 break;
501 default:
502 /* Invalid probe location lookup method. */
503 goto end;
504 }
505
506 ret = lttng_userspace_probe_location_function_create_no_check(
507 binary_path, function_name, lookup_method, true);
508end:
509 return ret;
510}
511
f4d0bb2e
FD
512struct lttng_userspace_probe_location *
513lttng_userspace_probe_location_tracepoint_create(const char *binary_path,
514 const char *provider_name, const char *probe_name,
515 struct lttng_userspace_probe_location_lookup_method *lookup_method)
516{
517 struct lttng_userspace_probe_location *ret = NULL;
518
519 if (!binary_path || !probe_name || !provider_name) {
f04a8200 520 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
521 goto end;
522 }
523
524 switch (lttng_userspace_probe_location_lookup_method_get_type(
525 lookup_method)) {
526 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
527 break;
528 default:
529 /* Invalid probe location lookup method. */
530 goto end;
531 }
532
533 ret = lttng_userspace_probe_location_tracepoint_create_no_check(
534 binary_path, provider_name, probe_name, lookup_method, true);
535end:
536 return ret;
537}
538
394357fe
FD
539static struct lttng_userspace_probe_location_lookup_method *
540lttng_userspace_probe_location_lookup_method_function_elf_copy(
541 const struct lttng_userspace_probe_location_lookup_method *lookup_method)
542{
543 struct lttng_userspace_probe_location_lookup_method *parent = NULL;
544 struct lttng_userspace_probe_location_lookup_method_elf *elf_method;
545
a0377dfe
FD
546 LTTNG_ASSERT(lookup_method);
547 LTTNG_ASSERT(lookup_method->type ==
394357fe
FD
548 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
549
550 elf_method = zmalloc(sizeof(*elf_method));
551 if (!elf_method) {
552 PERROR("Error allocating ELF userspace probe lookup method");
553 goto error;
554 }
555
556 elf_method->parent.type = lookup_method->type;
557 parent = &elf_method->parent;
558
559 goto end;
560error:
561 parent = NULL;
562end:
563 return parent;
564}
565
f4d0bb2e
FD
566static struct lttng_userspace_probe_location_lookup_method *
567lttng_userspace_probe_location_lookup_method_tracepoint_sdt_copy(
568 struct lttng_userspace_probe_location_lookup_method *lookup_method)
569{
570 struct lttng_userspace_probe_location_lookup_method *parent = NULL;
571 struct lttng_userspace_probe_location_lookup_method_sdt *sdt_method;
572
a0377dfe
FD
573 LTTNG_ASSERT(lookup_method);
574 LTTNG_ASSERT(lookup_method->type ==
f4d0bb2e
FD
575 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
576
577 sdt_method = zmalloc(sizeof(*sdt_method));
578 if (!sdt_method) {
579 PERROR("zmalloc");
580 goto error;
581 }
582
583 sdt_method->parent.type = lookup_method->type;
584 parent = &sdt_method->parent;
585
586 goto end;
587
588error:
589 parent = NULL;
590end:
591 return parent;
592}
593
394357fe
FD
594static struct lttng_userspace_probe_location *
595lttng_userspace_probe_location_function_copy(
596 const struct lttng_userspace_probe_location *location)
597{
598 enum lttng_userspace_probe_location_lookup_method_type lookup_type;
599 struct lttng_userspace_probe_location *new_location = NULL;
600 struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL;
cc831309
FD
601 const char *binary_path = NULL;
602 const char *function_name = NULL;
fe489250 603 struct lttng_userspace_probe_location_function *function_location;
394357fe 604
a0377dfe
FD
605 LTTNG_ASSERT(location);
606 LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
fe489250
JG
607 function_location = container_of(
608 location, typeof(*function_location), parent);
394357fe 609
cc831309
FD
610 /* Get probe location fields */
611 binary_path = lttng_userspace_probe_location_function_get_binary_path(location);
394357fe 612 if (!binary_path) {
cc831309 613 ERR("Userspace probe binary path is NULL");
394357fe
FD
614 goto error;
615 }
616
cc831309 617 function_name = lttng_userspace_probe_location_function_get_function_name(location);
394357fe 618 if (!function_name) {
cc831309 619 ERR("Userspace probe function name is NULL");
394357fe
FD
620 goto error;
621 }
622
394357fe
FD
623 /*
624 * Duplicate probe location method fields
625 */
626 lookup_type = lttng_userspace_probe_location_lookup_method_get_type(
627 location->lookup_method);
628 switch (lookup_type) {
629 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
630 lookup_method =
631 lttng_userspace_probe_location_lookup_method_function_elf_copy(
632 location->lookup_method);
633 if (!lookup_method) {
fe489250 634 goto error;
394357fe
FD
635 }
636 break;
637 default:
638 /* Invalid probe location lookup method. */
fe489250 639 goto error;
394357fe
FD
640 }
641
642 /* Create the probe_location */
643 new_location = lttng_userspace_probe_location_function_create_no_check(
cc831309 644 binary_path, function_name, lookup_method, false);
394357fe
FD
645 if (!new_location) {
646 goto destroy_lookup_method;
647 }
648
649 /* Set the duplicated fd to the new probe_location */
2cde0510
JG
650 if (lttng_userspace_probe_location_function_set_binary_fd_handle(new_location,
651 function_location->binary_fd_handle) < 0) {
394357fe
FD
652 goto destroy_probe_location;
653 }
654
655 goto end;
656
657destroy_probe_location:
658 lttng_userspace_probe_location_destroy(new_location);
659destroy_lookup_method:
660 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
394357fe 661error:
394357fe
FD
662 new_location = NULL;
663end:
664 return new_location;
665}
666
f4d0bb2e
FD
667static struct lttng_userspace_probe_location *
668lttng_userspace_probe_location_tracepoint_copy(
669 const struct lttng_userspace_probe_location *location)
670{
671 enum lttng_userspace_probe_location_lookup_method_type lookup_type;
672 struct lttng_userspace_probe_location *new_location = NULL;
673 struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL;
cc831309
FD
674 const char *binary_path = NULL;
675 const char *probe_name = NULL;
676 const char *provider_name = NULL;
fe489250 677 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
f4d0bb2e 678
a0377dfe
FD
679 LTTNG_ASSERT(location);
680 LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
fe489250
JG
681 tracepoint_location = container_of(
682 location, typeof(*tracepoint_location), parent);
f4d0bb2e 683
fe489250 684 /* Get probe location fields */
cc831309 685 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(location);
f4d0bb2e 686 if (!binary_path) {
cc831309 687 ERR("Userspace probe binary path is NULL");
f4d0bb2e
FD
688 goto error;
689 }
690
cc831309 691 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location);
f4d0bb2e 692 if (!probe_name) {
cc831309 693 ERR("Userspace probe probe name is NULL");
f4d0bb2e
FD
694 goto error;
695 }
696
cc831309 697 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(location);
f4d0bb2e 698 if (!provider_name) {
cc831309 699 ERR("Userspace probe provider name is NULL");
f4d0bb2e
FD
700 goto error;
701 }
702
f4d0bb2e
FD
703 /*
704 * Duplicate probe location method fields
705 */
706 lookup_type = lttng_userspace_probe_location_lookup_method_get_type(
707 location->lookup_method);
708 switch (lookup_type) {
709 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
710 lookup_method =
711 lttng_userspace_probe_location_lookup_method_tracepoint_sdt_copy(
712 location->lookup_method);
713 if (!lookup_method) {
fe489250 714 goto error;
f4d0bb2e
FD
715 }
716 break;
717 default:
718 /* Invalid probe location lookup method. */
fe489250 719 goto error;
f4d0bb2e
FD
720 }
721
722 /* Create the probe_location */
723 new_location = lttng_userspace_probe_location_tracepoint_create_no_check(
cc831309 724 binary_path, provider_name, probe_name, lookup_method, false);
f4d0bb2e
FD
725 if (!new_location) {
726 goto destroy_lookup_method;
727 }
728
729 /* Set the duplicated fd to the new probe_location */
2cde0510
JG
730 if (lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(new_location,
731 tracepoint_location->binary_fd_handle) < 0) {
f4d0bb2e
FD
732 goto destroy_probe_location;
733 }
734
735 goto end;
736
737destroy_probe_location:
738 lttng_userspace_probe_location_destroy(new_location);
739destroy_lookup_method:
740 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
f4d0bb2e 741error:
f4d0bb2e
FD
742 new_location = NULL;
743end:
744 return new_location;
745}
746
1ce46cfe
JG
747const char *lttng_userspace_probe_location_function_get_binary_path(
748 const struct lttng_userspace_probe_location *location)
749{
750 const char *ret = NULL;
751 struct lttng_userspace_probe_location_function *function_location;
752
753 if (!location || lttng_userspace_probe_location_get_type(location) !=
754 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) {
f04a8200 755 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
756 goto end;
757 }
758
759 function_location = container_of(location,
760 struct lttng_userspace_probe_location_function,
761 parent);
762 ret = function_location->binary_path;
763end:
764 return ret;
765}
766
f4d0bb2e
FD
767const char *lttng_userspace_probe_location_tracepoint_get_binary_path(
768 const struct lttng_userspace_probe_location *location)
769{
770 const char *ret = NULL;
771 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
772
773 if (!location || lttng_userspace_probe_location_get_type(location) !=
774 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) {
f04a8200 775 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
776 goto end;
777 }
778
779 tracepoint_location = container_of(location,
780 struct lttng_userspace_probe_location_tracepoint,
781 parent);
782 ret = tracepoint_location->binary_path;
783end:
784 return ret;
785}
786
1ce46cfe
JG
787const char *lttng_userspace_probe_location_function_get_function_name(
788 const struct lttng_userspace_probe_location *location)
789{
790 const char *ret = NULL;
791 struct lttng_userspace_probe_location_function *function_location;
792
793 if (!location || lttng_userspace_probe_location_get_type(location) !=
794 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) {
f04a8200 795 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
796 goto end;
797 }
798
799 function_location = container_of(location,
800 struct lttng_userspace_probe_location_function, parent);
801 ret = function_location->function_name;
802end:
803 return ret;
804}
805
f4d0bb2e
FD
806const char *lttng_userspace_probe_location_tracepoint_get_probe_name(
807 const struct lttng_userspace_probe_location *location)
808{
809 const char *ret = NULL;
810 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
811
812 if (!location || lttng_userspace_probe_location_get_type(location) !=
813 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) {
f04a8200 814 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
815 goto end;
816 }
817
818 tracepoint_location = container_of(location,
819 struct lttng_userspace_probe_location_tracepoint, parent);
820 ret = tracepoint_location->probe_name;
821end:
822 return ret;
823}
824
825const char *lttng_userspace_probe_location_tracepoint_get_provider_name(
826 const struct lttng_userspace_probe_location *location)
827{
828 const char *ret = NULL;
829 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
830
831 if (!location || lttng_userspace_probe_location_get_type(location) !=
832 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) {
f04a8200 833 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
834 goto end;
835 }
836
837 tracepoint_location = container_of(location,
838 struct lttng_userspace_probe_location_tracepoint, parent);
839 ret = tracepoint_location->provider_name;
840end:
841 return ret;
842}
843
1ce46cfe
JG
844int lttng_userspace_probe_location_function_get_binary_fd(
845 const struct lttng_userspace_probe_location *location)
846{
847 int ret = -1;
848 struct lttng_userspace_probe_location_function *function_location;
849
850 if (!location || lttng_userspace_probe_location_get_type(location) !=
851 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) {
f04a8200 852 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
853 goto end;
854 }
855
856 function_location = container_of(location,
857 struct lttng_userspace_probe_location_function, parent);
2cde0510
JG
858 ret = function_location->binary_fd_handle ?
859 fd_handle_get_fd(function_location->binary_fd_handle) : -1;
1ce46cfe
JG
860end:
861 return ret;
862}
863
9d3981b5
JG
864enum lttng_userspace_probe_location_function_instrumentation_type
865lttng_userspace_probe_location_function_get_instrumentation_type(
866 const struct lttng_userspace_probe_location *location)
867{
868 enum lttng_userspace_probe_location_function_instrumentation_type type;
869 struct lttng_userspace_probe_location_function *function_location;
870
871 if (!location || lttng_userspace_probe_location_get_type(location) !=
872 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) {
f04a8200 873 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
9d3981b5
JG
874 type = LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_UNKNOWN;
875 goto end;
876 }
877
878 function_location = container_of(location,
879 struct lttng_userspace_probe_location_function, parent);
880 type = function_location->instrumentation_type;
881end:
882 return type;
883}
884
885enum lttng_userspace_probe_location_status
886lttng_userspace_probe_location_function_set_instrumentation_type(
887 const struct lttng_userspace_probe_location *location,
888 enum lttng_userspace_probe_location_function_instrumentation_type instrumentation_type)
889{
890 enum lttng_userspace_probe_location_status status =
891 LTTNG_USERSPACE_PROBE_LOCATION_STATUS_OK;
892 struct lttng_userspace_probe_location_function *function_location;
893
894 if (!location || lttng_userspace_probe_location_get_type(location) !=
895 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION ||
896 instrumentation_type !=
897 LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_ENTRY) {
f04a8200 898 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
9d3981b5
JG
899 status = LTTNG_USERSPACE_PROBE_LOCATION_STATUS_INVALID;
900 goto end;
901 }
902
903 function_location = container_of(location,
904 struct lttng_userspace_probe_location_function, parent);
905 function_location->instrumentation_type = instrumentation_type;
906end:
907 return status;
908}
909
f4d0bb2e
FD
910int lttng_userspace_probe_location_tracepoint_get_binary_fd(
911 const struct lttng_userspace_probe_location *location)
912{
913 int ret = -1;
914 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
915
916 if (!location || lttng_userspace_probe_location_get_type(location) !=
917 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) {
f04a8200 918 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
919 goto end;
920 }
921
922 tracepoint_location = container_of(location,
923 struct lttng_userspace_probe_location_tracepoint, parent);
2cde0510
JG
924 ret = tracepoint_location->binary_fd_handle ?
925 fd_handle_get_fd(tracepoint_location->binary_fd_handle) : -1;
f4d0bb2e
FD
926end:
927 return ret;
928}
929
1ce46cfe
JG
930static struct lttng_userspace_probe_location_lookup_method *
931lttng_userspace_probe_location_function_get_lookup_method(
932 const struct lttng_userspace_probe_location *location)
933{
934 struct lttng_userspace_probe_location_lookup_method *ret = NULL;
935
936 if (!location || lttng_userspace_probe_location_get_type(location) !=
937 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) {
f04a8200 938 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
939 goto end;
940 }
941
942 ret = location->lookup_method;
943end:
944 return ret;
945}
946
f4d0bb2e
FD
947static struct lttng_userspace_probe_location_lookup_method *
948lttng_userspace_probe_location_tracepoint_get_lookup_method(
949 const struct lttng_userspace_probe_location *location)
950{
951 struct lttng_userspace_probe_location_lookup_method *ret = NULL;
952
953 if (!location || lttng_userspace_probe_location_get_type(location) !=
954 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) {
f04a8200 955 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
f4d0bb2e
FD
956 goto end;
957 }
958
959 ret = location->lookup_method;
960end:
961 return ret;
962}
963
87597c2c 964const struct lttng_userspace_probe_location_lookup_method *
1ce46cfe
JG
965lttng_userspace_probe_location_get_lookup_method(
966 const struct lttng_userspace_probe_location *location)
967{
968 struct lttng_userspace_probe_location_lookup_method *ret = NULL;
969
a0377dfe 970 LTTNG_ASSERT(location);
1ce46cfe
JG
971 switch (location->type) {
972 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
973 ret = lttng_userspace_probe_location_function_get_lookup_method(
974 location);
975 break;
f4d0bb2e
FD
976 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
977 ret = lttng_userspace_probe_location_tracepoint_get_lookup_method(
978 location);
979 break;
1ce46cfe
JG
980 default:
981 ERR("Unknowned lookup method.");
982 break;
983 }
984 return ret;
985}
986
987static
988int lttng_userspace_probe_location_lookup_method_serialize(
989 struct lttng_userspace_probe_location_lookup_method *method,
e368fb43 990 struct lttng_payload *payload)
1ce46cfe
JG
991{
992 int ret;
993 struct lttng_userspace_probe_location_lookup_method_comm
994 lookup_method_comm;
995
996 lookup_method_comm.type = (int8_t) (method ? method->type :
997 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT);
e368fb43
JG
998 if (payload) {
999 ret = lttng_dynamic_buffer_append(&payload->buffer, &lookup_method_comm,
1ce46cfe
JG
1000 sizeof(lookup_method_comm));
1001 if (ret) {
1002 goto end;
1003 }
1004 }
f4d0bb2e
FD
1005 ret = sizeof(lookup_method_comm);
1006end:
1007 return ret;
1008}
1009
1010static
1011int lttng_userspace_probe_location_function_serialize(
1012 const struct lttng_userspace_probe_location *location,
e368fb43 1013 struct lttng_payload *payload)
f4d0bb2e
FD
1014{
1015 int ret;
1016 size_t function_name_len, binary_path_len;
1017 struct lttng_userspace_probe_location_function *location_function;
1018 struct lttng_userspace_probe_location_function_comm location_function_comm;
1019
a0377dfe
FD
1020 LTTNG_ASSERT(location);
1021 LTTNG_ASSERT(lttng_userspace_probe_location_get_type(location) ==
f4d0bb2e
FD
1022 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
1023
1024 location_function = container_of(location,
1025 struct lttng_userspace_probe_location_function,
1026 parent);
1027 if (!location_function->function_name || !location_function->binary_path) {
1028 ret = -LTTNG_ERR_INVALID;
1029 goto end;
1030 }
1031
2cde0510 1032 if (payload && !location_function->binary_fd_handle) {
f4d0bb2e
FD
1033 ret = -LTTNG_ERR_INVALID;
1034 goto end;
1035 }
1036
f4d0bb2e
FD
1037 function_name_len = strlen(location_function->function_name);
1038 if (function_name_len == 0) {
1039 ret = -LTTNG_ERR_INVALID;
1040 goto end;
1041 }
1042 binary_path_len = strlen(location_function->binary_path);
1043 if (binary_path_len == 0) {
1044 ret = -LTTNG_ERR_INVALID;
1045 goto end;
1046 }
1047
1048 location_function_comm.function_name_len = function_name_len + 1;
1049 location_function_comm.binary_path_len = binary_path_len + 1;
1050
e368fb43
JG
1051 if (payload) {
1052 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1053 &location_function_comm,
1054 sizeof(location_function_comm));
1055 if (ret) {
1056 ret = -LTTNG_ERR_INVALID;
1057 goto end;
1058 }
e368fb43 1059 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1060 location_function->function_name,
1061 location_function_comm.function_name_len);
1062 if (ret) {
1063 ret = -LTTNG_ERR_INVALID;
1064 goto end;
1065 }
e368fb43 1066 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1067 location_function->binary_path,
1068 location_function_comm.binary_path_len);
1069 if (ret) {
1070 ret = -LTTNG_ERR_INVALID;
1071 goto end;
1072 }
fe489250 1073 ret = lttng_payload_push_fd_handle(
2cde0510 1074 payload, location_function->binary_fd_handle);
e368fb43
JG
1075 if (ret) {
1076 ret = -LTTNG_ERR_INVALID;
1077 goto end;
1078 }
f4d0bb2e
FD
1079 }
1080 ret = sizeof(location_function_comm) +
1081 location_function_comm.function_name_len +
1082 location_function_comm.binary_path_len;
1ce46cfe
JG
1083end:
1084 return ret;
1085}
1086
1087static
f4d0bb2e 1088int lttng_userspace_probe_location_tracepoint_serialize(
1ce46cfe 1089 const struct lttng_userspace_probe_location *location,
e368fb43 1090 struct lttng_payload *payload)
1ce46cfe
JG
1091{
1092 int ret;
f4d0bb2e
FD
1093 size_t probe_name_len, provider_name_len, binary_path_len;
1094 struct lttng_userspace_probe_location_tracepoint *location_tracepoint;
1095 struct lttng_userspace_probe_location_tracepoint_comm location_tracepoint_comm;
1ce46cfe 1096
a0377dfe
FD
1097 LTTNG_ASSERT(location);
1098 LTTNG_ASSERT(lttng_userspace_probe_location_get_type(location) ==
f4d0bb2e 1099 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
1ce46cfe 1100
f4d0bb2e
FD
1101 location_tracepoint = container_of(location,
1102 struct lttng_userspace_probe_location_tracepoint,
1ce46cfe 1103 parent);
f4d0bb2e
FD
1104 if (!location_tracepoint->probe_name ||
1105 !location_tracepoint->provider_name ||
1106 !location_tracepoint->binary_path) {
1ce46cfe
JG
1107 ret = -LTTNG_ERR_INVALID;
1108 goto end;
1109 }
1110
2cde0510 1111 if (payload && !location_tracepoint->binary_fd_handle) {
1ce46cfe
JG
1112 ret = -LTTNG_ERR_INVALID;
1113 goto end;
1114 }
1115
f4d0bb2e
FD
1116 probe_name_len = strlen(location_tracepoint->probe_name);
1117 if (probe_name_len == 0) {
1ce46cfe
JG
1118 ret = -LTTNG_ERR_INVALID;
1119 goto end;
1120 }
f4d0bb2e
FD
1121
1122 provider_name_len = strlen(location_tracepoint->provider_name);
1123 if (provider_name_len == 0) {
1124 ret = -LTTNG_ERR_INVALID;
1125 goto end;
1126 }
1127
1128 binary_path_len = strlen(location_tracepoint->binary_path);
1ce46cfe
JG
1129 if (binary_path_len == 0) {
1130 ret = -LTTNG_ERR_INVALID;
1131 goto end;
1132 }
1133
f4d0bb2e
FD
1134 location_tracepoint_comm.probe_name_len = probe_name_len + 1;
1135 location_tracepoint_comm.provider_name_len = provider_name_len + 1;
1136 location_tracepoint_comm.binary_path_len = binary_path_len + 1;
1ce46cfe 1137
e368fb43
JG
1138 if (payload) {
1139 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1140 &location_tracepoint_comm,
1141 sizeof(location_tracepoint_comm));
1ce46cfe
JG
1142 if (ret) {
1143 ret = -LTTNG_ERR_INVALID;
1144 goto end;
1145 }
e368fb43 1146 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1147 location_tracepoint->probe_name,
1148 location_tracepoint_comm.probe_name_len);
1ce46cfe
JG
1149 if (ret) {
1150 ret = -LTTNG_ERR_INVALID;
1151 goto end;
1152 }
e368fb43 1153 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1154 location_tracepoint->provider_name,
1155 location_tracepoint_comm.provider_name_len);
1156 if (ret) {
1157 ret = -LTTNG_ERR_INVALID;
1158 goto end;
1159 }
e368fb43 1160 ret = lttng_dynamic_buffer_append(&payload->buffer,
f4d0bb2e
FD
1161 location_tracepoint->binary_path,
1162 location_tracepoint_comm.binary_path_len);
1ce46cfe
JG
1163 if (ret) {
1164 ret = -LTTNG_ERR_INVALID;
1165 goto end;
1166 }
fe489250 1167 ret = lttng_payload_push_fd_handle(
2cde0510 1168 payload, location_tracepoint->binary_fd_handle);
e368fb43
JG
1169 if (ret) {
1170 ret = -LTTNG_ERR_INVALID;
1171 goto end;
1172 }
1ce46cfe 1173 }
e368fb43 1174
f4d0bb2e
FD
1175 ret = sizeof(location_tracepoint_comm) +
1176 location_tracepoint_comm.probe_name_len +
1177 location_tracepoint_comm.provider_name_len +
1178 location_tracepoint_comm.binary_path_len;
1ce46cfe
JG
1179end:
1180 return ret;
1181}
1182
1ce46cfe
JG
1183int lttng_userspace_probe_location_serialize(
1184 const struct lttng_userspace_probe_location *location,
e368fb43 1185 struct lttng_payload *payload)
1ce46cfe
JG
1186{
1187 int ret, buffer_use = 0;
1188 struct lttng_userspace_probe_location_comm location_generic_comm;
1189
1190 if (!location) {
f04a8200 1191 ERR("Invalid argument(s) passed to '%s'", __FUNCTION__);
1ce46cfe
JG
1192 ret = -LTTNG_ERR_INVALID;
1193 goto end;
1194 }
1195
56f0bc67
JG
1196 memset(&location_generic_comm, 0, sizeof(location_generic_comm));
1197
1ce46cfe 1198 location_generic_comm.type = (int8_t) location->type;
e368fb43
JG
1199 if (payload) {
1200 ret = lttng_dynamic_buffer_append(&payload->buffer,
1201 &location_generic_comm,
1ce46cfe
JG
1202 sizeof(location_generic_comm));
1203 if (ret) {
1204 goto end;
1205 }
1206 }
1207 buffer_use += sizeof(location_generic_comm);
1208
1209 switch (lttng_userspace_probe_location_get_type(location)) {
1210 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1211 ret = lttng_userspace_probe_location_function_serialize(
e368fb43 1212 location, payload);
1ce46cfe 1213 break;
f4d0bb2e
FD
1214 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
1215 ret = lttng_userspace_probe_location_tracepoint_serialize(
e368fb43 1216 location, payload);
f4d0bb2e 1217 break;
1ce46cfe
JG
1218 default:
1219 ERR("Unsupported probe location type");
1220 ret = -LTTNG_ERR_INVALID;
1221 goto end;
1222 }
1223 if (ret < 0) {
1224 goto end;
1225 }
1226 buffer_use += ret;
1227
1228 ret = lttng_userspace_probe_location_lookup_method_serialize(
e368fb43 1229 location->lookup_method, payload);
1ce46cfe
JG
1230 if (ret < 0) {
1231 goto end;
1232 }
1233 ret += buffer_use;
1234end:
1235 return ret;
1236}
1237
1238static
e368fb43
JG
1239int lttng_userspace_probe_location_function_create_from_payload(
1240 struct lttng_payload_view *view,
1ce46cfe
JG
1241 struct lttng_userspace_probe_location **location)
1242{
1243 struct lttng_userspace_probe_location_function_comm *location_function_comm;
1244 const char *function_name_src, *binary_path_src;
1245 char *function_name = NULL, *binary_path = NULL;
1246 int ret = 0;
e368fb43 1247 size_t expected_size;
2cde0510 1248 struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
1ce46cfe 1249
a0377dfe 1250 LTTNG_ASSERT(location);
1ce46cfe 1251
e368fb43
JG
1252 if (view->buffer.size < sizeof(*location_function_comm)) {
1253 ret = -LTTNG_ERR_INVALID;
1254 goto end;
1255 }
1256
1ce46cfe 1257 location_function_comm =
e368fb43 1258 (typeof(location_function_comm)) view->buffer.data;
1ce46cfe 1259
e368fb43 1260 expected_size = sizeof(*location_function_comm) +
1ce46cfe
JG
1261 location_function_comm->function_name_len +
1262 location_function_comm->binary_path_len;
1263
e368fb43 1264 if (view->buffer.size < expected_size) {
1ce46cfe
JG
1265 ret = -LTTNG_ERR_INVALID;
1266 goto end;
1267 }
1268
e368fb43 1269 function_name_src = view->buffer.data + sizeof(*location_function_comm);
1ce46cfe
JG
1270 binary_path_src = function_name_src +
1271 location_function_comm->function_name_len;
1272
48c24aea
JG
1273 if (!lttng_buffer_view_contains_string(&view->buffer, function_name_src,
1274 location_function_comm->function_name_len)) {
1ce46cfe
JG
1275 ret = -LTTNG_ERR_INVALID;
1276 goto end;
1277 }
48c24aea
JG
1278
1279 if (!lttng_buffer_view_contains_string(&view->buffer, binary_path_src,
1280 location_function_comm->binary_path_len)) {
1ce46cfe
JG
1281 ret = -LTTNG_ERR_INVALID;
1282 goto end;
1283 }
1284
1285 function_name = lttng_strndup(function_name_src, LTTNG_SYMBOL_NAME_LEN);
1286 if (!function_name) {
1287 PERROR("lttng_strndup");
2aa28610 1288 ret = -LTTNG_ERR_NOMEM;
1ce46cfe
JG
1289 goto end;
1290 }
1291
1292 binary_path = lttng_strndup(binary_path_src, LTTNG_PATH_MAX);
1293 if (!binary_path) {
1294 PERROR("lttng_strndup");
2aa28610 1295 ret = -LTTNG_ERR_NOMEM;
1ce46cfe
JG
1296 goto end;
1297 }
1298
1299 *location = lttng_userspace_probe_location_function_create_no_check(
1300 binary_path, function_name, NULL, false);
1301 if (!(*location)) {
1302 ret = -LTTNG_ERR_INVALID;
1303 goto end;
1304 }
1305
2cde0510
JG
1306 ret = lttng_userspace_probe_location_function_set_binary_fd_handle(
1307 *location, binary_fd_handle);
e368fb43 1308 if (ret) {
e368fb43
JG
1309 ret = -LTTNG_ERR_INVALID;
1310 goto end;
1311 }
1312
1ce46cfe
JG
1313 ret = (int) expected_size;
1314end:
2cde0510 1315 fd_handle_put(binary_fd_handle);
1ce46cfe
JG
1316 free(function_name);
1317 free(binary_path);
1318 return ret;
1319}
1320
f4d0bb2e 1321static
e368fb43
JG
1322int lttng_userspace_probe_location_tracepoint_create_from_payload(
1323 struct lttng_payload_view *view,
f4d0bb2e
FD
1324 struct lttng_userspace_probe_location **location)
1325{
1326 struct lttng_userspace_probe_location_tracepoint_comm *location_tracepoint_comm;
1327 const char *probe_name_src, *provider_name_src, *binary_path_src;
1328 char *probe_name = NULL, *provider_name = NULL, *binary_path = NULL;
1329 int ret = 0;
e368fb43 1330 size_t expected_size;
2cde0510 1331 struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
f4d0bb2e 1332
a0377dfe 1333 LTTNG_ASSERT(location);
f4d0bb2e 1334
2cde0510 1335 if (!binary_fd_handle) {
e368fb43
JG
1336 ret = -LTTNG_ERR_INVALID;
1337 goto end;
1338 }
1339
1340 if (view->buffer.size < sizeof(*location_tracepoint_comm)) {
1341 ret = -LTTNG_ERR_INVALID;
1342 goto end;
1343 }
1344
f4d0bb2e 1345 location_tracepoint_comm =
e368fb43 1346 (typeof(location_tracepoint_comm)) view->buffer.data;
f4d0bb2e 1347
e368fb43 1348 expected_size = sizeof(*location_tracepoint_comm) +
f4d0bb2e
FD
1349 location_tracepoint_comm->probe_name_len +
1350 location_tracepoint_comm->provider_name_len +
1351 location_tracepoint_comm->binary_path_len;
1352
e368fb43 1353 if (view->buffer.size < expected_size) {
f4d0bb2e
FD
1354 ret = -LTTNG_ERR_INVALID;
1355 goto end;
1356 }
1357
e368fb43 1358 probe_name_src = view->buffer.data + sizeof(*location_tracepoint_comm);
f4d0bb2e
FD
1359 provider_name_src = probe_name_src +
1360 location_tracepoint_comm->probe_name_len;
1361 binary_path_src = provider_name_src +
1362 location_tracepoint_comm->provider_name_len;
1363
48c24aea
JG
1364 if (!lttng_buffer_view_contains_string(&view->buffer, probe_name_src,
1365 location_tracepoint_comm->probe_name_len)) {
f4d0bb2e
FD
1366 ret = -LTTNG_ERR_INVALID;
1367 goto end;
1368 }
1369
48c24aea
JG
1370 if (!lttng_buffer_view_contains_string(&view->buffer, provider_name_src,
1371 location_tracepoint_comm->provider_name_len)) {
f4d0bb2e
FD
1372 ret = -LTTNG_ERR_INVALID;
1373 goto end;
1374 }
1375
48c24aea
JG
1376 if (!lttng_buffer_view_contains_string(&view->buffer, binary_path_src,
1377 location_tracepoint_comm->binary_path_len)) {
f4d0bb2e
FD
1378 ret = -LTTNG_ERR_INVALID;
1379 goto end;
1380 }
1381
1382 probe_name = lttng_strndup(probe_name_src, LTTNG_SYMBOL_NAME_LEN);
1383 if (!probe_name) {
c21e883d
JG
1384 PERROR("Failed to allocate probe name");
1385 ret = -LTTNG_ERR_INVALID;
f4d0bb2e
FD
1386 goto end;
1387 }
1388 provider_name = lttng_strndup(provider_name_src, LTTNG_SYMBOL_NAME_LEN);
1389 if (!provider_name) {
c21e883d
JG
1390 PERROR("Failed to allocate provider name");
1391 ret = -LTTNG_ERR_INVALID;
f4d0bb2e
FD
1392 goto end;
1393 }
1394
b45a2969 1395 binary_path = lttng_strndup(binary_path_src, LTTNG_PATH_MAX);
f4d0bb2e 1396 if (!binary_path) {
c21e883d
JG
1397 PERROR("Failed to allocate binary path");
1398 ret = -LTTNG_ERR_INVALID;
f4d0bb2e
FD
1399 goto end;
1400 }
1401
1402 *location = lttng_userspace_probe_location_tracepoint_create_no_check(
1403 binary_path, provider_name, probe_name, NULL, false);
1404 if (!(*location)) {
1405 ret = -LTTNG_ERR_INVALID;
1406 goto end;
1407 }
1408
2cde0510
JG
1409 ret = lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(
1410 *location, binary_fd_handle);
e368fb43 1411 if (ret) {
e368fb43
JG
1412 ret = -LTTNG_ERR_INVALID;
1413 goto end;
1414 }
1415
f4d0bb2e
FD
1416 ret = (int) expected_size;
1417end:
2cde0510 1418 fd_handle_put(binary_fd_handle);
f4d0bb2e
FD
1419 free(probe_name);
1420 free(provider_name);
1421 free(binary_path);
1422 return ret;
1423}
1424
1ce46cfe 1425static
e368fb43
JG
1426int lttng_userspace_probe_location_lookup_method_create_from_payload(
1427 struct lttng_payload_view *view,
1ce46cfe
JG
1428 struct lttng_userspace_probe_location_lookup_method **lookup_method)
1429{
1430 int ret;
1431 struct lttng_userspace_probe_location_lookup_method_comm *lookup_comm;
1432 enum lttng_userspace_probe_location_lookup_method_type type;
1433
a0377dfe
FD
1434 LTTNG_ASSERT(view);
1435 LTTNG_ASSERT(lookup_method);
1ce46cfe 1436
e368fb43 1437 if (view->buffer.size < sizeof(*lookup_comm)) {
1ce46cfe
JG
1438 ret = -LTTNG_ERR_INVALID;
1439 goto end;
1440 }
1441
e368fb43 1442 lookup_comm = (typeof(lookup_comm)) view->buffer.data;
1ce46cfe
JG
1443 type = (enum lttng_userspace_probe_location_lookup_method_type)
1444 lookup_comm->type;
1445 switch (type) {
1446 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
1447 *lookup_method = NULL;
1448 break;
1449 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
1450 *lookup_method =
1451 lttng_userspace_probe_location_lookup_method_function_elf_create();
1452 if (!(*lookup_method)) {
1453 ret = -LTTNG_ERR_INVALID;
1454 goto end;
1455 }
1456 break;
f4d0bb2e
FD
1457 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
1458 *lookup_method =
1459 lttng_userspace_probe_location_lookup_method_tracepoint_sdt_create();
1460 if (!(*lookup_method)) {
1461 ret = -LTTNG_ERR_INVALID;
1462 goto end;
1463 }
1464 break;
1ce46cfe
JG
1465 default:
1466 ret = -LTTNG_ERR_INVALID;
1467 goto end;
1468 }
1469
1470 ret = sizeof(*lookup_comm);
1471end:
1472 return ret;
1473}
1474
e368fb43
JG
1475int lttng_userspace_probe_location_create_from_payload(
1476 struct lttng_payload_view *view,
1ce46cfe
JG
1477 struct lttng_userspace_probe_location **location)
1478{
1479 struct lttng_userspace_probe_location_lookup_method *lookup_method;
1ce46cfe 1480 enum lttng_userspace_probe_location_type type;
1ce46cfe
JG
1481 int consumed = 0;
1482 int ret;
3e6e0df2
JG
1483 struct lttng_userspace_probe_location_comm *probe_location_comm;
1484 struct lttng_payload_view probe_location_comm_view =
1485 lttng_payload_view_from_view(
1486 view, 0, sizeof(*probe_location_comm));
1ce46cfe 1487
a0377dfe
FD
1488 LTTNG_ASSERT(view);
1489 LTTNG_ASSERT(location);
1ce46cfe
JG
1490
1491 lookup_method = NULL;
1492
3e6e0df2 1493 if (!lttng_payload_view_is_valid(&probe_location_comm_view)) {
1ce46cfe
JG
1494 ret = -LTTNG_ERR_INVALID;
1495 goto end;
1496 }
1497
3e6e0df2 1498 probe_location_comm = (typeof(probe_location_comm)) probe_location_comm_view.buffer.data;
1ce46cfe
JG
1499 type = (enum lttng_userspace_probe_location_type) probe_location_comm->type;
1500 consumed += sizeof(*probe_location_comm);
1501
1502 switch (type) {
1503 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1504 {
e368fb43
JG
1505 struct lttng_payload_view location_view =
1506 lttng_payload_view_from_view(
1507 view, consumed, -1);
1ce46cfe 1508
e368fb43
JG
1509 ret = lttng_userspace_probe_location_function_create_from_payload(
1510 &location_view, location);
1ce46cfe
JG
1511 if (ret < 0) {
1512 goto end;
1513 }
1514 break;
1515 }
f4d0bb2e
FD
1516 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
1517 {
e368fb43
JG
1518 struct lttng_payload_view location_view =
1519 lttng_payload_view_from_view(view, consumed, -1);
f4d0bb2e 1520
e368fb43
JG
1521 ret = lttng_userspace_probe_location_tracepoint_create_from_payload(
1522 &location_view, location);
f4d0bb2e
FD
1523 if (ret < 0) {
1524 goto end;
1525 }
1526 break;
1527 }
1ce46cfe
JG
1528 default:
1529 ret = -LTTNG_ERR_INVALID;
1530 goto end;
1531 }
1532
1533 consumed += ret;
e368fb43 1534 if (view->buffer.size <= consumed) {
1ce46cfe
JG
1535 ret = -LTTNG_ERR_INVALID;
1536 goto end;
1537 }
1538
e368fb43
JG
1539 {
1540 struct lttng_payload_view lookup_method_view =
1541 lttng_payload_view_from_view(
1542 view, consumed, -1);
1543
1544 ret = lttng_userspace_probe_location_lookup_method_create_from_payload(
1545 &lookup_method_view, &lookup_method);
1546 }
1ce46cfe
JG
1547 if (ret < 0) {
1548 ret = -LTTNG_ERR_INVALID;
1549 goto end;
1550 }
1551
a0377dfe 1552 LTTNG_ASSERT(lookup_method);
1ce46cfe
JG
1553 (*location)->lookup_method = lookup_method;
1554 lookup_method = NULL;
1555 ret += consumed;
1556end:
1557 return ret;
1558}
1559
fe489250 1560static
2cde0510 1561int lttng_userspace_probe_location_function_set_binary_fd_handle(
fe489250
JG
1562 struct lttng_userspace_probe_location *location,
1563 struct fd_handle *binary_fd)
1ce46cfe
JG
1564{
1565 int ret = 0;
1566 struct lttng_userspace_probe_location_function *function_location;
1567
a0377dfe
FD
1568 LTTNG_ASSERT(location);
1569 LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
1ce46cfe
JG
1570
1571 function_location = container_of(location,
1572 struct lttng_userspace_probe_location_function, parent);
2cde0510 1573 fd_handle_put(function_location->binary_fd_handle);
fe489250 1574 fd_handle_get(binary_fd);
2cde0510 1575 function_location->binary_fd_handle = binary_fd;
1ce46cfe
JG
1576 return ret;
1577}
1578
fe489250 1579static
2cde0510 1580int lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(
fe489250
JG
1581 struct lttng_userspace_probe_location *location,
1582 struct fd_handle *binary_fd)
f4d0bb2e
FD
1583{
1584 int ret = 0;
1585 struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
1586
a0377dfe
FD
1587 LTTNG_ASSERT(location);
1588 LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
f4d0bb2e
FD
1589
1590 tracepoint_location = container_of(location,
1591 struct lttng_userspace_probe_location_tracepoint, parent);
2cde0510 1592 fd_handle_put(tracepoint_location->binary_fd_handle);
fe489250 1593 fd_handle_get(binary_fd);
2cde0510 1594 tracepoint_location->binary_fd_handle = binary_fd;
f4d0bb2e
FD
1595 return ret;
1596}
1597
1ce46cfe
JG
1598static
1599int lttng_userspace_probe_location_function_flatten(
1600 const struct lttng_userspace_probe_location *location,
1601 struct lttng_dynamic_buffer *buffer)
1602{
1603 struct lttng_userspace_probe_location_lookup_method_elf flat_lookup_method;
1604 struct lttng_userspace_probe_location_function *probe_function;
1605 struct lttng_userspace_probe_location_function flat_probe;
1606 size_t function_name_len, binary_path_len;
1607 size_t padding_needed = 0;
1608 char *flat_probe_start;
1609 int storage_needed = 0;
1610 int ret;
1611
a0377dfe 1612 LTTNG_ASSERT(location);
1ce46cfe
JG
1613
1614 if (location->lookup_method && location->lookup_method->type !=
1615 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF) {
1616 ret = -LTTNG_ERR_INVALID;
1617 goto end;
1618 }
1619
1620 probe_function = container_of(location,
1621 struct lttng_userspace_probe_location_function,
1622 parent);
a0377dfe
FD
1623 LTTNG_ASSERT(probe_function->function_name);
1624 LTTNG_ASSERT(probe_function->binary_path);
1ce46cfe
JG
1625
1626 storage_needed +=
1627 sizeof(struct lttng_userspace_probe_location_function);
1628 function_name_len = strlen(probe_function->function_name) + 1;
1629 binary_path_len = strlen(probe_function->binary_path) + 1;
1630 storage_needed += function_name_len + binary_path_len;
1631
1632 /*
1633 * The lookup method is aligned to 64-bit within the buffer.
1634 * This is needed even if there is no lookup method since
1635 * the next structure in the buffer probably needs to be
1636 * aligned too (depending on the arch).
1637 */
1cbd136b 1638 padding_needed = lttng_align_ceil(storage_needed, sizeof(uint64_t)) - storage_needed;
1ce46cfe
JG
1639 storage_needed += padding_needed;
1640
1641 if (location->lookup_method) {
1642 /* NOTE: elf look-up method is assumed here. */
1643 storage_needed += sizeof(struct lttng_userspace_probe_location_lookup_method_elf);
1644 }
1645
1646 if (!buffer) {
1647 ret = storage_needed;
1648 goto end;
1649 }
1650
1651 if (lttng_dynamic_buffer_get_capacity_left(buffer) < storage_needed) {
1652 ret = lttng_dynamic_buffer_set_capacity(buffer,
1653 buffer->size + storage_needed);
1654 if (ret) {
1655 goto end;
1656 }
1657 }
1658
1659 memset(&flat_probe, 0, sizeof(flat_probe));
1660
1661 flat_probe_start = buffer->data + buffer->size;
1662 flat_probe.parent.type = location->type;
1663 /*
1664 * The lookup method, if present, is the last element in the flat
1665 * representation of the probe.
1666 */
1667 if (location->lookup_method) {
1668 flat_probe.parent.lookup_method =
1669 (struct lttng_userspace_probe_location_lookup_method *)
1670 (flat_probe_start + sizeof(flat_probe) +
1671 function_name_len + binary_path_len + padding_needed);
1672 } else {
1673 flat_probe.parent.lookup_method = NULL;
1674 }
1675
1676 flat_probe.function_name = flat_probe_start + sizeof(flat_probe);
1677 flat_probe.binary_path = flat_probe.function_name + function_name_len;
2cde0510 1678 flat_probe.binary_fd_handle = NULL;
1ce46cfe
JG
1679 ret = lttng_dynamic_buffer_append(buffer, &flat_probe,
1680 sizeof(flat_probe));
1681 if (ret) {
1682 goto end;
1683 }
1684
1685 ret = lttng_dynamic_buffer_append(buffer,
1686 probe_function->function_name, function_name_len);
1687 if (ret) {
1688 goto end;
1689 }
1690 ret = lttng_dynamic_buffer_append(buffer,
1691 probe_function->binary_path, binary_path_len);
1692 if (ret) {
1693 goto end;
1694 }
1695
1696 /* Insert padding before the lookup method. */
1697 ret = lttng_dynamic_buffer_set_size(buffer,
1698 buffer->size + padding_needed);
1699 if (ret) {
1700 goto end;
1701 }
1702
1703 if (!location->lookup_method) {
1704 /* Not an error, the default method is used. */
1705 ret = storage_needed;
1706 goto end;
1707 }
1708
1709 memset(&flat_lookup_method, 0, sizeof(flat_lookup_method));
1710 flat_lookup_method.parent.type =
1711 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF;
1712 ret = lttng_dynamic_buffer_append(buffer,
1713 &flat_lookup_method, sizeof(flat_lookup_method));
1714 if (ret) {
1715 goto end;
1716 }
1717 ret = storage_needed;
1718end:
1719 return ret;
1720}
1721
f4d0bb2e
FD
1722static
1723int lttng_userspace_probe_location_tracepoint_flatten(
1724 const struct lttng_userspace_probe_location *location,
1725 struct lttng_dynamic_buffer *buffer)
1726{
1727 struct lttng_userspace_probe_location_lookup_method_sdt flat_lookup_method;
1728 struct lttng_userspace_probe_location_tracepoint *probe_tracepoint;
1729 struct lttng_userspace_probe_location_tracepoint flat_probe;
1730 size_t probe_name_len, provider_name_len, binary_path_len;
1731 size_t padding_needed = 0;
1732 int storage_needed = 0;
1733 char *flat_probe_start;
1734 int ret = 0;
1735
a0377dfe 1736 LTTNG_ASSERT(location);
f4d0bb2e
FD
1737
1738 /* Only SDT tracepoints are supported at the moment */
1739 if (location->lookup_method && location->lookup_method->type !=
1740 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT) {
1741 ret = -LTTNG_ERR_INVALID;
1742 goto end;
1743 }
1744 probe_tracepoint = container_of(location,
1745 struct lttng_userspace_probe_location_tracepoint,
1746 parent);
a0377dfe
FD
1747 LTTNG_ASSERT(probe_tracepoint->probe_name);
1748 LTTNG_ASSERT(probe_tracepoint->provider_name);
1749 LTTNG_ASSERT(probe_tracepoint->binary_path);
f4d0bb2e
FD
1750
1751 /* Compute the storage space needed to flatten the probe location */
1752 storage_needed += sizeof(struct lttng_userspace_probe_location_tracepoint);
1753
1754 probe_name_len = strlen(probe_tracepoint->probe_name) + 1;
1755 provider_name_len = strlen(probe_tracepoint->provider_name) + 1;
1756 binary_path_len = strlen(probe_tracepoint->binary_path) + 1;
1757
1758 storage_needed += probe_name_len + provider_name_len + binary_path_len;
1759
1760 /*
1761 * The lookup method is aligned to 64-bit within the buffer.
1762 * This is needed even if there is no lookup method since
1763 * the next structure in the buffer probably needs to be
1764 * aligned too (depending on the arch).
1765 */
1cbd136b 1766 padding_needed = lttng_align_ceil(storage_needed, sizeof(uint64_t)) - storage_needed;
f4d0bb2e
FD
1767 storage_needed += padding_needed;
1768
1769 if (location->lookup_method) {
1770 /* NOTE: elf look-up method is assumed here. */
1771 storage_needed +=
1772 sizeof(struct lttng_userspace_probe_location_lookup_method_elf);
1773 }
1774
1775 /*
1776 * If the caller set buffer to NULL, return the size of the needed buffer.
1777 */
1778 if (!buffer) {
1779 ret = storage_needed;
1780 goto end;
1781 }
1782
1783 if (lttng_dynamic_buffer_get_capacity_left(buffer) < storage_needed) {
1784 ret = lttng_dynamic_buffer_set_capacity(buffer,
1785 buffer->size + storage_needed);
1786 if (ret) {
1787 goto end;
1788 }
1789 }
1790
1791 memset(&flat_probe, 0, sizeof(flat_probe));
1792
1793 flat_probe_start = buffer->data + buffer->size;
1794 flat_probe.parent.type = location->type;
1795
1796 /*
1797 * The lookup method, if present, is the last element in the flat
1798 * representation of the probe.
1799 */
1800 if (location->lookup_method) {
1801 flat_probe.parent.lookup_method =
1802 (struct lttng_userspace_probe_location_lookup_method *)
1803 (flat_probe_start + sizeof(flat_probe) +
1804 probe_name_len + provider_name_len +
1805 binary_path_len + padding_needed);
1806 } else {
1807 flat_probe.parent.lookup_method = NULL;
1808 }
1809
1810 flat_probe.probe_name = flat_probe_start + sizeof(flat_probe);
1811 flat_probe.provider_name = flat_probe.probe_name + probe_name_len;
1812 flat_probe.binary_path = flat_probe.provider_name + provider_name_len;
2cde0510 1813 flat_probe.binary_fd_handle = NULL;
f4d0bb2e
FD
1814 ret = lttng_dynamic_buffer_append(buffer, &flat_probe, sizeof(flat_probe));
1815 if (ret) {
1816 goto end;
1817 }
1818
1819 /* Append all the fields to the buffer */
1820 ret = lttng_dynamic_buffer_append(buffer,
1821 probe_tracepoint->probe_name, probe_name_len);
1822 if (ret) {
1823 goto end;
1824 }
1825 ret = lttng_dynamic_buffer_append(buffer,
1826 probe_tracepoint->provider_name, provider_name_len);
1827 if (ret) {
1828 goto end;
1829 }
1830 ret = lttng_dynamic_buffer_append(buffer,
1831 probe_tracepoint->binary_path, binary_path_len);
1832 if (ret) {
1833 goto end;
1834 }
1835
1836 /* Insert padding before the lookup method. */
1837 ret = lttng_dynamic_buffer_set_size(buffer, buffer->size + padding_needed);
1838 if (ret) {
1839 goto end;
1840 }
1841
1842 if (!location->lookup_method) {
1843 /* Not an error, the default method is used. */
1844 ret = storage_needed;
1845 goto end;
1846 }
1847
1848 memset(&flat_lookup_method, 0, sizeof(flat_lookup_method));
1849
1850 flat_lookup_method.parent.type =
1851 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT;
1852 ret = lttng_dynamic_buffer_append(buffer,
1853 &flat_lookup_method, sizeof(flat_lookup_method));
1854 if (ret) {
1855 goto end;
1856 }
1857 ret = storage_needed;
1858end:
1859 return ret;
1860}
1861
1ce46cfe
JG
1862int lttng_userspace_probe_location_flatten(
1863 const struct lttng_userspace_probe_location *location,
1864 struct lttng_dynamic_buffer *buffer)
1865{
1866 int ret;
1867 if (!location) {
1868 ret = -LTTNG_ERR_INVALID;
1869 goto end;
1870 }
1871
1872 /* Only types currently supported. */
1873 switch (location->type) {
1874 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1875 ret = lttng_userspace_probe_location_function_flatten(location, buffer);
1876 break;
f4d0bb2e
FD
1877 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
1878 ret = lttng_userspace_probe_location_tracepoint_flatten(location, buffer);
1879 break;
1ce46cfe
JG
1880 default:
1881 ret = -LTTNG_ERR_INVALID;
1882 goto end;
1883 }
1884
1885end:
1886 return ret;
1887}
394357fe 1888
394357fe
FD
1889struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy(
1890 const struct lttng_userspace_probe_location *location)
1891{
1892 struct lttng_userspace_probe_location *new_location = NULL;
1893 enum lttng_userspace_probe_location_type type;
1894
1895 if (!location) {
1896 goto err;
1897 }
1898
1899 type = lttng_userspace_probe_location_get_type(location);
1900 switch (type) {
1901 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1902 new_location =
1903 lttng_userspace_probe_location_function_copy(location);
1904 if (!new_location) {
1905 goto err;
1906 }
1907 break;
f4d0bb2e
FD
1908 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
1909 new_location =
1910 lttng_userspace_probe_location_tracepoint_copy(location);
1911 if (!new_location) {
1912 goto err;
1913 }
1914 break;
394357fe
FD
1915 default:
1916 new_location = NULL;
1917 goto err;
1918 }
1919err:
1920 return new_location;
1921}
dfcfa983 1922
dfcfa983
JR
1923bool lttng_userspace_probe_location_lookup_method_is_equal(
1924 const struct lttng_userspace_probe_location_lookup_method *a,
1925 const struct lttng_userspace_probe_location_lookup_method *b)
1926{
1927 bool is_equal = false;
1928
1929 if (!a || !b) {
1930 goto end;
1931 }
1932
1933 if (a == b) {
1934 is_equal = true;
1935 goto end;
1936 }
1937
1938 if (a->type != b->type) {
1939 goto end;
1940 }
1941
1942 is_equal = true;
1943end:
1944 return is_equal;
1945}
1946
dfcfa983
JR
1947bool lttng_userspace_probe_location_is_equal(
1948 const struct lttng_userspace_probe_location *a,
1949 const struct lttng_userspace_probe_location *b)
1950{
1951 bool is_equal = false;
1952
1953 if (!a || !b) {
1954 goto end;
1955 }
1956
1957 if (a == b) {
1958 is_equal = true;
1959 goto end;
1960 }
1961
1962 if (!lttng_userspace_probe_location_lookup_method_is_equal(
1963 a->lookup_method, b->lookup_method)) {
1964 goto end;
1965 }
1966
1967 if (a->type != b->type) {
1968 goto end;
1969 }
1970
1971 is_equal = a->equal ? a->equal(a, b) : true;
1972end:
1973 return is_equal;
1974}
959e3c66 1975
959e3c66
JR
1976unsigned long lttng_userspace_probe_location_hash(
1977 const struct lttng_userspace_probe_location *location)
1978{
1979 return location->hash(location);
1980}
6a751b95 1981
6a751b95
JR
1982enum lttng_error_code lttng_userspace_probe_location_mi_serialize(
1983 const struct lttng_userspace_probe_location *location,
1984 struct mi_writer *writer)
1985{
1986 typedef enum lttng_error_code (*mi_fp)(
1987 const struct lttng_userspace_probe_location *,
1988 struct mi_writer *);
1989
1990 int ret;
1991 enum lttng_error_code ret_code;
1992 mi_fp mi_function = NULL;
1993
a0377dfe
FD
1994 LTTNG_ASSERT(location);
1995 LTTNG_ASSERT(writer);
6a751b95
JR
1996
1997 switch (lttng_userspace_probe_location_get_type(location)) {
1998 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1999 mi_function = lttng_userspace_probe_location_function_mi_serialize;
2000 break;
2001 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
2002 mi_function = lttng_userspace_probe_location_tracepoint_mi_serialize;
2003 break;
2004 default:
2005 abort();
2006 break;
2007 }
2008
2009 /* Open userspace probe location element. */
2010 ret = mi_lttng_writer_open_element(
2011 writer, mi_lttng_element_userspace_probe_location);
2012 if (ret) {
2013 goto mi_error;
2014 }
2015
2016 /* Underlying user space probe location. */
2017 ret_code = mi_function(location, writer);
2018 if (ret_code != LTTNG_OK) {
2019 goto end;
2020 }
2021
2022 /* Close userspace probe location element. */
2023 ret = mi_lttng_writer_close_element(writer);
2024 if (ret) {
2025 goto mi_error;
2026 }
2027
2028 ret_code = LTTNG_OK;
2029 goto end;
2030
2031mi_error:
2032 ret_code = LTTNG_ERR_MI_IO_FAIL;
2033end:
2034 return ret_code;
2035}
2036
2037enum lttng_error_code lttng_userspace_probe_location_lookup_method_mi_serialize(
2038 const struct lttng_userspace_probe_location_lookup_method
2039 *method,
2040 struct mi_writer *writer)
2041{
2042 int ret;
2043 enum lttng_error_code ret_code;
2044 const char *type_element_str;
2045
a0377dfe
FD
2046 LTTNG_ASSERT(method);
2047 LTTNG_ASSERT(writer);
6a751b95
JR
2048
2049 switch (lttng_userspace_probe_location_lookup_method_get_type(method)) {
2050 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
2051 type_element_str =
2052 mi_lttng_element_userspace_probe_location_lookup_method_function_default;
2053 break;
2054 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
2055 type_element_str =
2056 mi_lttng_element_userspace_probe_location_lookup_method_function_elf;
2057 break;
2058 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
2059 type_element_str =
2060 mi_lttng_element_userspace_probe_location_lookup_method_tracepoint_sdt;
2061 break;
2062 default:
2063 abort();
2064 break;
2065 }
2066
2067 /* Open userspace probe location lookup method element. */
2068 ret = mi_lttng_writer_open_element(writer,
2069 mi_lttng_element_userspace_probe_location_lookup_method);
2070 if (ret) {
2071 goto mi_error;
2072 }
2073
2074 /* User space probe location lookup method empty element. */
2075 ret = mi_lttng_writer_open_element(writer, type_element_str);
2076 if (ret) {
2077 goto mi_error;
2078 }
2079
2080 /* Close userspace probe location lookup method element. */
2081 ret = mi_lttng_close_multi_element(writer, 2);
2082 if (ret) {
2083 goto mi_error;
2084 }
2085
2086 ret_code = LTTNG_OK;
2087 goto end;
2088
2089mi_error:
2090 ret_code = LTTNG_ERR_MI_IO_FAIL;
2091end:
2092 return ret_code;
2093}
2094
2095static enum lttng_error_code lttng_userspace_probe_location_tracepoint_mi_serialize(
2096 const struct lttng_userspace_probe_location *location,
2097 struct mi_writer *writer)
2098{
2099 int ret;
2100 enum lttng_error_code ret_code;
2101 const char *probe_name = NULL;
2102 const char *provider_name = NULL;
2103 const char *binary_path = NULL;
2104 const struct lttng_userspace_probe_location_lookup_method
2105 *lookup_method = NULL;
2106
a0377dfe
FD
2107 LTTNG_ASSERT(location);
2108 LTTNG_ASSERT(writer);
6a751b95
JR
2109
2110 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
2111 location);
2112 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
2113 location);
2114 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(
2115 location);
2116 lookup_method = lttng_userspace_probe_location_tracepoint_get_lookup_method(
2117 location);
2118
2119 /* Open userspace probe location tracepoint element. */
2120 ret = mi_lttng_writer_open_element(writer,
2121 mi_lttng_element_userspace_probe_location_tracepoint);
2122 if (ret) {
2123 goto mi_error;
2124 }
2125
2126 /* Probe name. */
2127 ret = mi_lttng_writer_write_element_string(writer,
2128 mi_lttng_element_userspace_probe_location_tracepoint_probe_name,
2129 probe_name);
2130 if (ret) {
2131 goto mi_error;
2132 }
2133
2134 /* Provider name. */
2135 ret = mi_lttng_writer_write_element_string(writer,
2136 mi_lttng_element_userspace_probe_location_tracepoint_provider_name,
2137 provider_name);
2138 if (ret) {
2139 goto mi_error;
2140 }
2141
2142 /* Binary path. */
2143 ret = mi_lttng_writer_write_element_string(writer,
2144 mi_lttng_element_userspace_probe_location_binary_path,
2145 binary_path);
2146 if (ret) {
2147 goto mi_error;
2148 }
2149
2150 /* The lookup method. */
2151 ret_code = lttng_userspace_probe_location_lookup_method_mi_serialize(
2152 lookup_method, writer);
2153 if (ret_code != LTTNG_OK) {
2154 goto end;
2155 }
2156
2157 /* Close userspace probe location tracepoint. */
2158 ret = mi_lttng_writer_close_element(writer);
2159 if (ret) {
2160 goto mi_error;
2161 }
2162
2163 ret_code = LTTNG_OK;
2164 goto end;
2165
2166mi_error:
2167 ret_code = LTTNG_ERR_MI_IO_FAIL;
2168end:
2169 return ret_code;
2170}
2171
2172static enum lttng_error_code lttng_userspace_probe_location_function_mi_serialize(
2173 const struct lttng_userspace_probe_location *location,
2174 struct mi_writer *writer)
2175{
2176 int ret;
2177 enum lttng_error_code ret_code;
2178 const char *function_name = NULL;
2179 const char *binary_path = NULL;
2180 const char *instrumentation_type_str = NULL;
2181 enum lttng_userspace_probe_location_function_instrumentation_type
2182 instrumentation_type;
2183 const struct lttng_userspace_probe_location_lookup_method
2184 *lookup_method = NULL;
2185
a0377dfe
FD
2186 LTTNG_ASSERT(location);
2187 LTTNG_ASSERT(writer);
6a751b95
JR
2188
2189 function_name = lttng_userspace_probe_location_function_get_function_name(
2190 location);
2191 binary_path = lttng_userspace_probe_location_function_get_binary_path(
2192 location);
2193 instrumentation_type =
2194 lttng_userspace_probe_location_function_get_instrumentation_type(
2195 location);
2196 lookup_method = lttng_userspace_probe_location_function_get_lookup_method(
2197 location);
2198
2199 switch (instrumentation_type) {
2200 case LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_ENTRY:
2201 instrumentation_type_str =
2202 mi_lttng_userspace_probe_location_function_instrumentation_type_entry;
2203 break;
2204 default:
2205 abort();
2206 break;
2207 }
2208
2209 /* Open userspace probe location function element. */
2210 ret = mi_lttng_writer_open_element(writer,
2211 mi_lttng_element_userspace_probe_location_function);
2212 if (ret) {
2213 goto mi_error;
2214 }
2215
2216 /* Function name. */
2217 ret = mi_lttng_writer_write_element_string(writer,
2218 mi_lttng_element_userspace_probe_location_function_name,
2219 function_name);
2220 if (ret) {
2221 goto mi_error;
2222 }
2223
2224 /* Binary path. */
2225 ret = mi_lttng_writer_write_element_string(writer,
2226 mi_lttng_element_userspace_probe_location_binary_path,
2227 binary_path);
2228 if (ret) {
2229 goto mi_error;
2230 }
2231
2232 /* Instrumentation type. */
2233 ret = mi_lttng_writer_write_element_string(writer,
2234 mi_lttng_element_userspace_probe_location_function_instrumentation_type,
2235 instrumentation_type_str);
2236 if (ret) {
2237 goto mi_error;
2238 }
2239
2240 /* The lookup method. */
2241 ret_code = lttng_userspace_probe_location_lookup_method_mi_serialize(
2242 lookup_method, writer);
2243 if (ret_code != LTTNG_OK) {
2244 goto end;
2245 }
2246
2247 /* Close userspace probe location function element. */
2248 ret = mi_lttng_writer_close_element(writer);
2249 if (ret) {
2250 goto mi_error;
2251 }
2252
2253 ret_code = LTTNG_OK;
2254 goto end;
2255
2256mi_error:
2257 ret_code = LTTNG_ERR_MI_IO_FAIL;
2258end:
2259 return ret_code;
2260}
This page took 0.240898 seconds and 4 git commands to generate.