arch/x86/vdso/vdso2c.c

   1 #include <inttypes.h>
   2 #include <stdint.h>
   3 #include <unistd.h>
   4 #include <stdarg.h>
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <fcntl.h>
   9 #include <err.h>
  10
  11 #include <sys/mman.h>
  12 #include <sys/types.h>
  13
  14 #include <tools/le_byteshift.h>
  15
  16 #include <linux/elf.h>
  17 #include <linux/types.h>
  18
  19 const char *outfilename;
  20
  21 /* Symbols that we need in vdso2c. */
  22 enum {
  23         sym_vvar_page,
  24         sym_hpet_page,
  25         sym_end_mapping,
  26 };
  27
  28 const int special_pages[] = {
  29         sym_vvar_page,
  30         sym_hpet_page,
  31 };
  32
  33 char const * const required_syms[] = {
  34         [sym_vvar_page] = "vvar_page",
  35         [sym_hpet_page] = "hpet_page",
  36         [sym_end_mapping] = "end_mapping",
  37         "VDSO32_NOTE_MASK",
  38         "VDSO32_SYSENTER_RETURN",
  39         "__kernel_vsyscall",
  40         "__kernel_sigreturn",
  41         "__kernel_rt_sigreturn",
  42 };
  43
  44 __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
  45 static void fail(const char *format, ...)
  46 {
  47         va_list ap;
  48         va_start(ap, format);
  49         fprintf(stderr, "Error: ");
  50         vfprintf(stderr, format, ap);
  51         unlink(outfilename);
  52         exit(1);
  53         va_end(ap);
  54 }
  55
  56 /*
  57  * Evil macros to do a little-endian read.
  58  */
  59 #define GLE(x, bits, ifnot)                                             \
  60         __builtin_choose_expr(                                          \
  61                 (sizeof(*(x)) == bits/8),                               \
  62                 (__typeof__(*(x)))get_unaligned_le##bits(x), ifnot)
  63
  64 extern void bad_get_le(void);
  65 #define LAST_LE(x)                                                      \
  66         __builtin_choose_expr(sizeof(*(x)) == 1, *(x), bad_get_le())
  67
  68 #define GET_LE(x)                                                       \
  69         GLE(x, 64, GLE(x, 32, GLE(x, 16, LAST_LE(x))))
  70
  71 #define NSYMS (sizeof(required_syms) / sizeof(required_syms[0]))
  72
  73 #define BITS 64
  74 #define GOFUNC go64
  75 #define Elf_Ehdr Elf64_Ehdr
  76 #define Elf_Shdr Elf64_Shdr
  77 #define Elf_Phdr Elf64_Phdr
  78 #define Elf_Sym Elf64_Sym
  79 #define Elf_Dyn Elf64_Dyn
  80 #include "vdso2c.h"
  81 #undef BITS
  82 #undef GOFUNC
  83 #undef Elf_Ehdr
  84 #undef Elf_Shdr
  85 #undef Elf_Phdr
  86 #undef Elf_Sym
  87 #undef Elf_Dyn
  88
  89 #define BITS 32
  90 #define GOFUNC go32
  91 #define Elf_Ehdr Elf32_Ehdr
  92 #define Elf_Shdr Elf32_Shdr
  93 #define Elf_Phdr Elf32_Phdr
  94 #define Elf_Sym Elf32_Sym
  95 #define Elf_Dyn Elf32_Dyn
  96 #include "vdso2c.h"
  97 #undef BITS
  98 #undef GOFUNC
  99 #undef Elf_Ehdr
 100 #undef Elf_Shdr
 101 #undef Elf_Phdr
 102 #undef Elf_Sym
 103 #undef Elf_Dyn
 104
 105 static void go(void *addr, size_t len, FILE *outfile, const char *name)
 106 {
 107         Elf64_Ehdr *hdr = (Elf64_Ehdr *)addr;
 108
 109         if (hdr->e_ident[EI_CLASS] == ELFCLASS64) {
 110                 go64(addr, len, outfile, name);
 111         } else if (hdr->e_ident[EI_CLASS] == ELFCLASS32) {
 112                 go32(addr, len, outfile, name);
 113         } else {
 114                 fail("unknown ELF class\n");
 115         }
 116 }
 117
 118 int main(int argc, char **argv)
 119 {
 120         int fd;
 121         off_t len;
 122         void *addr;
 123         FILE *outfile;
 124         char *name, *tmp;
 125         int namelen;
 126
 127         if (argc != 3) {
 128                 printf("Usage: vdso2c INPUT OUTPUT\n");
 129                 return 1;
 130         }
 131
 132         /*
 133          * Figure out the struct name.  If we're writing to a .so file,
 134          * generate raw output insted.
 135          */
 136         name = strdup(argv[2]);
 137         namelen = strlen(name);
 138         if (namelen >= 3 && !strcmp(name + namelen - 3, ".so")) {
 139                 name = NULL;
 140         } else {
 141                 tmp = strrchr(name, '/');
 142                 if (tmp)
 143                         name = tmp + 1;
 144                 tmp = strchr(name, '.');
 145                 if (tmp)
 146                         *tmp = '\0';
 147                 for (tmp = name; *tmp; tmp++)
 148                         if (*tmp == '-')
 149                                 *tmp = '_';
 150         }
 151
 152         fd = open(argv[1], O_RDONLY);
 153         if (fd == -1)
 154                 err(1, "%s", argv[1]);
 155
 156         len = lseek(fd, 0, SEEK_END);
 157         if (len == (off_t)-1)
 158                 err(1, "lseek");
 159
 160         addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 161         if (addr == MAP_FAILED)
 162                 err(1, "mmap");
 163
 164         outfilename = argv[2];
 165         outfile = fopen(outfilename, "w");
 166         if (!outfile)
 167                 err(1, "%s", argv[2]);
 168
 169         go(addr, (size_t)len, outfile, name);
 170
 171         munmap(addr, len);
 172         fclose(outfile);
 173
 174         return 0;
 175 }