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