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>
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.
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.
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
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>
32 #include <sys/types.h>
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
45 #if BYTE_ORDER == LITTLE_ENDIAN
46 #define NATIVE_ELF_ENDIANNESS ELFDATA2LSB
48 #define NATIVE_ELF_ENDIANNESS ELFDATA2MSB
51 #define next_4bytes_boundary(x) (typeof(x)) ((((uint64_t)x) + 3) & ~0x03)
55 switch (sizeof(x)) { \
72 #define bswap_shdr(shdr) \
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); \
86 #define bswap_ehdr(ehdr) \
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); \
103 #define copy_shdr(src_shdr, dst_shdr) \
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; \
117 #define copy_ehdr(src_ehdr, dst_ehdr) \
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; \
134 #define copy_sym(src_sym, dst_sym) \
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; \
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)
147 struct lttng_elf_ehdr
{
156 uint16_t e_phentsize
;
158 uint16_t e_shentsize
;
163 struct lttng_elf_shdr
{
172 uint64_t sh_addralign
;
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
181 struct lttng_elf_sym
{
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
;
202 int is_elf_32_bit(struct lttng_elf
*elf
)
204 return elf
->bitness
== ELFCLASS32
;
208 int is_elf_native_endian(struct lttng_elf
*elf
)
210 return elf
->endianness
== NATIVE_ELF_ENDIANNESS
;
214 int populate_section_header(struct lttng_elf
* elf
, struct lttng_elf_shdr
*shdr
,
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
;
224 if (lseek(elf
->fd
, offset
, SEEK_SET
) < 0) {
225 PERROR("Error seeking to the beginning of ELF section header");
230 if (is_elf_32_bit(elf
)) {
233 if (lttng_read(elf
->fd
, &elf_shdr
, sizeof(elf_shdr
)) < sizeof(elf_shdr
)) {
234 PERROR("Error reading ELF section header");
238 if (!is_elf_native_endian(elf
)) {
239 bswap_shdr(elf_shdr
);
241 copy_shdr(elf_shdr
, *shdr
);
245 if (lttng_read(elf
->fd
, &elf_shdr
, sizeof(elf_shdr
)) < sizeof(elf_shdr
)) {
246 PERROR("Error reading ELF section header");
250 if (!is_elf_native_endian(elf
)) {
251 bswap_shdr(elf_shdr
);
253 copy_shdr(elf_shdr
, *shdr
);
261 int populate_elf_header(struct lttng_elf
*elf
)
266 * Move the read pointer back to the beginning to read the full header
267 * and copy it in our structure.
269 if (lseek(elf
->fd
, 0, SEEK_SET
) < 0) {
270 PERROR("Error seeking to the beginning of the file");
276 * Use macros to set fields in the ELF header struct for both 32bit and
279 if (is_elf_32_bit(elf
)) {
282 if (lttng_read(elf
->fd
, &elf_ehdr
, sizeof(elf_ehdr
)) < sizeof(elf_ehdr
)) {
286 if (!is_elf_native_endian(elf
)) {
287 bswap_ehdr(elf_ehdr
);
289 copy_ehdr(elf_ehdr
, *(elf
->ehdr
));
293 if (lttng_read(elf
->fd
, &elf_ehdr
, sizeof(elf_ehdr
)) < sizeof(elf_ehdr
)) {
297 if (!is_elf_native_endian(elf
)) {
298 bswap_ehdr(elf_ehdr
);
300 copy_ehdr(elf_ehdr
, *(elf
->ehdr
));
307 * Retrieve the nth (where n is the `index` argument) shdr (section
308 * header) from the given elf instance.
310 * A pointer to the shdr is returned on success, NULL on failure.
313 struct lttng_elf_shdr
*lttng_elf_get_section_hdr(struct lttng_elf
*elf
,
316 struct lttng_elf_shdr
*section_header
= NULL
;
323 if (index
>= elf
->ehdr
->e_shnum
) {
327 section_header
= zmalloc(sizeof(struct lttng_elf_shdr
));
328 if (!section_header
) {
332 ret
= populate_section_header(elf
, section_header
, index
);
334 ret
= LTTNG_ERR_ELF_PARSING
;
335 DBG("Error populating section header.");
338 return section_header
;
341 free(section_header
);
346 * Lookup a section's name from a given offset (usually from an shdr's
347 * sh_name value) in bytes relative to the beginning of the section
348 * names string table.
350 * If no name is found, NULL is returned.
353 char *lttng_elf_get_section_name(struct lttng_elf
*elf
, off_t offset
)
356 size_t name_length
= 0, to_read
; /* name_length does not include \0 */
362 if (offset
>= elf
->section_names_size
) {
366 if (lseek(elf
->fd
, elf
->section_names_offset
+ offset
, SEEK_SET
) < 0) {
367 PERROR("Error seeking to the beginning of ELF string table section");
371 to_read
= elf
->section_names_size
- offset
;
373 /* Find first \0 after or at current location, remember name_length. */
382 read_len
= lttng_read(elf
->fd
, buf
, min_t(size_t, BUF_LEN
, to_read
));
384 PERROR("Error reading ELF string table section");
387 for (i
= 0; i
< read_len
; i
++) {
388 if (buf
[i
] == '\0') {
393 name_length
+= read_len
;
398 * We found the length of the section name, now seek back to the
399 * beginning of the name and copy it in the newly allocated buffer.
401 name
= zmalloc(sizeof(char) * (name_length
+ 1)); /* + 1 for \0 */
403 PERROR("Error allocating ELF section name buffer");
406 if (lseek(elf
->fd
, elf
->section_names_offset
+ offset
, SEEK_SET
) < 0) {
407 PERROR("Error seeking to the offset of the ELF section name");
410 if (lttng_read(elf
->fd
, name
, name_length
+ 1) < name_length
+ 1) {
411 PERROR("Error reading the ELF section name");
423 int lttng_elf_validate_and_populate(struct lttng_elf
*elf
)
426 uint8_t e_ident
[EI_NIDENT
];
427 uint8_t *magic_number
= NULL
;
432 ret
= LTTNG_ERR_ELF_PARSING
;
437 * First read the magic number, endianness and version to later populate
438 * the ELF header with the correct endianness and bitness.
442 if (lseek(elf
->fd
, 0, SEEK_SET
) < 0) {
443 PERROR("Error seeking the beginning of ELF file");
444 ret
= LTTNG_ERR_ELF_PARSING
;
447 ret
= lttng_read(elf
->fd
, e_ident
, EI_NIDENT
);
448 if (ret
< EI_NIDENT
) {
449 DBG("Error reading the ELF identification fields");
451 PERROR("Error reading the ELF identification fields");
453 ret
= LTTNG_ERR_ELF_PARSING
;
458 * Copy fields used to check that the target file is in fact a valid ELF
461 elf
->bitness
= e_ident
[EI_CLASS
];
462 elf
->endianness
= e_ident
[EI_DATA
];
463 version
= e_ident
[EI_VERSION
];
464 magic_number
= &e_ident
[EI_MAG0
];
467 * Check the magic number.
469 if (memcmp(magic_number
, ELFMAG
, SELFMAG
) != 0) {
470 DBG("Error check ELF magic number.");
471 ret
= LTTNG_ERR_ELF_PARSING
;
476 * Check the bitness is either ELFCLASS32 or ELFCLASS64.
478 if (elf
->bitness
<= ELFCLASSNONE
|| elf
->bitness
>= ELFCLASSNUM
) {
479 DBG("ELF class error.");
480 ret
= LTTNG_ERR_ELF_PARSING
;
485 * Check the endianness is either ELFDATA2LSB or ELFDATA2MSB.
487 if (elf
->endianness
<= ELFDATANONE
|| elf
->endianness
>= ELFDATANUM
) {
488 DBG("ELF endianness error.");
489 ret
= LTTNG_ERR_ELF_PARSING
;
494 * Check the version is ELF_CURRENT.
496 if (version
<= EV_NONE
|| version
>= EV_NUM
) {
497 DBG("Wrong ELF version.");
498 ret
= LTTNG_ERR_ELF_PARSING
;
502 elf
->ehdr
= zmalloc(sizeof(struct lttng_elf_ehdr
));
504 PERROR("Error allocation buffer for ELF header");
505 ret
= LTTNG_ERR_NOMEM
;
510 * Copy the content of the elf header.
512 ret
= populate_elf_header(elf
);
514 DBG("Error reading ELF header,");
528 * Create an instance of lttng_elf for the ELF file located at
531 * Return a pointer to the instance on success, NULL on failure.
534 struct lttng_elf
*lttng_elf_create(int fd
)
536 struct lttng_elf_shdr
*section_names_shdr
;
537 struct lttng_elf
*elf
= NULL
;
544 elf
= zmalloc(sizeof(struct lttng_elf
));
546 PERROR("Error allocating struct lttng_elf");
552 PERROR("Error duplicating file descriptor to binary");
556 ret
= lttng_elf_validate_and_populate(elf
);
561 section_names_shdr
= lttng_elf_get_section_hdr(elf
, elf
->ehdr
->e_shstrndx
);
562 if (!section_names_shdr
) {
566 elf
->section_names_offset
= section_names_shdr
->sh_offset
;
567 elf
->section_names_size
= section_names_shdr
->sh_size
;
569 free(section_names_shdr
);
578 if (close(elf
->fd
)) {
579 PERROR("Error closing file descriptor in error path");
589 * Destroy the given lttng_elf instance.
592 void lttng_elf_destroy(struct lttng_elf
*elf
)
599 if (close(elf
->fd
)) {
600 PERROR("Error closing file description in error path");
607 int lttng_elf_get_section_hdr_by_name(struct lttng_elf
*elf
,
608 const char *section_name
, struct lttng_elf_shdr
**section_hdr
)
611 char *curr_section_name
;
612 for (i
= 0; i
< elf
->ehdr
->e_shnum
; ++i
) {
613 *section_hdr
= lttng_elf_get_section_hdr(elf
, i
);
614 curr_section_name
= lttng_elf_get_section_name(elf
,
615 (*section_hdr
)->sh_name
);
617 if (!curr_section_name
) {
620 if (strcmp(curr_section_name
, section_name
) == 0) {
624 return LTTNG_ERR_ELF_PARSING
;
628 char *lttng_elf_get_section_data(struct lttng_elf
*elf
,
629 struct lttng_elf_shdr
*shdr
)
632 off_t section_offset
;
639 section_offset
= shdr
->sh_offset
;
640 if (lseek(elf
->fd
, section_offset
, SEEK_SET
) < 0) {
641 PERROR("Error seeking to section offset");
645 data
= zmalloc(shdr
->sh_size
);
647 PERROR("Error allocating buffer for ELF section data");
650 ret
= lttng_read(elf
->fd
, data
, shdr
->sh_size
);
652 PERROR("Error reading ELF section data");
665 * Convert the virtual address in a binary's mapping to the offset of
666 * the corresponding instruction in the binary file.
667 * This function assumes the address is in the text section.
669 * Returns the offset on success or non-zero in case of failure.
672 int lttng_elf_convert_addr_in_text_to_offset(struct lttng_elf
*elf_handle
,
673 size_t addr
, uint64_t *offset
)
676 off_t text_section_offset
;
677 off_t text_section_addr_beg
;
678 off_t text_section_addr_end
;
679 off_t offset_in_section
;
680 struct lttng_elf_shdr
*text_section_hdr
= NULL
;
683 DBG("Invalid ELF handle.");
684 ret
= LTTNG_ERR_ELF_PARSING
;
688 /* Get a pointer to the .text section header. */
689 ret
= lttng_elf_get_section_hdr_by_name(elf_handle
,
690 TEXT_SECTION_NAME
, &text_section_hdr
);
692 DBG("Text section not found in binary.");
693 ret
= LTTNG_ERR_ELF_PARSING
;
697 text_section_offset
= text_section_hdr
->sh_offset
;
698 text_section_addr_beg
= text_section_hdr
->sh_addr
;
699 text_section_addr_end
= text_section_addr_beg
+ text_section_hdr
->sh_size
;
702 * Verify that the address is within the .text section boundaries.
704 if (addr
< text_section_addr_beg
|| addr
> text_section_addr_end
) {
705 DBG("Address found is outside of the .text section addr=0x%zx, "
706 ".text section=[0x%jd - 0x%jd].", addr
, (intmax_t)text_section_addr_beg
,
707 (intmax_t)text_section_addr_end
);
708 ret
= LTTNG_ERR_ELF_PARSING
;
712 offset_in_section
= addr
- text_section_addr_beg
;
715 * Add the target offset in the text section to the offset of this text
716 * section from the beginning of the binary file.
718 *offset
= text_section_offset
+ offset_in_section
;
725 * Compute the offset of a symbol from the begining of the ELF binary.
727 * On success, returns 0 offset parameter is set to the computed value
728 * On failure, returns -1.
730 int lttng_elf_get_symbol_offset(int fd
, char *symbol
, uint64_t *offset
)
737 char *curr_sym_str
= NULL
;
738 char *symbol_table_data
= NULL
;
739 char *string_table_data
= NULL
;
740 struct lttng_elf_shdr
*symtab_hdr
= NULL
;
741 struct lttng_elf_shdr
*strtab_hdr
= NULL
;
742 struct lttng_elf
*elf
= NULL
;
744 if (!symbol
|| !offset
) {
745 ret
= LTTNG_ERR_ELF_PARSING
;
749 elf
= lttng_elf_create(fd
);
751 ret
= LTTNG_ERR_ELF_PARSING
;
755 /* Get the symbol table section header. */
756 ret
= lttng_elf_get_section_hdr_by_name(elf
, SYMBOL_TAB_SECTION_NAME
,
759 DBG("Cannot get ELF Symbol Table section.");
760 ret
= LTTNG_ERR_ELF_PARSING
;
763 /* Get the data associated with the symbol table section. */
764 symbol_table_data
= lttng_elf_get_section_data(elf
, symtab_hdr
);
765 if (symbol_table_data
== NULL
) {
766 DBG("Cannot get ELF Symbol Table data.");
767 ret
= LTTNG_ERR_ELF_PARSING
;
771 /* Get the string table section header. */
772 ret
= lttng_elf_get_section_hdr_by_name(elf
, STRING_TAB_SECTION_NAME
,
775 DBG("Cannot get ELF string table section.");
776 goto free_symbol_table_data
;
779 /* Get the data associated with the string table section. */
780 string_table_data
= lttng_elf_get_section_data(elf
, strtab_hdr
);
781 if (string_table_data
== NULL
) {
782 DBG("Cannot get ELF string table section data.");
783 ret
= LTTNG_ERR_ELF_PARSING
;
784 goto free_symbol_table_data
;
787 /* Get the number of symbol in the table for the iteration. */
788 sym_count
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
790 /* Loop over all symbol. */
791 for (sym_idx
= 0; sym_idx
< sym_count
; sym_idx
++) {
792 struct lttng_elf_sym curr_sym
;
794 /* Get the symbol at the current index. */
795 if (is_elf_32_bit(elf
)) {
796 Elf32_Sym tmp
= ((Elf32_Sym
*) symbol_table_data
)[sym_idx
];
797 copy_sym(tmp
, curr_sym
);
799 Elf64_Sym tmp
= ((Elf64_Sym
*) symbol_table_data
)[sym_idx
];
800 copy_sym(tmp
, curr_sym
);
804 * If the st_name field is zero, there is no string name for
805 * this symbol; skip to the next symbol.
807 if (curr_sym
.st_name
== 0) {
812 * Use the st_name field in the lttng_elf_sym struct to get offset of
813 * the symbol's name from the beginning of the string table.
815 curr_sym_str
= string_table_data
+ curr_sym
.st_name
;
818 * If the current symbol is not a function; skip to the next symbol.
820 if (ELF_ST_TYPE(curr_sym
.st_info
) != STT_FUNC
) {
825 * Compare with the search symbol. If there is a match set the address
826 * output parameter and return success.
828 if (strcmp(symbol
, curr_sym_str
) == 0 ) {
830 addr
= curr_sym
.st_value
;
836 DBG("Symbol not found.");
837 ret
= LTTNG_ERR_ELF_PARSING
;
838 goto free_string_table_data
;
842 * Use the virtual address of the symbol to compute the offset of this
843 * symbol from the beginning of the executable file.
845 ret
= lttng_elf_convert_addr_in_text_to_offset(elf
, addr
, offset
);
847 DBG("Cannot convet addr to offset.");
848 goto free_string_table_data
;
852 free_string_table_data
:
853 free(string_table_data
);
854 free_symbol_table_data
:
855 free(symbol_table_data
);
857 lttng_elf_destroy(elf
);
863 * Compute the offsets of SDT probes from the begining of the ELF binary.
865 * On success, returns 0 and the nb_probes parameter is set to the number of
866 * offsets found and the offsets parameter points to an array of offsets where
867 * the SDT probes are.
868 * On failure, returns -1.
870 int lttng_elf_get_sdt_probe_offsets(int fd
, const char *provider_name
,
871 const char *probe_name
, uint64_t **offsets
, uint32_t *nb_probes
)
873 int ret
= 0, nb_match
= 0;
874 struct lttng_elf_shdr
*stap_note_section_hdr
= NULL
;
875 struct lttng_elf
*elf
= NULL
;
876 char *stap_note_section_data
= NULL
;
877 char *curr_note_section_begin
, *curr_data_ptr
, *curr_probe
, *curr_provider
;
878 char *next_note_ptr
, *curr_desc_beg
;
879 uint32_t name_size
, desc_size
, note_type
;
880 uint64_t curr_probe_location
, curr_probe_offset
, curr_semaphore_location
;
881 uint64_t *probe_locs
= NULL
, *new_probe_locs
= NULL
;
883 if (!provider_name
|| !probe_name
|| !nb_probes
|| !offsets
) {
884 DBG("Invalid arguments.");
885 ret
= LTTNG_ERR_ELF_PARSING
;
889 elf
= lttng_elf_create(fd
);
891 DBG("Error allocation ELF.");
892 ret
= LTTNG_ERR_ELF_PARSING
;
896 /* Get the stap note section header. */
897 ret
= lttng_elf_get_section_hdr_by_name(elf
, NOTE_STAPSDT_SECTION_NAME
,
898 &stap_note_section_hdr
);
900 DBG("Cannot get ELF stap note section.");
901 goto destroy_elf_error
;
904 /* Get the data associated with the stap note section. */
905 stap_note_section_data
= lttng_elf_get_section_data(elf
, stap_note_section_hdr
);
906 if (stap_note_section_data
== NULL
) {
907 DBG("Cannot get ELF stap note section data.");
908 ret
= LTTNG_ERR_ELF_PARSING
;
909 goto destroy_elf_error
;
912 curr_data_ptr
= stap_note_section_data
;
913 next_note_ptr
= stap_note_section_data
;
914 curr_note_section_begin
= stap_note_section_data
;
918 curr_data_ptr
= next_note_ptr
;
919 /* Check if we have reached the end of the note section. */
921 curr_note_section_begin
+ stap_note_section_hdr
->sh_size
) {
922 *nb_probes
= nb_match
;
923 *offsets
= probe_locs
;
927 /* Get name size field. */
928 name_size
= next_4bytes_boundary(*(uint32_t*) curr_data_ptr
);
929 curr_data_ptr
+= sizeof(uint32_t);
931 /* Sanity check; a zero name_size is reserved. */
932 if (name_size
== 0) {
933 DBG("Invalid name size field in SDT probe descriptions"
939 /* Get description size field. */
940 desc_size
= next_4bytes_boundary(*(uint32_t*) curr_data_ptr
);
941 curr_data_ptr
+= sizeof(uint32_t);
943 /* Get type field. */
944 note_type
= *(uint32_t *) curr_data_ptr
;
945 curr_data_ptr
+= sizeof(uint32_t);
948 * Move the pointer to the next note to be ready for the next
949 * iteration. The current note is made of 3 unsigned 32bit
950 * integers (name size, descriptor size and note type), the
951 * name and the descriptor. To move to the next note, we move
952 * the pointer according to those values.
954 next_note_ptr
= next_note_ptr
+
955 (3 * sizeof(uint32_t)) + desc_size
+ name_size
;
958 * Move ptr to the end of the name string (we don't need it)
959 * and go to the next 4 byte alignement.
961 if (note_type
!= NOTE_STAPSDT_TYPE
||
962 strncmp(curr_data_ptr
, NOTE_STAPSDT_NAME
, name_size
) != 0) {
966 curr_data_ptr
+= name_size
;
968 /* Get description field. */
969 curr_desc_beg
= curr_data_ptr
;
971 /* Get probe location. */
972 curr_probe_location
= *(uint64_t *) curr_data_ptr
;
973 curr_data_ptr
+= sizeof(uint64_t);
975 /* Pass over the base. Not needed. */
976 curr_data_ptr
+= sizeof(uint64_t);
978 /* Get semaphore location. */
979 curr_semaphore_location
= *(uint64_t *) curr_data_ptr
;
980 curr_data_ptr
+= sizeof(uint64_t);
981 /* Get provider name. */
982 curr_provider
= curr_data_ptr
;
983 curr_data_ptr
+= strlen(curr_provider
) + 1;
985 /* Get probe name. */
986 curr_probe
= curr_data_ptr
;
987 curr_data_ptr
+= strlen(curr_probe
) + 1;
989 curr_data_ptr
= curr_desc_beg
+ desc_size
;
991 /* Check if the provider and probe name match */
992 if (strcmp(provider_name
, curr_provider
) == 0 &&
993 strcmp(probe_name
, curr_probe
) == 0) {
997 * We currently don't support SDT probes with semaphores. Return
998 * success as we found a matching probe but it's guarded by a
1001 if (curr_semaphore_location
!= 0) {
1002 ret
= LTTNG_ERR_SDT_PROBE_SEMAPHORE
;
1006 new_size
= (++nb_match
) * sizeof(uint64_t);
1009 * Found a match with not semaphore, we need to copy the
1010 * probe_location to the output parameter.
1012 new_probe_locs
= realloc(probe_locs
, new_size
);
1013 if (!new_probe_locs
) {
1014 /* Error allocating a larger buffer */
1015 DBG("Allocation error in SDT.");
1016 ret
= LTTNG_ERR_NOMEM
;
1019 probe_locs
= new_probe_locs
;
1020 new_probe_locs
= NULL
;
1023 * Use the virtual address of the probe to compute the offset of
1024 * this probe from the beginning of the executable file.
1026 ret
= lttng_elf_convert_addr_in_text_to_offset(elf
,
1027 curr_probe_location
, &curr_probe_offset
);
1029 DBG("Conversion error in SDT.");
1033 probe_locs
[nb_match
- 1] = curr_probe_offset
;
1038 free(stap_note_section_data
);
1040 lttng_elf_destroy(elf
);