src/common/lttng-elf.cpp

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