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