SoW-2019-0002: Dynamic Snapshot
[lttng-tools.git] / src / common / lttng-elf.c
1 /*
2 * Copyright (C) 2015 Antoine Busque <abusque@efficios.com>
3 * Copyright (C) 2017 Francis Deslauriers <francis.deslauriers@efficios.com>
4 * Copyright (C) 2017 Erica Bugden <erica.bugden@efficios.com>
5 *
6 * SPDX-License-Identifier: LGPL-2.1-or-later
7 *
8 */
9
10 #include <common/compat/endian.h>
11 #include <common/error.h>
12 #include <common/lttng-elf.h>
13 #include <common/macros.h>
14 #include <common/readwrite.h>
15 #include <fcntl.h>
16 #include <stdbool.h>
17 #include <stdint.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include <unistd.h>
23
24 #include <elf.h>
25
26 #define BUF_LEN 4096
27 #define TEXT_SECTION_NAME ".text"
28 #define SYMBOL_TAB_SECTION_NAME ".symtab"
29 #define STRING_TAB_SECTION_NAME ".strtab"
30 #define DYNAMIC_SYMBOL_TAB_SECTION_NAME ".dynsym"
31 #define DYNAMIC_STRING_TAB_SECTION_NAME ".dynstr"
32 #define NOTE_STAPSDT_SECTION_NAME ".note.stapsdt"
33 #define NOTE_STAPSDT_NAME "stapsdt"
34 #define NOTE_STAPSDT_TYPE 3
35 #define MAX_SECTION_DATA_SIZE 512 * 1024 * 1024
36
37 #if BYTE_ORDER == LITTLE_ENDIAN
38 #define NATIVE_ELF_ENDIANNESS ELFDATA2LSB
39 #else
40 #define NATIVE_ELF_ENDIANNESS ELFDATA2MSB
41 #endif
42
43 #define next_4bytes_boundary(x) (typeof(x)) ((((uint64_t)x) + 3) & ~0x03)
44
45 #define bswap(x) \
46 do { \
47 switch (sizeof(x)) { \
48 case 8: \
49 x = be64toh((uint64_t)x); \
50 break; \
51 case 4: \
52 x = be32toh((uint32_t)x); \
53 break; \
54 case 2: \
55 x = be16toh((uint16_t)x); \
56 break; \
57 case 1: \
58 break; \
59 default: \
60 abort(); \
61 } \
62 } while (0)
63
64 #define bswap_shdr(shdr) \
65 do { \
66 bswap((shdr).sh_name); \
67 bswap((shdr).sh_type); \
68 bswap((shdr).sh_flags); \
69 bswap((shdr).sh_addr); \
70 bswap((shdr).sh_offset); \
71 bswap((shdr).sh_size); \
72 bswap((shdr).sh_link); \
73 bswap((shdr).sh_info); \
74 bswap((shdr).sh_addralign); \
75 bswap((shdr).sh_entsize); \
76 } while (0)
77
78 #define bswap_ehdr(ehdr) \
79 do { \
80 bswap((ehdr).e_type); \
81 bswap((ehdr).e_machine); \
82 bswap((ehdr).e_version); \
83 bswap((ehdr).e_entry); \
84 bswap((ehdr).e_phoff); \
85 bswap((ehdr).e_shoff); \
86 bswap((ehdr).e_flags); \
87 bswap((ehdr).e_ehsize); \
88 bswap((ehdr).e_phentsize); \
89 bswap((ehdr).e_phnum); \
90 bswap((ehdr).e_shentsize); \
91 bswap((ehdr).e_shnum); \
92 bswap((ehdr).e_shstrndx); \
93 } while (0)
94
95 #define copy_shdr(src_shdr, dst_shdr) \
96 do { \
97 (dst_shdr).sh_name = (src_shdr).sh_name; \
98 (dst_shdr).sh_type = (src_shdr).sh_type; \
99 (dst_shdr).sh_flags = (src_shdr).sh_flags; \
100 (dst_shdr).sh_addr = (src_shdr).sh_addr; \
101 (dst_shdr).sh_offset = (src_shdr).sh_offset; \
102 (dst_shdr).sh_size = (src_shdr).sh_size; \
103 (dst_shdr).sh_link = (src_shdr).sh_link; \
104 (dst_shdr).sh_info = (src_shdr).sh_info; \
105 (dst_shdr).sh_addralign = (src_shdr).sh_addralign; \
106 (dst_shdr).sh_entsize = (src_shdr).sh_entsize; \
107 } while (0)
108
109 #define copy_ehdr(src_ehdr, dst_ehdr) \
110 do { \
111 (dst_ehdr).e_type = (src_ehdr).e_type; \
112 (dst_ehdr).e_machine = (src_ehdr).e_machine; \
113 (dst_ehdr).e_version = (src_ehdr).e_version; \
114 (dst_ehdr).e_entry = (src_ehdr).e_entry; \
115 (dst_ehdr).e_phoff = (src_ehdr).e_phoff; \
116 (dst_ehdr).e_shoff = (src_ehdr).e_shoff; \
117 (dst_ehdr).e_flags = (src_ehdr).e_flags; \
118 (dst_ehdr).e_ehsize = (src_ehdr).e_ehsize; \
119 (dst_ehdr).e_phentsize = (src_ehdr).e_phentsize; \
120 (dst_ehdr).e_phnum = (src_ehdr).e_phnum; \
121 (dst_ehdr).e_shentsize = (src_ehdr).e_shentsize; \
122 (dst_ehdr).e_shnum = (src_ehdr).e_shnum; \
123 (dst_ehdr).e_shstrndx = (src_ehdr).e_shstrndx; \
124 } while (0)
125
126 #define copy_sym(src_sym, dst_sym) \
127 do { \
128 dst_sym.st_name = src_sym.st_name; \
129 dst_sym.st_info = src_sym.st_info; \
130 dst_sym.st_other = src_sym.st_other; \
131 dst_sym.st_shndx = src_sym.st_shndx; \
132 dst_sym.st_value = src_sym.st_value; \
133 dst_sym.st_size = src_sym.st_size; \
134 } while (0)
135
136 /* Both 32bit and 64bit use the same 1 byte field for type. (See elf.h) */
137 #define ELF_ST_TYPE(val) ELF32_ST_TYPE(val)
138
139 struct lttng_elf_ehdr {
140 uint16_t e_type;
141 uint16_t e_machine;
142 uint32_t e_version;
143 uint64_t e_entry;
144 uint64_t e_phoff;
145 uint64_t e_shoff;
146 uint32_t e_flags;
147 uint16_t e_ehsize;
148 uint16_t e_phentsize;
149 uint16_t e_phnum;
150 uint16_t e_shentsize;
151 uint16_t e_shnum;
152 uint16_t e_shstrndx;
153 };
154
155 struct lttng_elf_shdr {
156 uint32_t sh_name;
157 uint32_t sh_type;
158 uint64_t sh_flags;
159 uint64_t sh_addr;
160 uint64_t sh_offset;
161 uint64_t sh_size;
162 uint32_t sh_link;
163 uint32_t sh_info;
164 uint64_t sh_addralign;
165 uint64_t sh_entsize;
166 };
167
168 /*
169 * This struct can hold both 32bit and 64bit symbol description. It's used with
170 * the copy_sym() macro. Using this abstraction, we can use the same code for
171 * both bitness.
172 */
173 struct lttng_elf_sym {
174 uint32_t st_name;
175 uint8_t st_info;
176 uint8_t st_other;
177 uint16_t st_shndx;
178 uint64_t st_value;
179 uint64_t st_size;
180 };
181
182 struct lttng_elf {
183 int fd;
184 size_t file_size;
185 uint8_t bitness;
186 uint8_t endianness;
187 /* Offset in bytes to start of section names string table. */
188 off_t section_names_offset;
189 /* Size in bytes of section names string table. */
190 size_t section_names_size;
191 struct lttng_elf_ehdr *ehdr;
192 };
193
194 static inline
195 int is_elf_32_bit(struct lttng_elf *elf)
196 {
197 return elf->bitness == ELFCLASS32;
198 }
199
200 static inline
201 int is_elf_native_endian(struct lttng_elf *elf)
202 {
203 return elf->endianness == NATIVE_ELF_ENDIANNESS;
204 }
205
206 static
207 int populate_section_header(struct lttng_elf * elf, struct lttng_elf_shdr *shdr,
208 uint32_t index)
209 {
210 int ret = 0;
211 off_t offset;
212
213 /* Compute the offset of the section in the file */
214 offset = (off_t) elf->ehdr->e_shoff
215 + (off_t) index * elf->ehdr->e_shentsize;
216
217 if (lseek(elf->fd, offset, SEEK_SET) < 0) {
218 PERROR("Error seeking to the beginning of ELF section header");
219 ret = -1;
220 goto error;
221 }
222
223 if (is_elf_32_bit(elf)) {
224 Elf32_Shdr elf_shdr;
225
226 if (lttng_read(elf->fd, &elf_shdr, sizeof(elf_shdr)) < sizeof(elf_shdr)) {
227 PERROR("Error reading ELF section header");
228 ret = -1;
229 goto error;
230 }
231 if (!is_elf_native_endian(elf)) {
232 bswap_shdr(elf_shdr);
233 }
234 copy_shdr(elf_shdr, *shdr);
235 } else {
236 Elf64_Shdr elf_shdr;
237
238 if (lttng_read(elf->fd, &elf_shdr, sizeof(elf_shdr)) < sizeof(elf_shdr)) {
239 PERROR("Error reading ELF section header");
240 ret = -1;
241 goto error;
242 }
243 if (!is_elf_native_endian(elf)) {
244 bswap_shdr(elf_shdr);
245 }
246 copy_shdr(elf_shdr, *shdr);
247 }
248
249 error:
250 return ret;
251 }
252
253 static
254 int populate_elf_header(struct lttng_elf *elf)
255 {
256 int ret = 0;
257
258 /*
259 * Move the read pointer back to the beginning to read the full header
260 * and copy it in our structure.
261 */
262 if (lseek(elf->fd, 0, SEEK_SET) < 0) {
263 PERROR("Error seeking to the beginning of the file");
264 ret = -1;
265 goto error;
266 }
267
268 /*
269 * Use macros to set fields in the ELF header struct for both 32bit and
270 * 64bit.
271 */
272 if (is_elf_32_bit(elf)) {
273 Elf32_Ehdr elf_ehdr;
274
275 if (lttng_read(elf->fd, &elf_ehdr, sizeof(elf_ehdr)) < sizeof(elf_ehdr)) {
276 ret = -1;
277 goto error;
278 }
279 if (!is_elf_native_endian(elf)) {
280 bswap_ehdr(elf_ehdr);
281 }
282 copy_ehdr(elf_ehdr, *(elf->ehdr));
283 } else {
284 Elf64_Ehdr elf_ehdr;
285
286 if (lttng_read(elf->fd, &elf_ehdr, sizeof(elf_ehdr)) < sizeof(elf_ehdr)) {
287 ret = -1;
288 goto error;
289 }
290 if (!is_elf_native_endian(elf)) {
291 bswap_ehdr(elf_ehdr);
292 }
293 copy_ehdr(elf_ehdr, *(elf->ehdr));
294 }
295 error:
296 return ret;
297 }
298
299 /*
300 * Retrieve the nth (where n is the `index` argument) shdr (section
301 * header) from the given elf instance.
302 *
303 * 0 is returned on succes, -1 on failure.
304 */
305 static
306 int lttng_elf_get_section_hdr(struct lttng_elf *elf,
307 uint16_t index, struct lttng_elf_shdr *out_header)
308 {
309 int ret = 0;
310
311 if (!elf) {
312 ret = -1;
313 goto error;
314 }
315
316 if (index >= elf->ehdr->e_shnum) {
317 ret = -1;
318 goto error;
319 }
320
321 ret = populate_section_header(elf, out_header, index);
322 if (ret) {
323 DBG("Error populating section header.");
324 goto error;
325 }
326
327 error:
328 return ret;
329 }
330
331 /*
332 * Lookup a section's name from a given offset (usually from an shdr's
333 * sh_name value) in bytes relative to the beginning of the section
334 * names string table.
335 *
336 * If no name is found, NULL is returned.
337 */
338 static
339 char *lttng_elf_get_section_name(struct lttng_elf *elf, off_t offset)
340 {
341 char *name = NULL;
342 size_t name_length = 0, to_read; /* name_length does not include \0 */
343
344 if (!elf) {
345 goto error;
346 }
347
348 if (offset >= elf->section_names_size) {
349 goto error;
350 }
351
352 if (lseek(elf->fd, elf->section_names_offset + offset, SEEK_SET) < 0) {
353 PERROR("Error seeking to the beginning of ELF string table section");
354 goto error;
355 }
356
357 to_read = elf->section_names_size - offset;
358
359 /* Find first \0 after or at current location, remember name_length. */
360 for (;;) {
361 char buf[BUF_LEN];
362 ssize_t read_len;
363 size_t i;
364
365 if (!to_read) {
366 goto error;
367 }
368 read_len = lttng_read(elf->fd, buf, min_t(size_t, BUF_LEN, to_read));
369 if (read_len <= 0) {
370 PERROR("Error reading ELF string table section");
371 goto error;
372 }
373 for (i = 0; i < read_len; i++) {
374 if (buf[i] == '\0') {
375 name_length += i;
376 goto end;
377 }
378 }
379 name_length += read_len;
380 to_read -= read_len;
381 }
382 end:
383 /*
384 * We found the length of the section name, now seek back to the
385 * beginning of the name and copy it in the newly allocated buffer.
386 */
387 name = zmalloc(sizeof(char) * (name_length + 1)); /* + 1 for \0 */
388 if (!name) {
389 PERROR("Error allocating ELF section name buffer");
390 goto error;
391 }
392 if (lseek(elf->fd, elf->section_names_offset + offset, SEEK_SET) < 0) {
393 PERROR("Error seeking to the offset of the ELF section name");
394 goto error;
395 }
396 if (lttng_read(elf->fd, name, name_length + 1) < name_length + 1) {
397 PERROR("Error reading the ELF section name");
398 goto error;
399 }
400
401 return name;
402
403 error:
404 free(name);
405 return NULL;
406 }
407
408 static
409 int lttng_elf_validate_and_populate(struct lttng_elf *elf)
410 {
411 uint8_t version;
412 uint8_t e_ident[EI_NIDENT];
413 uint8_t *magic_number = NULL;
414 int ret = 0;
415
416 if (elf->fd == -1) {
417 DBG("fd error");
418 ret = LTTNG_ERR_ELF_PARSING;
419 goto end;
420 }
421
422 /*
423 * First read the magic number, endianness and version to later populate
424 * the ELF header with the correct endianness and bitness.
425 * (see elf.h)
426 */
427
428 if (lseek(elf->fd, 0, SEEK_SET) < 0) {
429 PERROR("Error seeking the beginning of ELF file");
430 ret = LTTNG_ERR_ELF_PARSING;
431 goto end;
432 }
433 ret = lttng_read(elf->fd, e_ident, EI_NIDENT);
434 if (ret < EI_NIDENT) {
435 DBG("Error reading the ELF identification fields");
436 if (ret == -1) {
437 PERROR("Error reading the ELF identification fields");
438 }
439 ret = LTTNG_ERR_ELF_PARSING;
440 goto end;
441 }
442
443 /*
444 * Copy fields used to check that the target file is in fact a valid ELF
445 * file.
446 */
447 elf->bitness = e_ident[EI_CLASS];
448 elf->endianness = e_ident[EI_DATA];
449 version = e_ident[EI_VERSION];
450 magic_number = &e_ident[EI_MAG0];
451
452 /*
453 * Check the magic number.
454 */
455 if (memcmp(magic_number, ELFMAG, SELFMAG) != 0) {
456 DBG("Error check ELF magic number.");
457 ret = LTTNG_ERR_ELF_PARSING;
458 goto end;
459 }
460
461 /*
462 * Check the bitness is either ELFCLASS32 or ELFCLASS64.
463 */
464 if (elf->bitness <= ELFCLASSNONE || elf->bitness >= ELFCLASSNUM) {
465 DBG("ELF class error.");
466 ret = LTTNG_ERR_ELF_PARSING;
467 goto end;
468 }
469
470 /*
471 * Check the endianness is either ELFDATA2LSB or ELFDATA2MSB.
472 */
473 if (elf->endianness <= ELFDATANONE || elf->endianness >= ELFDATANUM) {
474 DBG("ELF endianness error.");
475 ret = LTTNG_ERR_ELF_PARSING;
476 goto end;
477 }
478
479 /*
480 * Check the version is ELF_CURRENT.
481 */
482 if (version <= EV_NONE || version >= EV_NUM) {
483 DBG("Wrong ELF version.");
484 ret = LTTNG_ERR_ELF_PARSING;
485 goto end;
486 }
487
488 elf->ehdr = zmalloc(sizeof(struct lttng_elf_ehdr));
489 if (!elf->ehdr) {
490 PERROR("Error allocation buffer for ELF header");
491 ret = LTTNG_ERR_NOMEM;
492 goto end;
493 }
494
495 /*
496 * Copy the content of the elf header.
497 */
498 ret = populate_elf_header(elf);
499 if (ret) {
500 DBG("Error reading ELF header,");
501 goto free_elf_error;
502 }
503
504 goto end;
505
506 free_elf_error:
507 free(elf->ehdr);
508 elf->ehdr = NULL;
509 end:
510 return ret;
511 }
512
513 /*
514 * Create an instance of lttng_elf for the ELF file located at
515 * `path`.
516 *
517 * Return a pointer to the instance on success, NULL on failure.
518 */
519 static
520 struct lttng_elf *lttng_elf_create(int fd)
521 {
522 struct lttng_elf_shdr section_names_shdr;
523 struct lttng_elf *elf = NULL;
524 int ret;
525 struct stat stat_buf;
526
527 if (fd < 0) {
528 goto error;
529 }
530
531 ret = fstat(fd, &stat_buf);
532 if (ret) {
533 PERROR("Failed to determine size of elf file");
534 goto error;
535 }
536 if (!S_ISREG(stat_buf.st_mode)) {
537 ERR("Refusing to initialize lttng_elf from non-regular file");
538 goto error;
539 }
540
541 elf = zmalloc(sizeof(struct lttng_elf));
542 if (!elf) {
543 PERROR("Error allocating struct lttng_elf");
544 goto error;
545 }
546 elf->file_size = (size_t) stat_buf.st_size;
547
548 elf->fd = dup(fd);
549 if (elf->fd < 0) {
550 PERROR("Error duplicating file descriptor to binary");
551 goto error;
552 }
553
554 ret = lttng_elf_validate_and_populate(elf);
555 if (ret) {
556 goto error;
557 }
558
559 ret = lttng_elf_get_section_hdr(
560 elf, elf->ehdr->e_shstrndx, &section_names_shdr);
561 if (ret) {
562 goto error;
563 }
564
565 elf->section_names_offset = section_names_shdr.sh_offset;
566 elf->section_names_size = section_names_shdr.sh_size;
567 return elf;
568
569 error:
570 if (elf) {
571 if (elf->ehdr) {
572 free(elf->ehdr);
573 }
574 if (elf->fd >= 0) {
575 if (close(elf->fd)) {
576 PERROR("Error closing file descriptor in error path");
577 abort();
578 }
579 }
580 free(elf);
581 }
582 return NULL;
583 }
584
585 /*
586 * Destroy the given lttng_elf instance.
587 */
588 static
589 void lttng_elf_destroy(struct lttng_elf *elf)
590 {
591 if (!elf) {
592 return;
593 }
594
595 free(elf->ehdr);
596 if (close(elf->fd)) {
597 PERROR("Error closing file description in error path");
598 abort();
599 }
600 free(elf);
601 }
602
603 static
604 int lttng_elf_get_section_hdr_by_name(struct lttng_elf *elf,
605 const char *section_name, struct lttng_elf_shdr *section_hdr)
606 {
607 int i;
608 char *curr_section_name;
609
610 for (i = 0; i < elf->ehdr->e_shnum; ++i) {
611 bool name_equal;
612 int ret = lttng_elf_get_section_hdr(elf, i, section_hdr);
613
614 if (ret) {
615 break;
616 }
617 curr_section_name = lttng_elf_get_section_name(elf,
618 section_hdr->sh_name);
619 if (!curr_section_name) {
620 continue;
621 }
622 name_equal = strcmp(curr_section_name, section_name) == 0;
623 free(curr_section_name);
624 if (name_equal) {
625 return 0;
626 }
627 }
628 return LTTNG_ERR_ELF_PARSING;
629 }
630
631 static
632 char *lttng_elf_get_section_data(struct lttng_elf *elf,
633 struct lttng_elf_shdr *shdr)
634 {
635 int ret;
636 off_t section_offset;
637 char *data;
638 size_t max_alloc_size;
639
640 if (!elf || !shdr) {
641 goto error;
642 }
643
644 max_alloc_size = min_t(size_t, MAX_SECTION_DATA_SIZE, elf->file_size);
645
646 section_offset = shdr->sh_offset;
647 if (lseek(elf->fd, section_offset, SEEK_SET) < 0) {
648 PERROR("Error seeking to section offset");
649 goto error;
650 }
651
652 if (shdr->sh_size > max_alloc_size) {
653 ERR("ELF section size exceeds maximal allowed size of %zu bytes",
654 max_alloc_size);
655 goto error;
656 }
657 data = zmalloc(shdr->sh_size);
658 if (!data) {
659 PERROR("Error allocating buffer for ELF section data");
660 goto error;
661 }
662 ret = lttng_read(elf->fd, data, shdr->sh_size);
663 if (ret == -1) {
664 PERROR("Error reading ELF section data");
665 goto free_error;
666 }
667
668 return data;
669
670 free_error:
671 free(data);
672 error:
673 return NULL;
674 }
675
676 /*
677 * Convert the virtual address in a binary's mapping to the offset of
678 * the corresponding instruction in the binary file.
679 * This function assumes the address is in the text section.
680 *
681 * Returns the offset on success or non-zero in case of failure.
682 */
683 static
684 int lttng_elf_convert_addr_in_text_to_offset(struct lttng_elf *elf_handle,
685 size_t addr, uint64_t *offset)
686 {
687 int ret = 0;
688 off_t text_section_offset;
689 off_t text_section_addr_beg;
690 off_t text_section_addr_end;
691 off_t offset_in_section;
692 struct lttng_elf_shdr text_section_hdr;
693
694 if (!elf_handle) {
695 DBG("Invalid ELF handle.");
696 ret = LTTNG_ERR_ELF_PARSING;
697 goto error;
698 }
699
700 /* Get a pointer to the .text section header. */
701 ret = lttng_elf_get_section_hdr_by_name(elf_handle,
702 TEXT_SECTION_NAME, &text_section_hdr);
703 if (ret) {
704 DBG("Text section not found in binary.");
705 ret = LTTNG_ERR_ELF_PARSING;
706 goto error;
707 }
708
709 text_section_offset = text_section_hdr.sh_offset;
710 text_section_addr_beg = text_section_hdr.sh_addr;
711 text_section_addr_end =
712 text_section_addr_beg + text_section_hdr.sh_size;
713
714 /*
715 * Verify that the address is within the .text section boundaries.
716 */
717 if (addr < text_section_addr_beg || addr > text_section_addr_end) {
718 DBG("Address found is outside of the .text section addr=0x%zx, "
719 ".text section=[0x%jd - 0x%jd].", addr, (intmax_t)text_section_addr_beg,
720 (intmax_t)text_section_addr_end);
721 ret = LTTNG_ERR_ELF_PARSING;
722 goto error;
723 }
724
725 offset_in_section = addr - text_section_addr_beg;
726
727 /*
728 * Add the target offset in the text section to the offset of this text
729 * section from the beginning of the binary file.
730 */
731 *offset = text_section_offset + offset_in_section;
732
733 error:
734 return ret;
735 }
736
737 /*
738 * Compute the offset of a symbol from the begining of the ELF binary.
739 *
740 * On success, returns 0 offset parameter is set to the computed value
741 * On failure, returns -1.
742 */
743 int lttng_elf_get_symbol_offset(int fd, char *symbol, uint64_t *offset)
744 {
745 int ret = 0;
746 int sym_found = 0;
747 int sym_count = 0;
748 int sym_idx = 0;
749 uint64_t addr = 0;
750 char *curr_sym_str = NULL;
751 char *symbol_table_data = NULL;
752 char *string_table_data = NULL;
753 const char *string_table_name = NULL;
754 struct lttng_elf_shdr symtab_hdr;
755 struct lttng_elf_shdr strtab_hdr;
756 struct lttng_elf *elf = NULL;
757
758 if (!symbol || !offset ) {
759 ret = LTTNG_ERR_ELF_PARSING;
760 goto end;
761 }
762
763 elf = lttng_elf_create(fd);
764 if (!elf) {
765 ret = LTTNG_ERR_ELF_PARSING;
766 goto end;
767 }
768
769 /*
770 * The .symtab section might not exist on stripped binaries.
771 * Try to get the symbol table section header first. If it's absent,
772 * try to get the dynamic symbol table. All symbols in the dynamic
773 * symbol tab are in the (normal) symbol table if it exists.
774 */
775 ret = lttng_elf_get_section_hdr_by_name(elf, SYMBOL_TAB_SECTION_NAME,
776 &symtab_hdr);
777 if (ret) {
778 DBG("Cannot get ELF Symbol Table section. Trying to get ELF Dynamic Symbol Table section.");
779 /* Get the dynamic symbol table section header. */
780 ret = lttng_elf_get_section_hdr_by_name(elf, DYNAMIC_SYMBOL_TAB_SECTION_NAME,
781 &symtab_hdr);
782 if (ret) {
783 DBG("Cannot get ELF Symbol Table nor Dynamic Symbol Table sections.");
784 ret = LTTNG_ERR_ELF_PARSING;
785 goto destroy_elf;
786 }
787 string_table_name = DYNAMIC_STRING_TAB_SECTION_NAME;
788 } else {
789 string_table_name = STRING_TAB_SECTION_NAME;
790 }
791
792 /* Get the data associated with the symbol table section. */
793 symbol_table_data = lttng_elf_get_section_data(elf, &symtab_hdr);
794 if (symbol_table_data == NULL) {
795 DBG("Cannot get ELF Symbol Table data.");
796 ret = LTTNG_ERR_ELF_PARSING;
797 goto destroy_elf;
798 }
799
800 /* Get the string table section header. */
801 ret = lttng_elf_get_section_hdr_by_name(elf, string_table_name,
802 &strtab_hdr);
803 if (ret) {
804 DBG("Cannot get ELF string table section.");
805 goto free_symbol_table_data;
806 }
807
808 /* Get the data associated with the string table section. */
809 string_table_data = lttng_elf_get_section_data(elf, &strtab_hdr);
810 if (string_table_data == NULL) {
811 DBG("Cannot get ELF string table section data.");
812 ret = LTTNG_ERR_ELF_PARSING;
813 goto free_symbol_table_data;
814 }
815
816 /* Get the number of symbol in the table for the iteration. */
817 sym_count = symtab_hdr.sh_size / symtab_hdr.sh_entsize;
818
819 /* Loop over all symbol. */
820 for (sym_idx = 0; sym_idx < sym_count; sym_idx++) {
821 struct lttng_elf_sym curr_sym;
822
823 /* Get the symbol at the current index. */
824 if (is_elf_32_bit(elf)) {
825 Elf32_Sym tmp = ((Elf32_Sym *) symbol_table_data)[sym_idx];
826 copy_sym(tmp, curr_sym);
827 } else {
828 Elf64_Sym tmp = ((Elf64_Sym *) symbol_table_data)[sym_idx];
829 copy_sym(tmp, curr_sym);
830 }
831
832 /*
833 * If the st_name field is zero, there is no string name for
834 * this symbol; skip to the next symbol.
835 */
836 if (curr_sym.st_name == 0) {
837 continue;
838 }
839
840 /*
841 * Use the st_name field in the lttng_elf_sym struct to get offset of
842 * the symbol's name from the beginning of the string table.
843 */
844 curr_sym_str = string_table_data + curr_sym.st_name;
845
846 /*
847 * If the current symbol is not a function; skip to the next symbol.
848 */
849 if (ELF_ST_TYPE(curr_sym.st_info) != STT_FUNC) {
850 continue;
851 }
852
853 /*
854 * Compare with the search symbol. If there is a match set the address
855 * output parameter and return success.
856 */
857 if (strcmp(symbol, curr_sym_str) == 0 ) {
858 sym_found = 1;
859 addr = curr_sym.st_value;
860 break;
861 }
862 }
863
864 if (!sym_found) {
865 DBG("Symbol not found.");
866 ret = LTTNG_ERR_ELF_PARSING;
867 goto free_string_table_data;
868 }
869
870 /*
871 * Use the virtual address of the symbol to compute the offset of this
872 * symbol from the beginning of the executable file.
873 */
874 ret = lttng_elf_convert_addr_in_text_to_offset(elf, addr, offset);
875 if (ret) {
876 DBG("Cannot convert addr to offset.");
877 goto free_string_table_data;
878 }
879
880
881 free_string_table_data:
882 free(string_table_data);
883 free_symbol_table_data:
884 free(symbol_table_data);
885 destroy_elf:
886 lttng_elf_destroy(elf);
887 end:
888 return ret;
889 }
890
891 /*
892 * Compute the offsets of SDT probes from the begining of the ELF binary.
893 *
894 * On success, returns 0 and the nb_probes parameter is set to the number of
895 * offsets found and the offsets parameter points to an array of offsets where
896 * the SDT probes are.
897 * On failure, returns -1.
898 */
899 int lttng_elf_get_sdt_probe_offsets(int fd, const char *provider_name,
900 const char *probe_name, uint64_t **offsets, uint32_t *nb_probes)
901 {
902 int ret = 0, nb_match = 0;
903 struct lttng_elf_shdr stap_note_section_hdr;
904 struct lttng_elf *elf = NULL;
905 char *stap_note_section_data = NULL;
906 char *curr_note_section_begin, *curr_data_ptr, *curr_probe, *curr_provider;
907 char *next_note_ptr;
908 uint32_t name_size, desc_size, note_type;
909 uint64_t curr_probe_location, curr_probe_offset, curr_semaphore_location;
910 uint64_t *probe_locs = NULL, *new_probe_locs = NULL;
911
912 if (!provider_name || !probe_name || !nb_probes || !offsets) {
913 DBG("Invalid arguments.");
914 ret = LTTNG_ERR_ELF_PARSING;
915 goto error;
916 }
917
918 elf = lttng_elf_create(fd);
919 if (!elf) {
920 DBG("Error allocation ELF.");
921 ret = LTTNG_ERR_ELF_PARSING;
922 goto error;
923 }
924
925 /* Get the stap note section header. */
926 ret = lttng_elf_get_section_hdr_by_name(elf, NOTE_STAPSDT_SECTION_NAME,
927 &stap_note_section_hdr);
928 if (ret) {
929 DBG("Cannot get ELF stap note section.");
930 goto destroy_elf_error;
931 }
932
933 /* Get the data associated with the stap note section. */
934 stap_note_section_data =
935 lttng_elf_get_section_data(elf, &stap_note_section_hdr);
936 if (stap_note_section_data == NULL) {
937 DBG("Cannot get ELF stap note section data.");
938 ret = LTTNG_ERR_ELF_PARSING;
939 goto destroy_elf_error;
940 }
941
942 next_note_ptr = stap_note_section_data;
943 curr_note_section_begin = stap_note_section_data;
944
945 *offsets = NULL;
946 while (1) {
947 curr_data_ptr = next_note_ptr;
948 /* Check if we have reached the end of the note section. */
949 if (curr_data_ptr >=
950 curr_note_section_begin +
951 stap_note_section_hdr.sh_size) {
952 *nb_probes = nb_match;
953 *offsets = probe_locs;
954 ret = 0;
955 break;
956 }
957 /* Get name size field. */
958 name_size = next_4bytes_boundary(*(uint32_t*) curr_data_ptr);
959 curr_data_ptr += sizeof(uint32_t);
960
961 /* Sanity check; a zero name_size is reserved. */
962 if (name_size == 0) {
963 DBG("Invalid name size field in SDT probe descriptions"
964 "section.");
965 ret = -1;
966 goto realloc_error;
967 }
968
969 /* Get description size field. */
970 desc_size = next_4bytes_boundary(*(uint32_t*) curr_data_ptr);
971 curr_data_ptr += sizeof(uint32_t);
972
973 /* Get type field. */
974 note_type = *(uint32_t *) curr_data_ptr;
975 curr_data_ptr += sizeof(uint32_t);
976
977 /*
978 * Move the pointer to the next note to be ready for the next
979 * iteration. The current note is made of 3 unsigned 32bit
980 * integers (name size, descriptor size and note type), the
981 * name and the descriptor. To move to the next note, we move
982 * the pointer according to those values.
983 */
984 next_note_ptr = next_note_ptr +
985 (3 * sizeof(uint32_t)) + desc_size + name_size;
986
987 /*
988 * Move ptr to the end of the name string (we don't need it)
989 * and go to the next 4 byte alignement.
990 */
991 if (note_type != NOTE_STAPSDT_TYPE ||
992 strncmp(curr_data_ptr, NOTE_STAPSDT_NAME, name_size) != 0) {
993 continue;
994 }
995
996 curr_data_ptr += name_size;
997
998 /* Get probe location. */
999 curr_probe_location = *(uint64_t *) curr_data_ptr;
1000 curr_data_ptr += sizeof(uint64_t);
1001
1002 /* Pass over the base. Not needed. */
1003 curr_data_ptr += sizeof(uint64_t);
1004
1005 /* Get semaphore location. */
1006 curr_semaphore_location = *(uint64_t *) curr_data_ptr;
1007 curr_data_ptr += sizeof(uint64_t);
1008 /* Get provider name. */
1009 curr_provider = curr_data_ptr;
1010 curr_data_ptr += strlen(curr_provider) + 1;
1011
1012 /* Get probe name. */
1013 curr_probe = curr_data_ptr;
1014
1015 /* Check if the provider and probe name match */
1016 if (strcmp(provider_name, curr_provider) == 0 &&
1017 strcmp(probe_name, curr_probe) == 0) {
1018 int new_size;
1019
1020 /*
1021 * We currently don't support SDT probes with semaphores. Return
1022 * success as we found a matching probe but it's guarded by a
1023 * semaphore.
1024 */
1025 if (curr_semaphore_location != 0) {
1026 ret = LTTNG_ERR_SDT_PROBE_SEMAPHORE;
1027 goto realloc_error;
1028 }
1029
1030 new_size = (++nb_match) * sizeof(uint64_t);
1031
1032 /*
1033 * Found a match with not semaphore, we need to copy the
1034 * probe_location to the output parameter.
1035 */
1036 new_probe_locs = realloc(probe_locs, new_size);
1037 if (!new_probe_locs) {
1038 /* Error allocating a larger buffer */
1039 DBG("Allocation error in SDT.");
1040 ret = LTTNG_ERR_NOMEM;
1041 goto realloc_error;
1042 }
1043 probe_locs = new_probe_locs;
1044 new_probe_locs = NULL;
1045
1046 /*
1047 * Use the virtual address of the probe to compute the offset of
1048 * this probe from the beginning of the executable file.
1049 */
1050 ret = lttng_elf_convert_addr_in_text_to_offset(elf,
1051 curr_probe_location, &curr_probe_offset);
1052 if (ret) {
1053 DBG("Conversion error in SDT.");
1054 goto realloc_error;
1055 }
1056
1057 probe_locs[nb_match - 1] = curr_probe_offset;
1058 }
1059 }
1060
1061 end:
1062 free(stap_note_section_data);
1063 destroy_elf_error:
1064 lttng_elf_destroy(elf);
1065 error:
1066 return ret;
1067 realloc_error:
1068 free(probe_locs);
1069 goto end;
1070 }
This page took 0.085531 seconds and 5 git commands to generate.