vcs.maemo.org Git - qemu/blob - qemu/hw/magic-load.c

   1 #include "vl.h"
   2 #include "disas.h"
   3 #include "exec-all.h"
   4
   5 struct exec
   6 {
   7   uint32_t a_info;   /* Use macros N_MAGIC, etc for access */
   8   uint32_t a_text;   /* length of text, in bytes */
   9   uint32_t a_data;   /* length of data, in bytes */
  10   uint32_t a_bss;    /* length of uninitialized data area, in bytes */
  11   uint32_t a_syms;   /* length of symbol table data in file, in bytes */
  12   uint32_t a_entry;  /* start address */
  13   uint32_t a_trsize; /* length of relocation info for text, in bytes */
  14   uint32_t a_drsize; /* length of relocation info for data, in bytes */
  15 };
  16
  17 #ifdef BSWAP_NEEDED
  18 static void bswap_ahdr(struct exec *e)
  19 {
  20     bswap32s(&e->a_info);
  21     bswap32s(&e->a_text);
  22     bswap32s(&e->a_data);
  23     bswap32s(&e->a_bss);
  24     bswap32s(&e->a_syms);
  25     bswap32s(&e->a_entry);
  26     bswap32s(&e->a_trsize);
  27     bswap32s(&e->a_drsize);
  28 }
  29 #else
  30 #define bswap_ahdr(x) do { } while (0)
  31 #endif
  32
  33 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
  34 #define OMAGIC 0407
  35 #define NMAGIC 0410
  36 #define ZMAGIC 0413
  37 #define QMAGIC 0314
  38 #define _N_HDROFF(x) (1024 - sizeof (struct exec))
  39 #define N_TXTOFF(x)                                                     \
  40     (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) :     \
  41      (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
  42 #define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? TARGET_PAGE_SIZE : 0)
  43 #define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text)
  44 #define _N_SEGMENT_ROUND(x) (((x) + TARGET_PAGE_SIZE - 1) & ~(TARGET_PAGE_SIZE - 1))
  45
  46 #define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text)
  47
  48 #define N_DATADDR(x) \
  49     (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \
  50      : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
  51
  52
  53 #define ELF_CLASS   ELFCLASS32
  54 #define ELF_DATA    ELFDATA2MSB
  55 #define ELF_ARCH    EM_SPARC
  56
  57 #include "elf.h"
  58
  59 #ifdef BSWAP_NEEDED
  60 static void bswap_ehdr(Elf32_Ehdr *ehdr)
  61 {
  62     bswap16s(&ehdr->e_type);                    /* Object file type */
  63     bswap16s(&ehdr->e_machine);         /* Architecture */
  64     bswap32s(&ehdr->e_version);         /* Object file version */
  65     bswap32s(&ehdr->e_entry);           /* Entry point virtual address */
  66     bswap32s(&ehdr->e_phoff);           /* Program header table file offset */
  67     bswap32s(&ehdr->e_shoff);           /* Section header table file offset */
  68     bswap32s(&ehdr->e_flags);           /* Processor-specific flags */
  69     bswap16s(&ehdr->e_ehsize);          /* ELF header size in bytes */
  70     bswap16s(&ehdr->e_phentsize);               /* Program header table entry size */
  71     bswap16s(&ehdr->e_phnum);           /* Program header table entry count */
  72     bswap16s(&ehdr->e_shentsize);               /* Section header table entry size */
  73     bswap16s(&ehdr->e_shnum);           /* Section header table entry count */
  74     bswap16s(&ehdr->e_shstrndx);                /* Section header string table index */
  75 }
  76
  77 static void bswap_phdr(Elf32_Phdr *phdr)
  78 {
  79     bswap32s(&phdr->p_type);                    /* Segment type */
  80     bswap32s(&phdr->p_offset);          /* Segment file offset */
  81     bswap32s(&phdr->p_vaddr);           /* Segment virtual address */
  82     bswap32s(&phdr->p_paddr);           /* Segment physical address */
  83     bswap32s(&phdr->p_filesz);          /* Segment size in file */
  84     bswap32s(&phdr->p_memsz);           /* Segment size in memory */
  85     bswap32s(&phdr->p_flags);           /* Segment flags */
  86     bswap32s(&phdr->p_align);           /* Segment alignment */
  87 }
  88
  89 static void bswap_shdr(Elf32_Shdr *shdr)
  90 {
  91     bswap32s(&shdr->sh_name);
  92     bswap32s(&shdr->sh_type);
  93     bswap32s(&shdr->sh_flags);
  94     bswap32s(&shdr->sh_addr);
  95     bswap32s(&shdr->sh_offset);
  96     bswap32s(&shdr->sh_size);
  97     bswap32s(&shdr->sh_link);
  98     bswap32s(&shdr->sh_info);
  99     bswap32s(&shdr->sh_addralign);
 100     bswap32s(&shdr->sh_entsize);
 101 }
 102
 103 static void bswap_sym(Elf32_Sym *sym)
 104 {
 105     bswap32s(&sym->st_name);
 106     bswap32s(&sym->st_value);
 107     bswap32s(&sym->st_size);
 108     bswap16s(&sym->st_shndx);
 109 }
 110 #else
 111 #define bswap_ehdr(e) do { } while (0)
 112 #define bswap_phdr(e) do { } while (0)
 113 #define bswap_shdr(e) do { } while (0)
 114 #define bswap_sym(e) do { } while (0)
 115 #endif
 116
 117 static int find_phdr(struct elfhdr *ehdr, int fd, struct elf_phdr *phdr, uint32_t type)
 118 {
 119     int i, retval;
 120
 121     retval = lseek(fd, ehdr->e_phoff, SEEK_SET);
 122     if (retval < 0)
 123         return -1;
 124
 125     for (i = 0; i < ehdr->e_phnum; i++) {
 126         retval = read(fd, phdr, sizeof(*phdr));
 127         if (retval < 0)
 128             return -1;
 129         bswap_phdr(phdr);
 130         if (phdr->p_type == type)
 131             return 0;
 132     }
 133     return -1;
 134 }
 135
 136 static void *find_shdr(struct elfhdr *ehdr, int fd, struct elf_shdr *shdr, uint32_t type)
 137 {
 138     int i, retval;
 139
 140     retval = lseek(fd, ehdr->e_shoff, SEEK_SET);
 141     if (retval < 0)
 142         return NULL;
 143
 144     for (i = 0; i < ehdr->e_shnum; i++) {
 145         retval = read(fd, shdr, sizeof(*shdr));
 146         if (retval < 0)
 147             return NULL;
 148         bswap_shdr(shdr);
 149         if (shdr->sh_type == type)
 150             return qemu_malloc(shdr->sh_size);
 151     }
 152     return NULL;
 153 }
 154
 155 static void *find_strtab(struct elfhdr *ehdr, int fd, struct elf_shdr *shdr, struct elf_shdr *symtab)
 156 {
 157     int retval;
 158
 159     retval = lseek(fd, ehdr->e_shoff + sizeof(struct elf_shdr) * symtab->sh_link, SEEK_SET);
 160     if (retval < 0)
 161         return NULL;
 162
 163     retval = read(fd, shdr, sizeof(*shdr));
 164     if (retval < 0)
 165         return NULL;
 166     bswap_shdr(shdr);
 167     if (shdr->sh_type == SHT_STRTAB)
 168         return qemu_malloc(shdr->sh_size);;
 169     return NULL;
 170 }
 171
 172 static int read_program(int fd, struct elf_phdr *phdr, void *dst, uint32_t entry)
 173 {
 174     int retval;
 175     retval = lseek(fd, phdr->p_offset + entry - phdr->p_vaddr, SEEK_SET);
 176     if (retval < 0)
 177         return -1;
 178     return read(fd, dst, phdr->p_filesz);
 179 }
 180
 181 static int read_section(int fd, struct elf_shdr *s, void *dst)
 182 {
 183     int retval;
 184
 185     retval = lseek(fd, s->sh_offset, SEEK_SET);
 186     if (retval < 0)
 187         return -1;
 188     retval = read(fd, dst, s->sh_size);
 189     if (retval < 0)
 190         return -1;
 191     return 0;
 192 }
 193
 194 static void *process_section(struct elfhdr *ehdr, int fd, struct elf_shdr *shdr, uint32_t type)
 195 {
 196     void *dst;
 197
 198     dst = find_shdr(ehdr, fd, shdr, type);
 199     if (!dst)
 200         goto error;
 201
 202     if (read_section(fd, shdr, dst))
 203         goto error;
 204     return dst;
 205  error:
 206     qemu_free(dst);
 207     return NULL;
 208 }
 209
 210 static void *process_strtab(struct elfhdr *ehdr, int fd, struct elf_shdr *shdr, struct elf_shdr *symtab)
 211 {
 212     void *dst;
 213
 214     dst = find_strtab(ehdr, fd, shdr, symtab);
 215     if (!dst)
 216         goto error;
 217
 218     if (read_section(fd, shdr, dst))
 219         goto error;
 220     return dst;
 221  error:
 222     qemu_free(dst);
 223     return NULL;
 224 }
 225
 226 static void load_symbols(struct elfhdr *ehdr, int fd)
 227 {
 228     struct elf_shdr symtab, strtab;
 229     struct elf_sym *syms;
 230     struct syminfo *s;
 231     int nsyms, i;
 232     char *str;
 233
 234     /* Symbol table */
 235     syms = process_section(ehdr, fd, &symtab, SHT_SYMTAB);
 236     if (!syms)
 237         return;
 238
 239     nsyms = symtab.sh_size / sizeof(struct elf_sym);
 240     for (i = 0; i < nsyms; i++)
 241         bswap_sym(&syms[i]);
 242
 243     /* String table */
 244     str = process_strtab(ehdr, fd, &strtab, &symtab);
 245     if (!str)
 246         goto error_freesyms;
 247
 248     /* Commit */
 249     s = qemu_mallocz(sizeof(*s));
 250     s->disas_symtab = syms;
 251     s->disas_num_syms = nsyms;
 252     s->disas_strtab = str;
 253     s->next = syminfos;
 254     syminfos = s;
 255     return;
 256  error_freesyms:
 257     qemu_free(syms);
 258     return;
 259 }
 260
 261 int load_elf(const char *filename, uint8_t *addr)
 262 {
 263     struct elfhdr ehdr;
 264     struct elf_phdr phdr;
 265     int retval, fd;
 266
 267     fd = open(filename, O_RDONLY | O_BINARY);
 268     if (fd < 0)
 269         goto error;
 270
 271     retval = read(fd, &ehdr, sizeof(ehdr));
 272     if (retval < 0)
 273         goto error;
 274
 275     bswap_ehdr(&ehdr);
 276
 277     if (ehdr.e_ident[0] != 0x7f || ehdr.e_ident[1] != 'E'
 278         || ehdr.e_ident[2] != 'L' || ehdr.e_ident[3] != 'F'
 279         || (ehdr.e_machine != EM_SPARC
 280             && ehdr.e_machine != EM_SPARC32PLUS))
 281         goto error;
 282
 283     if (find_phdr(&ehdr, fd, &phdr, PT_LOAD))
 284         goto error;
 285     retval = read_program(fd, &phdr, addr, ehdr.e_entry);
 286     if (retval < 0)
 287         goto error;
 288
 289     load_symbols(&ehdr, fd);
 290
 291     close(fd);
 292     return retval;
 293  error:
 294     close(fd);
 295     return -1;
 296 }
 297
 298 int load_aout(const char *filename, uint8_t *addr)
 299 {
 300     int fd, size, ret;
 301     struct exec e;
 302     uint32_t magic;
 303
 304     fd = open(filename, O_RDONLY | O_BINARY);
 305     if (fd < 0)
 306         return -1;
 307
 308     size = read(fd, &e, sizeof(e));
 309     if (size < 0)
 310         goto fail;
 311
 312     bswap_ahdr(&e);
 313
 314     magic = N_MAGIC(e);
 315     switch (magic) {
 316     case ZMAGIC:
 317     case QMAGIC:
 318     case OMAGIC:
 319         lseek(fd, N_TXTOFF(e), SEEK_SET);
 320         size = read(fd, addr, e.a_text + e.a_data);
 321         if (size < 0)
 322             goto fail;
 323         break;
 324     case NMAGIC:
 325         lseek(fd, N_TXTOFF(e), SEEK_SET);
 326         size = read(fd, addr, e.a_text);
 327         if (size < 0)
 328             goto fail;
 329         ret = read(fd, addr + N_DATADDR(e), e.a_data);
 330         if (ret < 0)
 331             goto fail;
 332         size += ret;
 333         break;
 334     default:
 335         goto fail;
 336     }
 337     close(fd);
 338     return size;
 339  fail:
 340     close(fd);
 341     return -1;
 342 }
 343