tools/perf/util/genelf.c

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