contrib/elf2dmp/qemu_elf.c

   1 /*
   2  * Copyright (c) 2018 Virtuozzo International GmbH
   3  *
   4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   5  *
   6  */
   7
   8 #include "qemu/osdep.h"
   9 #include "err.h"
  10 #include "qemu_elf.h"
  11
  12 #define QEMU_NOTE_NAME "QEMU"
  13
  14 #ifndef ROUND_UP
  15 #define ROUND_UP(n, d) (((n) + (d) - 1) & -(0 ? (n) : (d)))
  16 #endif
  17
  18 #ifndef DIV_ROUND_UP
  19 #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
  20 #endif
  21
  22 #define ELF_NOTE_SIZE(hdr_size, name_size, desc_size)   \
  23     ((DIV_ROUND_UP((hdr_size), 4) +                     \
  24       DIV_ROUND_UP((name_size), 4) +                    \
  25       DIV_ROUND_UP((desc_size), 4)) * 4)
  26
  27 int is_system(QEMUCPUState *s)
  28 {
  29     return s->gs.base >> 63;
  30 }
  31
  32 static char *nhdr_get_name(Elf64_Nhdr *nhdr)
  33 {
  34     return (char *)nhdr + ROUND_UP(sizeof(*nhdr), 4);
  35 }
  36
  37 static void *nhdr_get_desc(Elf64_Nhdr *nhdr)
  38 {
  39     return nhdr_get_name(nhdr) + ROUND_UP(nhdr->n_namesz, 4);
  40 }
  41
  42 static Elf64_Nhdr *nhdr_get_next(Elf64_Nhdr *nhdr)
  43 {
  44     return (void *)((uint8_t *)nhdr + ELF_NOTE_SIZE(sizeof(*nhdr),
  45                 nhdr->n_namesz, nhdr->n_descsz));
  46 }
  47
  48 Elf64_Phdr *elf64_getphdr(void *map)
  49 {
  50     Elf64_Ehdr *ehdr = map;
  51     Elf64_Phdr *phdr = (void *)((uint8_t *)map + ehdr->e_phoff);
  52
  53     return phdr;
  54 }
  55
  56 Elf64_Half elf_getphdrnum(void *map)
  57 {
  58     Elf64_Ehdr *ehdr = map;
  59
  60     return ehdr->e_phnum;
  61 }
  62
  63 static bool init_states(QEMU_Elf *qe)
  64 {
  65     Elf64_Phdr *phdr = elf64_getphdr(qe->map);
  66     Elf64_Nhdr *start = (void *)((uint8_t *)qe->map + phdr[0].p_offset);
  67     Elf64_Nhdr *end = (void *)((uint8_t *)start + phdr[0].p_memsz);
  68     Elf64_Nhdr *nhdr;
  69     GPtrArray *states;
  70
  71     if (phdr[0].p_type != PT_NOTE) {
  72         eprintf("Failed to find PT_NOTE\n");
  73         return false;
  74     }
  75
  76     qe->has_kernel_gs_base = 1;
  77     states = g_ptr_array_new();
  78
  79     for (nhdr = start; nhdr < end; nhdr = nhdr_get_next(nhdr)) {
  80         if (!strcmp(nhdr_get_name(nhdr), QEMU_NOTE_NAME)) {
  81             QEMUCPUState *state = nhdr_get_desc(nhdr);
  82
  83             if (state->size < sizeof(*state)) {
  84                 eprintf("CPU #%u: QEMU CPU state size %u doesn't match\n",
  85                         states->len, state->size);
  86                 /*
  87                  * We assume either every QEMU CPU state has KERNEL_GS_BASE or
  88                  * no one has.
  89                  */
  90                 qe->has_kernel_gs_base = 0;
  91             }
  92             g_ptr_array_add(states, state);
  93         }
  94     }
  95
  96     printf("%u CPU states has been found\n", states->len);
  97
  98     qe->state_nr = states->len;
  99     qe->state = (void *)g_ptr_array_free(states, FALSE);
 100
 101     return true;
 102 }
 103
 104 static void exit_states(QEMU_Elf *qe)
 105 {
 106     g_free(qe->state);
 107 }
 108
 109 static bool check_ehdr(QEMU_Elf *qe)
 110 {
 111     Elf64_Ehdr *ehdr = qe->map;
 112
 113     if (sizeof(Elf64_Ehdr) > qe->size) {
 114         eprintf("Invalid input dump file size\n");
 115         return false;
 116     }
 117
 118     if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) {
 119         eprintf("Invalid ELF signature, input file is not ELF\n");
 120         return false;
 121     }
 122
 123     if (ehdr->e_ident[EI_CLASS] != ELFCLASS64 ||
 124             ehdr->e_ident[EI_DATA] != ELFDATA2LSB) {
 125         eprintf("Invalid ELF class or byte order, must be 64-bit LE\n");
 126         return false;
 127     }
 128
 129     if (ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
 130         eprintf("Invalid ELF version\n");
 131         return false;
 132     }
 133
 134     if (ehdr->e_machine != EM_X86_64) {
 135         eprintf("Invalid input dump architecture, only x86_64 is supported\n");
 136         return false;
 137     }
 138
 139     if (ehdr->e_type != ET_CORE) {
 140         eprintf("Invalid ELF type, must be core file\n");
 141         return false;
 142     }
 143
 144     /*
 145      * ELF dump file must contain one PT_NOTE and at least one PT_LOAD to
 146      * restore physical address space.
 147      */
 148     if (ehdr->e_phnum < 2) {
 149         eprintf("Invalid number of ELF program headers\n");
 150         return false;
 151     }
 152
 153     return true;
 154 }
 155
 156 static bool QEMU_Elf_map(QEMU_Elf *qe, const char *filename)
 157 {
 158 #ifdef CONFIG_LINUX
 159     struct stat st;
 160     int fd;
 161
 162     printf("Using Linux mmap\n");
 163
 164     fd = open(filename, O_RDONLY, 0);
 165     if (fd == -1) {
 166         eprintf("Failed to open ELF dump file \'%s\'\n", filename);
 167         return false;
 168     }
 169
 170     if (fstat(fd, &st)) {
 171         eprintf("Failed to get size of ELF dump file\n");
 172         close(fd);
 173         return false;
 174     }
 175     qe->size = st.st_size;
 176
 177     qe->map = mmap(NULL, qe->size, PROT_READ | PROT_WRITE,
 178             MAP_PRIVATE | MAP_NORESERVE, fd, 0);
 179     if (qe->map == MAP_FAILED) {
 180         eprintf("Failed to map ELF file\n");
 181         close(fd);
 182         return false;
 183     }
 184
 185     close(fd);
 186 #else
 187     GError *gerr = NULL;
 188
 189     printf("Using GLib mmap\n");
 190
 191     qe->gmf = g_mapped_file_new(filename, TRUE, &gerr);
 192     if (gerr) {
 193         eprintf("Failed to map ELF dump file \'%s\'\n", filename);
 194         g_error_free(gerr);
 195         return false;
 196     }
 197
 198     qe->map = g_mapped_file_get_contents(qe->gmf);
 199     qe->size = g_mapped_file_get_length(qe->gmf);
 200 #endif
 201
 202     return true;
 203 }
 204
 205 static void QEMU_Elf_unmap(QEMU_Elf *qe)
 206 {
 207 #ifdef CONFIG_LINUX
 208     munmap(qe->map, qe->size);
 209 #else
 210     g_mapped_file_unref(qe->gmf);
 211 #endif
 212 }
 213
 214 bool QEMU_Elf_init(QEMU_Elf *qe, const char *filename)
 215 {
 216     if (!QEMU_Elf_map(qe, filename)) {
 217         return false;
 218     }
 219
 220     if (!check_ehdr(qe)) {
 221         eprintf("Input file has the wrong format\n");
 222         QEMU_Elf_unmap(qe);
 223         return false;
 224     }
 225
 226     if (!init_states(qe)) {
 227         eprintf("Failed to extract QEMU CPU states\n");
 228         QEMU_Elf_unmap(qe);
 229         return false;
 230     }
 231
 232     return true;
 233 }
 234
 235 void QEMU_Elf_exit(QEMU_Elf *qe)
 236 {
 237     exit_states(qe);
 238     QEMU_Elf_unmap(qe);
 239 }