tools/perf/util/genelf.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * genelf.c
   4  * Copyright (C) 2014, Google, Inc
   5  *
   6  * Contributed by:
   7  *      Stephane Eranian <eranian@gmail.com>
   8  */
   9
  10 #include <sys/types.h>
  11 #include <stddef.h>
  12 #include <libelf.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <inttypes.h>
  17 #include <fcntl.h>
  18 #include <err.h>
  19 #ifdef HAVE_LIBDW_SUPPORT
  20 #include <dwarf.h>
  21 #endif
  22
  23 #include "genelf.h"
  24 #include "../util/jitdump.h"
  25 #include <linux/compiler.h>
  26
  27 #ifndef NT_GNU_BUILD_ID
  28 #define NT_GNU_BUILD_ID 3
  29 #endif
  30
  31 #define BUILD_ID_URANDOM /* different uuid for each run */
  32
  33 #ifdef HAVE_LIBCRYPTO_SUPPORT
  34
  35 #define BUILD_ID_MD5
  36 #undef BUILD_ID_SHA     /* does not seem to work well when linked with Java */
  37 #undef BUILD_ID_URANDOM /* different uuid for each run */
  38
  39 #ifdef BUILD_ID_SHA
  40 #include <openssl/sha.h>
  41 #endif
  42
  43 #ifdef BUILD_ID_MD5
  44 #include <openssl/evp.h>
  45 #include <openssl/md5.h>
  46 #endif
  47 #endif
  48
  49
  50 typedef struct {
  51   unsigned int namesz;  /* Size of entry's owner string */
  52   unsigned int descsz;  /* Size of the note descriptor */
  53   unsigned int type;    /* Interpretation of the descriptor */
  54   char         name[0]; /* Start of the name+desc data */
  55 } Elf_Note;
  56
  57 static char shd_string_table[] = {
  58         0,
  59         '.', 't', 'e', 'x', 't', 0,                     /*  1 */
  60         '.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', 0, /*  7 */
  61         '.', 's', 'y', 'm', 't', 'a', 'b', 0,           /* 17 */
  62         '.', 's', 't', 'r', 't', 'a', 'b', 0,           /* 25 */
  63         '.', 'n', 'o', 't', 'e', '.', 'g', 'n', 'u', '.', 'b', 'u', 'i', 'l', 'd', '-', 'i', 'd', 0, /* 33 */
  64         '.', 'd', 'e', 'b', 'u', 'g', '_', 'l', 'i', 'n', 'e', 0, /* 52 */
  65         '.', 'd', 'e', 'b', 'u', 'g', '_', 'i', 'n', 'f', 'o', 0, /* 64 */
  66         '.', 'd', 'e', 'b', 'u', 'g', '_', 'a', 'b', 'b', 'r', 'e', 'v', 0, /* 76 */
  67         '.', 'e', 'h', '_', 'f', 'r', 'a', 'm', 'e', '_', 'h', 'd', 'r', 0, /* 90 */
  68         '.', 'e', 'h', '_', 'f', 'r', 'a', 'm', 'e', 0, /* 104 */
  69 };
  70
  71 static struct buildid_note {
  72         Elf_Note desc;          /* descsz: size of build-id, must be multiple of 4 */
  73         char     name[4];       /* GNU\0 */
  74         char     build_id[20];
  75 } bnote;
  76
  77 static Elf_Sym symtab[]={
  78         /* symbol 0 MUST be the undefined symbol */
  79         { .st_name  = 0, /* index in sym_string table */
  80           .st_info  = ELF_ST_TYPE(STT_NOTYPE),
  81           .st_shndx = 0, /* for now */
  82           .st_value = 0x0,
  83           .st_other = ELF_ST_VIS(STV_DEFAULT),
  84           .st_size  = 0,
  85         },
  86         { .st_name  = 1, /* index in sym_string table */
  87           .st_info  = ELF_ST_BIND(STB_LOCAL) | ELF_ST_TYPE(STT_FUNC),
  88           .st_shndx = 1,
  89           .st_value = 0, /* for now */
  90           .st_other = ELF_ST_VIS(STV_DEFAULT),
  91           .st_size  = 0, /* for now */
  92         }
  93 };
  94
  95 #ifdef BUILD_ID_URANDOM
  96 static void
  97 gen_build_id(struct buildid_note *note,
  98              unsigned long load_addr __maybe_unused,
  99              const void *code __maybe_unused,
 100              size_t csize __maybe_unused)
 101 {
 102         int fd;
 103         size_t sz = sizeof(note->build_id);
 104         ssize_t sret;
 105
 106         fd = open("/dev/urandom", O_RDONLY);
 107         if (fd == -1)
 108                 err(1, "cannot access /dev/urandom for buildid");
 109
 110         sret = read(fd, note->build_id, sz);
 111
 112         close(fd);
 113
 114         if (sret != (ssize_t)sz)
 115                 memset(note->build_id, 0, sz);
 116 }
 117 #endif
 118
 119 #ifdef BUILD_ID_SHA
 120 static void
 121 gen_build_id(struct buildid_note *note,
 122              unsigned long load_addr __maybe_unused,
 123              const void *code,
 124              size_t csize)
 125 {
 126         if (sizeof(note->build_id) < SHA_DIGEST_LENGTH)
 127                 errx(1, "build_id too small for SHA1");
 128
 129         SHA1(code, csize, (unsigned char *)note->build_id);
 130 }
 131 #endif
 132
 133 #ifdef BUILD_ID_MD5
 134 static void
 135 gen_build_id(struct buildid_note *note, unsigned long load_addr, const void *code, size_t csize)
 136 {
 137         EVP_MD_CTX *mdctx;
 138
 139         if (sizeof(note->build_id) < 16)
 140                 errx(1, "build_id too small for MD5");
 141
 142         mdctx = EVP_MD_CTX_new();
 143         if (!mdctx)
 144                 errx(2, "failed to create EVP_MD_CTX");
 145
 146         EVP_DigestInit_ex(mdctx, EVP_md5(), NULL);
 147         EVP_DigestUpdate(mdctx, &load_addr, sizeof(load_addr));
 148         EVP_DigestUpdate(mdctx, code, csize);
 149         EVP_DigestFinal_ex(mdctx, (unsigned char *)note->build_id, NULL);
 150         EVP_MD_CTX_free(mdctx);
 151 }
 152 #endif
 153
 154 static int
 155 jit_add_eh_frame_info(Elf *e, void* unwinding, uint64_t unwinding_header_size,
 156                       uint64_t unwinding_size, uint64_t base_offset)
 157 {
 158         Elf_Data *d;
 159         Elf_Scn *scn;
 160         Elf_Shdr *shdr;
 161         uint64_t unwinding_table_size = unwinding_size - unwinding_header_size;
 162
 163         /*
 164          * setup eh_frame section
 165          */
 166         scn = elf_newscn(e);
 167         if (!scn) {
 168                 warnx("cannot create section");
 169                 return -1;
 170         }
 171
 172         d = elf_newdata(scn);
 173         if (!d) {
 174                 warnx("cannot get new data");
 175                 return -1;
 176         }
 177
 178         d->d_align = 8;
 179         d->d_off = 0LL;
 180         d->d_buf = unwinding;
 181         d->d_type = ELF_T_BYTE;
 182         d->d_size = unwinding_table_size;
 183         d->d_version = EV_CURRENT;
 184
 185         shdr = elf_getshdr(scn);
 186         if (!shdr) {
 187                 warnx("cannot get section header");
 188                 return -1;
 189         }
 190
 191         shdr->sh_name = 104;
 192         shdr->sh_type = SHT_PROGBITS;
 193         shdr->sh_addr = base_offset;
 194         shdr->sh_flags = SHF_ALLOC;
 195         shdr->sh_entsize = 0;
 196
 197         /*
 198          * setup eh_frame_hdr section
 199          */
 200         scn = elf_newscn(e);
 201         if (!scn) {
 202                 warnx("cannot create section");
 203                 return -1;
 204         }
 205
 206         d = elf_newdata(scn);
 207         if (!d) {
 208                 warnx("cannot get new data");
 209                 return -1;
 210         }
 211
 212         d->d_align = 4;
 213         d->d_off = 0LL;
 214         d->d_buf = unwinding + unwinding_table_size;
 215         d->d_type = ELF_T_BYTE;
 216         d->d_size = unwinding_header_size;
 217         d->d_version = EV_CURRENT;
 218
 219         shdr = elf_getshdr(scn);
 220         if (!shdr) {
 221                 warnx("cannot get section header");
 222                 return -1;
 223         }
 224
 225         shdr->sh_name = 90;
 226         shdr->sh_type = SHT_PROGBITS;
 227         shdr->sh_addr = base_offset + unwinding_table_size;
 228         shdr->sh_flags = SHF_ALLOC;
 229         shdr->sh_entsize = 0;
 230
 231         return 0;
 232 }
 233
 234 /*
 235  * fd: file descriptor open for writing for the output file
 236  * load_addr: code load address (could be zero, just used for buildid)
 237  * sym: function name (for native code - used as the symbol)
 238  * code: the native code
 239  * csize: the code size in bytes
 240  */
 241 int
 242 jit_write_elf(int fd, uint64_t load_addr, const char *sym,
 243               const void *code, int csize,
 244               void *debug __maybe_unused, int nr_debug_entries __maybe_unused,
 245               void *unwinding, uint64_t unwinding_header_size, uint64_t unwinding_size)
 246 {
 247         Elf *e;
 248         Elf_Data *d;
 249         Elf_Scn *scn;
 250         Elf_Ehdr *ehdr;
 251         Elf_Phdr *phdr;
 252         Elf_Shdr *shdr;
 253         uint64_t eh_frame_base_offset;
 254         char *strsym = NULL;
 255         int symlen;
 256         int retval = -1;
 257
 258         if (elf_version(EV_CURRENT) == EV_NONE) {
 259                 warnx("ELF initialization failed");
 260                 return -1;
 261         }
 262
 263         e = elf_begin(fd, ELF_C_WRITE, NULL);
 264         if (!e) {
 265                 warnx("elf_begin failed");
 266                 goto error;
 267         }
 268
 269         /*
 270          * setup ELF header
 271          */
 272         ehdr = elf_newehdr(e);
 273         if (!ehdr) {
 274                 warnx("cannot get ehdr");
 275                 goto error;
 276         }
 277
 278         ehdr->e_ident[EI_DATA] = GEN_ELF_ENDIAN;
 279         ehdr->e_ident[EI_CLASS] = GEN_ELF_CLASS;
 280         ehdr->e_machine = GEN_ELF_ARCH;
 281         ehdr->e_type = ET_DYN;
 282         ehdr->e_entry = GEN_ELF_TEXT_OFFSET;
 283         ehdr->e_version = EV_CURRENT;
 284         ehdr->e_shstrndx= unwinding ? 4 : 2; /* shdr index for section name */
 285
 286         /*
 287          * setup program header
 288          */
 289         phdr = elf_newphdr(e, 1);
 290         phdr[0].p_type = PT_LOAD;
 291         phdr[0].p_offset = GEN_ELF_TEXT_OFFSET;
 292         phdr[0].p_vaddr = GEN_ELF_TEXT_OFFSET;
 293         phdr[0].p_paddr = GEN_ELF_TEXT_OFFSET;
 294         phdr[0].p_filesz = csize;
 295         phdr[0].p_memsz = csize;
 296         phdr[0].p_flags = PF_X | PF_R;
 297         phdr[0].p_align = 8;
 298
 299         /*
 300          * setup text section
 301          */
 302         scn = elf_newscn(e);
 303         if (!scn) {
 304                 warnx("cannot create section");
 305                 goto error;
 306         }
 307
 308         d = elf_newdata(scn);
 309         if (!d) {
 310                 warnx("cannot get new data");
 311                 goto error;
 312         }
 313
 314         d->d_align = 16;
 315         d->d_off = 0LL;
 316         d->d_buf = (void *)code;
 317         d->d_type = ELF_T_BYTE;
 318         d->d_size = csize;
 319         d->d_version = EV_CURRENT;
 320
 321         shdr = elf_getshdr(scn);
 322         if (!shdr) {
 323                 warnx("cannot get section header");
 324                 goto error;
 325         }
 326
 327         shdr->sh_name = 1;
 328         shdr->sh_type = SHT_PROGBITS;
 329         shdr->sh_addr = GEN_ELF_TEXT_OFFSET;
 330         shdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 331         shdr->sh_entsize = 0;
 332
 333         /*
 334          * Setup .eh_frame_hdr and .eh_frame
 335          */
 336         if (unwinding) {
 337                 eh_frame_base_offset = ALIGN_8(GEN_ELF_TEXT_OFFSET + csize);
 338                 retval = jit_add_eh_frame_info(e, unwinding,
 339                                                unwinding_header_size, unwinding_size,
 340                                                eh_frame_base_offset);
 341                 if (retval)
 342                         goto error;
 343                 retval = -1;
 344         }
 345
 346         /*
 347          * setup section headers string table
 348          */
 349         scn = elf_newscn(e);
 350         if (!scn) {
 351                 warnx("cannot create section");
 352                 goto error;
 353         }
 354
 355         d = elf_newdata(scn);
 356         if (!d) {
 357                 warnx("cannot get new data");
 358                 goto error;
 359         }
 360
 361         d->d_align = 1;
 362         d->d_off = 0LL;
 363         d->d_buf = shd_string_table;
 364         d->d_type = ELF_T_BYTE;
 365         d->d_size = sizeof(shd_string_table);
 366         d->d_version = EV_CURRENT;
 367
 368         shdr = elf_getshdr(scn);
 369         if (!shdr) {
 370                 warnx("cannot get section header");
 371                 goto error;
 372         }
 373
 374         shdr->sh_name = 7; /* offset of '.shstrtab' in shd_string_table */
 375         shdr->sh_type = SHT_STRTAB;
 376         shdr->sh_flags = 0;
 377         shdr->sh_entsize = 0;
 378
 379         /*
 380          * setup symtab section
 381          */
 382         symtab[1].st_size  = csize;
 383         symtab[1].st_value = GEN_ELF_TEXT_OFFSET;
 384
 385         scn = elf_newscn(e);
 386         if (!scn) {
 387                 warnx("cannot create section");
 388                 goto error;
 389         }
 390
 391         d = elf_newdata(scn);
 392         if (!d) {
 393                 warnx("cannot get new data");
 394                 goto error;
 395         }
 396
 397         d->d_align = 8;
 398         d->d_off = 0LL;
 399         d->d_buf = symtab;
 400         d->d_type = ELF_T_SYM;
 401         d->d_size = sizeof(symtab);
 402         d->d_version = EV_CURRENT;
 403
 404         shdr = elf_getshdr(scn);
 405         if (!shdr) {
 406                 warnx("cannot get section header");
 407                 goto error;
 408         }
 409
 410         shdr->sh_name = 17; /* offset of '.symtab' in shd_string_table */
 411         shdr->sh_type = SHT_SYMTAB;
 412         shdr->sh_flags = 0;
 413         shdr->sh_entsize = sizeof(Elf_Sym);
 414         shdr->sh_link = unwinding ? 6 : 4; /* index of .strtab section */
 415
 416         /*
 417          * setup symbols string table
 418          * 2 = 1 for 0 in 1st entry, 1 for the 0 at end of symbol for 2nd entry
 419          */
 420         symlen = 2 + strlen(sym);
 421         strsym = calloc(1, symlen);
 422         if (!strsym) {
 423                 warnx("cannot allocate strsym");
 424                 goto error;
 425         }
 426         strcpy(strsym + 1, sym);
 427
 428         scn = elf_newscn(e);
 429         if (!scn) {
 430                 warnx("cannot create section");
 431                 goto error;
 432         }
 433
 434         d = elf_newdata(scn);
 435         if (!d) {
 436                 warnx("cannot get new data");
 437                 goto error;
 438         }
 439
 440         d->d_align = 1;
 441         d->d_off = 0LL;
 442         d->d_buf = strsym;
 443         d->d_type = ELF_T_BYTE;
 444         d->d_size = symlen;
 445         d->d_version = EV_CURRENT;
 446
 447         shdr = elf_getshdr(scn);
 448         if (!shdr) {
 449                 warnx("cannot get section header");
 450                 goto error;
 451         }
 452
 453         shdr->sh_name = 25; /* offset in shd_string_table */
 454         shdr->sh_type = SHT_STRTAB;
 455         shdr->sh_flags = 0;
 456         shdr->sh_entsize = 0;
 457
 458         /*
 459          * setup build-id section
 460          */
 461         scn = elf_newscn(e);
 462         if (!scn) {
 463                 warnx("cannot create section");
 464                 goto error;
 465         }
 466
 467         d = elf_newdata(scn);
 468         if (!d) {
 469                 warnx("cannot get new data");
 470                 goto error;
 471         }
 472
 473         /*
 474          * build-id generation
 475          */
 476         gen_build_id(&bnote, load_addr, code, csize);
 477         bnote.desc.namesz = sizeof(bnote.name); /* must include 0 termination */
 478         bnote.desc.descsz = sizeof(bnote.build_id);
 479         bnote.desc.type   = NT_GNU_BUILD_ID;
 480         strcpy(bnote.name, "GNU");
 481
 482         d->d_align = 4;
 483         d->d_off = 0LL;
 484         d->d_buf = &bnote;
 485         d->d_type = ELF_T_BYTE;
 486         d->d_size = sizeof(bnote);
 487         d->d_version = EV_CURRENT;
 488
 489         shdr = elf_getshdr(scn);
 490         if (!shdr) {
 491                 warnx("cannot get section header");
 492                 goto error;
 493         }
 494
 495         shdr->sh_name = 33; /* offset in shd_string_table */
 496         shdr->sh_type = SHT_NOTE;
 497         shdr->sh_addr = 0x0;
 498         shdr->sh_flags = SHF_ALLOC;
 499         shdr->sh_size = sizeof(bnote);
 500         shdr->sh_entsize = 0;
 501
 502 #ifdef HAVE_LIBDW_SUPPORT
 503         if (debug && nr_debug_entries) {
 504                 retval = jit_add_debug_info(e, load_addr, debug, nr_debug_entries);
 505                 if (retval)
 506                         goto error;
 507         } else
 508 #endif
 509         {
 510                 if (elf_update(e, ELF_C_WRITE) < 0) {
 511                         warnx("elf_update 4 failed");
 512                         goto error;
 513                 }
 514         }
 515
 516         retval = 0;
 517 error:
 518         (void)elf_end(e);
 519
 520         free(strsym);
 521
 522
 523         return retval;
 524 }