Commit | Line | Data |
---|---|---|
808cb744 JR |
1 | /* |
2 | * Copyright (C) 2020 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com> | |
3 | * | |
4 | * SPDX-License-Identifier: LGPL-2.1-only | |
5 | * | |
6 | */ | |
7 | ||
8 | #include "lttng/lttng-error.h" | |
9 | #include <assert.h> | |
10 | #include <common/error.h> | |
11 | #include <common/macros.h> | |
12 | #include <common/payload.h> | |
13 | #include <common/payload-view.h> | |
959e3c66 JR |
14 | #include <common/hashtable/hashtable.h> |
15 | #include <common/hashtable/utils.h> | |
808cb744 JR |
16 | #include <fcntl.h> |
17 | #include <lttng/constant.h> | |
18 | #include <lttng/kernel-probe.h> | |
19 | #include <lttng/kernel-probe-internal.h> | |
20 | #include <sys/stat.h> | |
21 | #include <sys/types.h> | |
22 | #include <sys/unistd.h> | |
23 | ||
24 | static | |
25 | int lttng_kernel_probe_location_address_serialize( | |
26 | const struct lttng_kernel_probe_location *location, | |
27 | struct lttng_payload *payload); | |
28 | ||
29 | static | |
30 | int lttng_kernel_probe_location_symbol_serialize( | |
31 | const struct lttng_kernel_probe_location *location, | |
32 | struct lttng_payload *payload); | |
33 | ||
34 | static | |
35 | bool lttng_kernel_probe_location_address_is_equal( | |
36 | const struct lttng_kernel_probe_location *a, | |
37 | const struct lttng_kernel_probe_location *b); | |
38 | ||
39 | static | |
40 | bool lttng_kernel_probe_location_symbol_is_equal( | |
41 | const struct lttng_kernel_probe_location *a, | |
42 | const struct lttng_kernel_probe_location *b); | |
43 | ||
959e3c66 JR |
44 | static |
45 | unsigned long lttng_kernel_probe_location_address_hash( | |
46 | const struct lttng_kernel_probe_location *location); | |
47 | ||
48 | static | |
49 | unsigned long lttng_kernel_probe_location_symbol_hash( | |
50 | const struct lttng_kernel_probe_location *location); | |
51 | ||
808cb744 JR |
52 | enum lttng_kernel_probe_location_type lttng_kernel_probe_location_get_type( |
53 | const struct lttng_kernel_probe_location *location) | |
54 | { | |
55 | return location ? location->type : | |
56 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_UNKNOWN; | |
57 | } | |
58 | ||
59 | static | |
60 | void lttng_kernel_probe_location_address_destroy( | |
61 | struct lttng_kernel_probe_location *location) | |
62 | { | |
63 | assert(location); | |
64 | free(location); | |
65 | } | |
66 | ||
67 | static | |
68 | void lttng_kernel_probe_location_symbol_destroy( | |
69 | struct lttng_kernel_probe_location *location) | |
70 | { | |
71 | struct lttng_kernel_probe_location_symbol *location_symbol = NULL; | |
72 | ||
73 | assert(location); | |
74 | ||
75 | location_symbol = container_of(location, | |
76 | struct lttng_kernel_probe_location_symbol, | |
77 | parent); | |
78 | ||
79 | assert(location_symbol); | |
80 | ||
81 | free(location_symbol->symbol_name); | |
82 | free(location); | |
83 | } | |
84 | ||
85 | void lttng_kernel_probe_location_destroy( | |
86 | struct lttng_kernel_probe_location *location) | |
87 | { | |
88 | if (!location) { | |
89 | return; | |
90 | } | |
91 | ||
92 | switch (location->type) { | |
93 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS: | |
94 | lttng_kernel_probe_location_address_destroy(location); | |
95 | break; | |
96 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET: | |
97 | lttng_kernel_probe_location_symbol_destroy(location); | |
98 | break; | |
99 | default: | |
100 | abort(); | |
101 | } | |
102 | } | |
103 | ||
104 | struct lttng_kernel_probe_location * | |
105 | lttng_kernel_probe_location_address_create(uint64_t address) | |
106 | { | |
107 | struct lttng_kernel_probe_location *ret = NULL; | |
108 | struct lttng_kernel_probe_location_address *location; | |
109 | ||
110 | location = zmalloc(sizeof(*location)); | |
111 | if (!location) { | |
077192fd | 112 | PERROR("Error allocating userspace probe location."); |
808cb744 JR |
113 | goto end; |
114 | } | |
115 | ||
116 | location->address = address; | |
117 | ||
118 | ret = &location->parent; | |
119 | ret->type = LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS; | |
120 | ret->equal = lttng_kernel_probe_location_address_is_equal; | |
121 | ret->serialize = lttng_kernel_probe_location_address_serialize; | |
959e3c66 | 122 | ret->hash = lttng_kernel_probe_location_address_hash; |
808cb744 JR |
123 | |
124 | end: | |
125 | return ret; | |
126 | } | |
127 | ||
128 | struct lttng_kernel_probe_location * | |
129 | lttng_kernel_probe_location_symbol_create(const char *symbol_name, | |
130 | uint64_t offset) | |
131 | { | |
132 | char *symbol_name_copy = NULL; | |
133 | struct lttng_kernel_probe_location *ret = NULL; | |
134 | struct lttng_kernel_probe_location_symbol *location; | |
135 | ||
136 | if (!symbol_name || strlen(symbol_name) >= LTTNG_SYMBOL_NAME_LEN) { | |
137 | goto error; | |
138 | } | |
139 | ||
140 | symbol_name_copy = strdup(symbol_name); | |
141 | if (!symbol_name_copy) { | |
142 | PERROR("Failed to copy symbol name '%s'", symbol_name); | |
143 | goto error; | |
144 | } | |
145 | ||
146 | location = zmalloc(sizeof(*location)); | |
147 | if (!location) { | |
148 | PERROR("Failed to allocate kernel symbol probe location"); | |
149 | goto error; | |
150 | } | |
151 | ||
152 | location->symbol_name = symbol_name_copy; | |
153 | location->offset = offset; | |
154 | ||
155 | ret = &location->parent; | |
156 | ret->type = LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET; | |
157 | ret->equal = lttng_kernel_probe_location_symbol_is_equal; | |
158 | ret->serialize = lttng_kernel_probe_location_symbol_serialize; | |
959e3c66 | 159 | ret->hash = lttng_kernel_probe_location_symbol_hash; |
808cb744 JR |
160 | goto end; |
161 | ||
162 | error: | |
163 | free(symbol_name_copy); | |
164 | end: | |
165 | return ret; | |
166 | } | |
167 | ||
168 | enum lttng_kernel_probe_location_status | |
169 | lttng_kernel_probe_location_address_get_address( | |
170 | const struct lttng_kernel_probe_location *location, | |
171 | uint64_t *offset) | |
172 | { | |
173 | enum lttng_kernel_probe_location_status ret = | |
174 | LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK; | |
175 | struct lttng_kernel_probe_location_address *address_location; | |
176 | ||
177 | assert(offset); | |
178 | ||
179 | if (!location || lttng_kernel_probe_location_get_type(location) != | |
180 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS) { | |
181 | ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); | |
182 | ret = LTTNG_KERNEL_PROBE_LOCATION_STATUS_INVALID; | |
183 | goto end; | |
184 | } | |
185 | ||
186 | address_location = container_of(location, | |
187 | struct lttng_kernel_probe_location_address, parent); | |
188 | *offset = address_location->address; | |
189 | end: | |
190 | return ret; | |
191 | } | |
192 | ||
193 | const char *lttng_kernel_probe_location_symbol_get_name( | |
194 | const struct lttng_kernel_probe_location *location) | |
195 | { | |
196 | const char *ret = NULL; | |
197 | struct lttng_kernel_probe_location_symbol *symbol_location; | |
198 | ||
199 | if (!location || lttng_kernel_probe_location_get_type(location) != | |
200 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET) { | |
201 | ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); | |
202 | goto end; | |
203 | } | |
204 | ||
205 | symbol_location = container_of(location, | |
206 | struct lttng_kernel_probe_location_symbol, parent); | |
207 | ret = symbol_location->symbol_name; | |
208 | end: | |
209 | return ret; | |
210 | } | |
211 | ||
212 | enum lttng_kernel_probe_location_status | |
213 | lttng_kernel_probe_location_symbol_get_offset( | |
214 | const struct lttng_kernel_probe_location *location, | |
215 | uint64_t *offset) | |
216 | { | |
217 | enum lttng_kernel_probe_location_status ret = | |
218 | LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK; | |
219 | struct lttng_kernel_probe_location_symbol *symbol_location; | |
220 | ||
221 | assert(offset); | |
222 | ||
223 | if (!location || lttng_kernel_probe_location_get_type(location) != | |
224 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET) { | |
225 | ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); | |
226 | ret = LTTNG_KERNEL_PROBE_LOCATION_STATUS_INVALID; | |
227 | goto end; | |
228 | } | |
229 | ||
230 | symbol_location = container_of(location, | |
231 | struct lttng_kernel_probe_location_symbol, parent); | |
232 | *offset = symbol_location->offset; | |
233 | end: | |
234 | return ret; | |
235 | } | |
236 | ||
237 | static | |
238 | int lttng_kernel_probe_location_symbol_serialize( | |
239 | const struct lttng_kernel_probe_location *location, | |
240 | struct lttng_payload *payload) | |
241 | { | |
242 | int ret; | |
243 | size_t symbol_name_len; | |
244 | size_t original_payload_size; | |
245 | struct lttng_kernel_probe_location_symbol *location_symbol; | |
246 | struct lttng_kernel_probe_location_symbol_comm location_symbol_comm; | |
247 | ||
248 | if (!location || !payload) { | |
249 | ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); | |
250 | ret = -LTTNG_ERR_INVALID; | |
251 | goto end; | |
252 | } | |
253 | ||
254 | assert(lttng_kernel_probe_location_get_type(location) == | |
255 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); | |
256 | ||
257 | original_payload_size = payload->buffer.size; | |
258 | location_symbol = container_of(location, | |
259 | struct lttng_kernel_probe_location_symbol, parent); | |
260 | ||
261 | if (!location_symbol->symbol_name) { | |
262 | ret = -LTTNG_ERR_INVALID; | |
263 | goto end; | |
264 | } | |
265 | ||
266 | symbol_name_len = strlen(location_symbol->symbol_name); | |
267 | if (symbol_name_len == 0) { | |
268 | ret = -LTTNG_ERR_INVALID; | |
269 | goto end; | |
270 | } | |
271 | ||
272 | location_symbol_comm.symbol_len = symbol_name_len + 1; | |
273 | location_symbol_comm.offset = location_symbol->offset; | |
274 | ||
275 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
276 | &location_symbol_comm, sizeof(location_symbol_comm)); | |
277 | if (ret) { | |
278 | ret = -LTTNG_ERR_INVALID; | |
279 | goto end; | |
280 | } | |
281 | ||
282 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
283 | location_symbol->symbol_name, | |
284 | location_symbol_comm.symbol_len); | |
285 | if (ret) { | |
286 | ret = -LTTNG_ERR_INVALID; | |
287 | goto end; | |
288 | } | |
289 | ||
290 | ret = (int) (payload->buffer.size - original_payload_size); | |
291 | end: | |
292 | return ret; | |
293 | } | |
294 | ||
295 | static | |
296 | int lttng_kernel_probe_location_address_serialize( | |
297 | const struct lttng_kernel_probe_location *location, | |
298 | struct lttng_payload *payload) | |
299 | { | |
300 | int ret; | |
301 | size_t original_payload_size; | |
302 | struct lttng_kernel_probe_location_address *location_address; | |
303 | struct lttng_kernel_probe_location_address_comm location_address_comm; | |
304 | ||
305 | assert(location); | |
306 | assert(lttng_kernel_probe_location_get_type(location) == | |
307 | LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); | |
308 | ||
309 | original_payload_size = payload->buffer.size; | |
310 | location_address = container_of(location, | |
311 | struct lttng_kernel_probe_location_address, | |
312 | parent); | |
313 | ||
314 | location_address_comm.address = location_address->address; | |
315 | ||
316 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
317 | &location_address_comm, | |
318 | sizeof(location_address_comm)); | |
319 | if (ret) { | |
320 | ret = -LTTNG_ERR_INVALID; | |
321 | goto end; | |
322 | } | |
323 | ||
324 | ret = (int) (payload->buffer.size - original_payload_size); | |
325 | end: | |
326 | return ret; | |
327 | } | |
328 | ||
329 | LTTNG_HIDDEN | |
330 | int lttng_kernel_probe_location_serialize( | |
331 | const struct lttng_kernel_probe_location *location, | |
332 | struct lttng_payload *payload) | |
333 | { | |
334 | int ret; | |
335 | size_t original_payload_size; | |
336 | struct lttng_kernel_probe_location_comm location_generic_comm = {}; | |
337 | ||
338 | if (!location || !payload) { | |
339 | ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); | |
340 | ret = -LTTNG_ERR_INVALID; | |
341 | goto end; | |
342 | } | |
343 | ||
344 | original_payload_size = payload->buffer.size; | |
345 | location_generic_comm.type = (int8_t) location->type; | |
346 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
347 | &location_generic_comm, | |
348 | sizeof(location_generic_comm)); | |
349 | if (ret) { | |
350 | goto end; | |
351 | } | |
352 | ||
353 | ret = location->serialize(location, payload); | |
354 | if (ret < 0) { | |
355 | goto end; | |
356 | } | |
357 | ||
358 | ret = (int) (payload->buffer.size - original_payload_size); | |
359 | end: | |
360 | return ret; | |
361 | } | |
362 | ||
363 | static | |
364 | int lttng_kernel_probe_location_symbol_create_from_payload( | |
365 | struct lttng_payload_view *view, | |
366 | struct lttng_kernel_probe_location **location) | |
367 | { | |
368 | struct lttng_kernel_probe_location_symbol_comm *location_symbol_comm; | |
369 | const char *symbol_name_src; | |
370 | ssize_t ret = 0; | |
371 | size_t expected_size; | |
372 | ||
373 | assert(location); | |
374 | ||
375 | if (view->buffer.size < sizeof(*location_symbol_comm)) { | |
376 | ret = -LTTNG_ERR_INVALID; | |
377 | goto end; | |
378 | } | |
379 | ||
380 | location_symbol_comm = | |
381 | (typeof(location_symbol_comm)) view->buffer.data; | |
382 | ||
383 | expected_size = sizeof(*location_symbol_comm) + | |
384 | location_symbol_comm->symbol_len; | |
385 | ||
386 | if (view->buffer.size < expected_size) { | |
387 | ret = -LTTNG_ERR_INVALID; | |
388 | goto end; | |
389 | } | |
390 | ||
391 | symbol_name_src = view->buffer.data + sizeof(*location_symbol_comm); | |
392 | ||
393 | if (!lttng_buffer_view_contains_string(&view->buffer, symbol_name_src, | |
394 | location_symbol_comm->symbol_len)) { | |
395 | ret = -LTTNG_ERR_INVALID; | |
396 | goto end; | |
397 | } | |
398 | ||
399 | *location = lttng_kernel_probe_location_symbol_create( | |
400 | symbol_name_src, location_symbol_comm->offset); | |
401 | if (!(*location)) { | |
402 | ret = -LTTNG_ERR_INVALID; | |
403 | goto end; | |
404 | } | |
405 | ||
406 | ret = (ssize_t) expected_size; | |
407 | end: | |
408 | return ret; | |
409 | } | |
410 | ||
411 | static | |
412 | ssize_t lttng_kernel_probe_location_address_create_from_payload( | |
413 | struct lttng_payload_view *view, | |
414 | struct lttng_kernel_probe_location **location) | |
415 | { | |
416 | struct lttng_kernel_probe_location_address_comm *location_address_comm; | |
417 | ssize_t ret = 0; | |
418 | size_t expected_size; | |
419 | ||
420 | assert(location); | |
421 | ||
422 | expected_size = sizeof(*location_address_comm); | |
423 | ||
424 | if (view->buffer.size < expected_size) { | |
425 | ret = -LTTNG_ERR_INVALID; | |
426 | goto end; | |
427 | } | |
428 | ||
429 | location_address_comm = | |
430 | (typeof(location_address_comm)) view->buffer.data; | |
431 | ||
432 | *location = lttng_kernel_probe_location_address_create(location_address_comm->address); | |
433 | if (!(*location)) { | |
434 | ret = -LTTNG_ERR_INVALID; | |
435 | goto end; | |
436 | } | |
437 | ||
438 | ret = (size_t) expected_size; | |
439 | end: | |
440 | return ret; | |
441 | } | |
442 | ||
443 | LTTNG_HIDDEN | |
444 | ssize_t lttng_kernel_probe_location_create_from_payload( | |
445 | struct lttng_payload_view *view, | |
446 | struct lttng_kernel_probe_location **location) | |
447 | { | |
808cb744 JR |
448 | enum lttng_kernel_probe_location_type type; |
449 | ssize_t consumed = 0; | |
450 | ssize_t ret; | |
3e6e0df2 JG |
451 | const struct lttng_kernel_probe_location_comm *probe_location_comm; |
452 | const struct lttng_payload_view probe_location_comm_view = | |
453 | lttng_payload_view_from_view( | |
454 | view, 0, sizeof(*probe_location_comm)); | |
808cb744 JR |
455 | |
456 | assert(view); | |
457 | assert(location); | |
458 | ||
3e6e0df2 | 459 | if (!lttng_payload_view_is_valid(&probe_location_comm_view)) { |
808cb744 JR |
460 | ret = -LTTNG_ERR_INVALID; |
461 | goto end; | |
462 | } | |
463 | ||
3e6e0df2 | 464 | probe_location_comm = (typeof(probe_location_comm)) probe_location_comm_view.buffer.data; |
808cb744 JR |
465 | type = (enum lttng_kernel_probe_location_type) probe_location_comm->type; |
466 | consumed += sizeof(*probe_location_comm); | |
467 | ||
468 | switch (type) { | |
469 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET: | |
470 | { | |
471 | struct lttng_payload_view location_view = | |
472 | lttng_payload_view_from_view( | |
473 | view, consumed, -1); | |
474 | ||
475 | ret = lttng_kernel_probe_location_symbol_create_from_payload( | |
476 | &location_view, location); | |
477 | break; | |
478 | } | |
479 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS: | |
480 | { | |
481 | struct lttng_payload_view location_view = | |
482 | lttng_payload_view_from_view(view, consumed, -1); | |
483 | ||
484 | ret = lttng_kernel_probe_location_address_create_from_payload( | |
485 | &location_view, location); | |
486 | break; | |
487 | } | |
488 | default: | |
489 | ret = -LTTNG_ERR_INVALID; | |
490 | break; | |
491 | } | |
492 | ||
493 | if (ret < 0) { | |
494 | ret = -LTTNG_ERR_INVALID; | |
495 | goto end; | |
496 | } | |
497 | ||
498 | ret += consumed; | |
499 | ||
500 | end: | |
501 | return ret; | |
502 | } | |
503 | ||
959e3c66 JR |
504 | static |
505 | unsigned long lttng_kernel_probe_location_address_hash( | |
506 | const struct lttng_kernel_probe_location *location) | |
507 | { | |
508 | unsigned long hash = hash_key_ulong( | |
509 | (void *) LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS, | |
510 | lttng_ht_seed); | |
511 | struct lttng_kernel_probe_location_address *address_location = | |
512 | container_of(location, typeof(*address_location), | |
513 | parent); | |
514 | ||
515 | hash ^= hash_key_u64(&address_location->address, lttng_ht_seed); | |
516 | ||
517 | return hash; | |
518 | } | |
519 | ||
808cb744 JR |
520 | static |
521 | bool lttng_kernel_probe_location_address_is_equal( | |
522 | const struct lttng_kernel_probe_location *_a, | |
523 | const struct lttng_kernel_probe_location *_b) | |
524 | { | |
525 | bool is_equal = false; | |
526 | struct lttng_kernel_probe_location_address *a, *b; | |
527 | ||
528 | a = container_of(_a, struct lttng_kernel_probe_location_address, | |
529 | parent); | |
530 | b = container_of(_b, struct lttng_kernel_probe_location_address, | |
531 | parent); | |
532 | ||
533 | if (a->address != b->address) { | |
534 | goto end; | |
535 | } | |
536 | ||
537 | is_equal = true; | |
538 | ||
539 | end: | |
540 | return is_equal; | |
541 | } | |
542 | ||
959e3c66 JR |
543 | static |
544 | unsigned long lttng_kernel_probe_location_symbol_hash( | |
545 | const struct lttng_kernel_probe_location *location) | |
546 | { | |
547 | unsigned long hash = hash_key_ulong( | |
548 | (void *) LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET, | |
549 | lttng_ht_seed); | |
550 | struct lttng_kernel_probe_location_symbol *symbol_location = | |
551 | container_of(location, typeof(*symbol_location), | |
552 | parent); | |
553 | ||
554 | hash ^= hash_key_str(symbol_location->symbol_name, lttng_ht_seed); | |
555 | hash ^= hash_key_u64(&symbol_location->offset, lttng_ht_seed); | |
556 | ||
557 | return hash; | |
558 | } | |
559 | ||
808cb744 JR |
560 | static |
561 | bool lttng_kernel_probe_location_symbol_is_equal( | |
562 | const struct lttng_kernel_probe_location *_a, | |
563 | const struct lttng_kernel_probe_location *_b) | |
564 | { | |
565 | bool is_equal = false; | |
566 | struct lttng_kernel_probe_location_symbol *a, *b; | |
567 | ||
568 | a = container_of(_a, struct lttng_kernel_probe_location_symbol, | |
569 | parent); | |
570 | b = container_of(_b, struct lttng_kernel_probe_location_symbol, | |
571 | parent); | |
572 | ||
573 | assert(a->symbol_name); | |
574 | assert(b->symbol_name); | |
575 | if (strcmp(a->symbol_name, b->symbol_name)) { | |
576 | goto end; | |
577 | } | |
578 | ||
579 | if (a->offset != b->offset) { | |
580 | goto end; | |
581 | } | |
582 | ||
583 | is_equal = true; | |
584 | ||
585 | end: | |
586 | return is_equal; | |
587 | } | |
588 | ||
589 | LTTNG_HIDDEN | |
590 | bool lttng_kernel_probe_location_is_equal( | |
591 | const struct lttng_kernel_probe_location *a, | |
592 | const struct lttng_kernel_probe_location *b) | |
593 | { | |
594 | bool is_equal = false; | |
595 | ||
596 | if (!a || !b) { | |
597 | goto end; | |
598 | } | |
599 | ||
600 | if (a == b) { | |
601 | is_equal = true; | |
602 | goto end; | |
603 | } | |
604 | ||
605 | if (a->type != b->type) { | |
606 | goto end; | |
607 | } | |
608 | ||
609 | is_equal = a->equal ? a->equal(a, b) : true; | |
610 | end: | |
611 | return is_equal; | |
612 | } | |
077192fd JR |
613 | |
614 | static struct lttng_kernel_probe_location * | |
615 | lttng_kernel_probe_location_symbol_copy( | |
616 | const struct lttng_kernel_probe_location *location) | |
617 | { | |
618 | struct lttng_kernel_probe_location *new_location = NULL; | |
619 | struct lttng_kernel_probe_location_symbol *symbol_location; | |
620 | enum lttng_kernel_probe_location_status status; | |
621 | const char *symbol_name = NULL; | |
622 | uint64_t offset; | |
623 | ||
624 | assert(location); | |
625 | assert(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); | |
626 | symbol_location = container_of( | |
627 | location, typeof(*symbol_location), parent); | |
628 | ||
629 | /* Get probe location offset */ | |
630 | status = lttng_kernel_probe_location_symbol_get_offset(location, &offset); | |
631 | if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) { | |
632 | ERR("Get kernel probe location offset failed."); | |
633 | goto error; | |
634 | } | |
635 | ||
636 | symbol_name = lttng_kernel_probe_location_symbol_get_name(location); | |
637 | if (!symbol_name) { | |
638 | ERR("Kernel probe symbol name is NULL."); | |
639 | goto error; | |
640 | } | |
641 | ||
642 | /* Create the probe_location */ | |
643 | new_location = lttng_kernel_probe_location_symbol_create( | |
644 | symbol_name, offset); | |
645 | ||
646 | goto end; | |
647 | ||
648 | error: | |
649 | new_location = NULL; | |
650 | end: | |
651 | return new_location; | |
652 | } | |
653 | static struct lttng_kernel_probe_location * | |
654 | lttng_kernel_probe_location_address_copy( | |
655 | const struct lttng_kernel_probe_location *location) | |
656 | { | |
657 | struct lttng_kernel_probe_location *new_location = NULL; | |
658 | struct lttng_kernel_probe_location_address *address_location; | |
659 | enum lttng_kernel_probe_location_status status; | |
660 | uint64_t address; | |
661 | ||
662 | assert(location); | |
663 | assert(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); | |
664 | address_location = container_of( | |
665 | location, typeof(*address_location), parent); | |
666 | ||
667 | ||
668 | /* Get probe location fields */ | |
669 | status = lttng_kernel_probe_location_address_get_address(location, &address); | |
670 | if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) { | |
671 | ERR("Get kernel probe address failed."); | |
672 | goto error; | |
673 | } | |
674 | ||
675 | /* Create the probe_location */ | |
676 | new_location = lttng_kernel_probe_location_address_create(address); | |
677 | ||
678 | goto end; | |
679 | ||
680 | error: | |
681 | new_location = NULL; | |
682 | end: | |
683 | return new_location; | |
684 | } | |
685 | ||
686 | LTTNG_HIDDEN | |
687 | struct lttng_kernel_probe_location *lttng_kernel_probe_location_copy( | |
688 | const struct lttng_kernel_probe_location *location) | |
689 | { | |
690 | struct lttng_kernel_probe_location *new_location = NULL; | |
691 | enum lttng_kernel_probe_location_type type; | |
692 | ||
693 | if (!location) { | |
694 | goto err; | |
695 | } | |
696 | ||
697 | type = lttng_kernel_probe_location_get_type(location); | |
698 | switch (type) { | |
699 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS: | |
700 | new_location = | |
701 | lttng_kernel_probe_location_address_copy(location); | |
702 | if (!new_location) { | |
703 | goto err; | |
704 | } | |
705 | break; | |
706 | case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET: | |
707 | new_location = | |
708 | lttng_kernel_probe_location_symbol_copy(location); | |
709 | if (!new_location) { | |
710 | goto err; | |
711 | } | |
712 | break; | |
713 | default: | |
714 | new_location = NULL; | |
715 | goto err; | |
716 | } | |
717 | err: | |
718 | return new_location; | |
719 | } | |
959e3c66 JR |
720 | |
721 | LTTNG_HIDDEN | |
722 | unsigned long lttng_kernel_probe_location_hash( | |
723 | const struct lttng_kernel_probe_location *location) | |
724 | { | |
725 | return location->hash(location); | |
726 | } |