1/*
2 * QEMU Executable loader
3 *
4 * Copyright (c) 2006 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 *
24 * Gunzip functionality in this file is derived from u-boot:
25 *
26 * (C) Copyright 2008 Semihalf
27 *
28 * (C) Copyright 2000-2005
29 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
30 *
31 * This program is free software; you can redistribute it and/or
32 * modify it under the terms of the GNU General Public License as
33 * published by the Free Software Foundation; either version 2 of
34 * the License, or (at your option) any later version.
35 *
36 * This program is distributed in the hope that it will be useful,
37 * but WITHOUT ANY WARRANTY; without even the implied warranty of
38 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
39 * GNU General Public License for more details.
40 *
41 * You should have received a copy of the GNU General Public License along
42 * with this program; if not, write to the Free Software Foundation, Inc.,
43 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
44 */
45
46#include "qemu-common.h"
47#include "disas.h"
48#include "sysemu.h"
49#include "uboot_image.h"
50
51#include <zlib.h>
52
53/* return the size or -1 if error */
54int get_image_size(const char *filename)
55{
56    int fd, size;
57    fd = open(filename, O_RDONLY | O_BINARY);
58    if (fd < 0)
59        return -1;
60    size = lseek(fd, 0, SEEK_END);
61    close(fd);
62    return size;
63}
64
65/* return the size or -1 if error */
66/* deprecated, because caller does not specify buffer size! */
67int load_image(const char *filename, uint8_t *addr)
68{
69    int fd, size;
70    fd = open(filename, O_RDONLY | O_BINARY);
71    if (fd < 0)
72        return -1;
73    size = lseek(fd, 0, SEEK_END);
74    lseek(fd, 0, SEEK_SET);
75    if (read(fd, addr, size) != size) {
76        close(fd);
77        return -1;
78    }
79    close(fd);
80    return size;
81}
82
83/* return the amount read, just like fread.  0 may mean error or eof */
84int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f)
85{
86    uint8_t buf[4096];
87    target_phys_addr_t dst_begin = dst_addr;
88    size_t want, did;
89
90    while (nbytes) {
91	want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
92	did = fread(buf, 1, want, f);
93
94	cpu_physical_memory_write_rom(dst_addr, buf, did);
95	dst_addr += did;
96	nbytes -= did;
97	if (did != want)
98	    break;
99    }
100    return dst_addr - dst_begin;
101}
102
103/* returns 0 on error, 1 if ok */
104int fread_targphys_ok(target_phys_addr_t dst_addr, size_t nbytes, FILE *f)
105{
106    return fread_targphys(dst_addr, nbytes, f) == nbytes;
107}
108
109/* read()-like version */
110int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes)
111{
112    uint8_t buf[4096];
113    target_phys_addr_t dst_begin = dst_addr;
114    size_t want, did;
115
116    while (nbytes) {
117	want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
118	did = read(fd, buf, want);
119	if (did != want) break;
120
121	cpu_physical_memory_write_rom(dst_addr, buf, did);
122	dst_addr += did;
123	nbytes -= did;
124    }
125    return dst_addr - dst_begin;
126}
127
128/* return the size or -1 if error */
129int load_image_targphys(const char *filename,
130			target_phys_addr_t addr, int max_sz)
131{
132    FILE *f;
133    size_t got;
134
135    f = fopen(filename, "rb");
136    if (!f) return -1;
137
138    got = fread_targphys(addr, max_sz, f);
139    if (ferror(f)) { fclose(f); return -1; }
140    fclose(f);
141
142    return got;
143}
144
145void pstrcpy_targphys(target_phys_addr_t dest, int buf_size,
146                      const char *source)
147{
148    static const uint8_t nul_byte = 0;
149    const char *nulp;
150
151    if (buf_size <= 0) return;
152    nulp = memchr(source, 0, buf_size);
153    if (nulp) {
154	cpu_physical_memory_write_rom(dest, (uint8_t *)source,
155                                      (nulp - source) + 1);
156    } else {
157	cpu_physical_memory_write_rom(dest, (uint8_t *)source, buf_size - 1);
158	cpu_physical_memory_write_rom(dest, &nul_byte, 1);
159    }
160}
161
162/* A.OUT loader */
163
164struct exec
165{
166  uint32_t a_info;   /* Use macros N_MAGIC, etc for access */
167  uint32_t a_text;   /* length of text, in bytes */
168  uint32_t a_data;   /* length of data, in bytes */
169  uint32_t a_bss;    /* length of uninitialized data area, in bytes */
170  uint32_t a_syms;   /* length of symbol table data in file, in bytes */
171  uint32_t a_entry;  /* start address */
172  uint32_t a_trsize; /* length of relocation info for text, in bytes */
173  uint32_t a_drsize; /* length of relocation info for data, in bytes */
174};
175
176#ifdef BSWAP_NEEDED
177static void bswap_ahdr(struct exec *e)
178{
179    bswap32s(&e->a_info);
180    bswap32s(&e->a_text);
181    bswap32s(&e->a_data);
182    bswap32s(&e->a_bss);
183    bswap32s(&e->a_syms);
184    bswap32s(&e->a_entry);
185    bswap32s(&e->a_trsize);
186    bswap32s(&e->a_drsize);
187}
188#else
189#define bswap_ahdr(x) do { } while (0)
190#endif
191
192#define N_MAGIC(exec) ((exec).a_info & 0xffff)
193#define OMAGIC 0407
194#define NMAGIC 0410
195#define ZMAGIC 0413
196#define QMAGIC 0314
197#define _N_HDROFF(x) (1024 - sizeof (struct exec))
198#define N_TXTOFF(x)							\
199    (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) :	\
200     (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
201#define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? TARGET_PAGE_SIZE : 0)
202#define _N_SEGMENT_ROUND(x) (((x) + TARGET_PAGE_SIZE - 1) & ~(TARGET_PAGE_SIZE - 1))
203
204#define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text)
205
206#define N_DATADDR(x) \
207    (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \
208     : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
209
210
211int load_aout(const char *filename, target_phys_addr_t addr, int max_sz)
212{
213    int fd, size, ret;
214    struct exec e;
215    uint32_t magic;
216
217    fd = open(filename, O_RDONLY | O_BINARY);
218    if (fd < 0)
219        return -1;
220
221    size = read(fd, &e, sizeof(e));
222    if (size < 0)
223        goto fail;
224
225    bswap_ahdr(&e);
226
227    magic = N_MAGIC(e);
228    switch (magic) {
229    case ZMAGIC:
230    case QMAGIC:
231    case OMAGIC:
232        if (e.a_text + e.a_data > max_sz)
233            goto fail;
234	lseek(fd, N_TXTOFF(e), SEEK_SET);
235	size = read_targphys(fd, addr, e.a_text + e.a_data);
236	if (size < 0)
237	    goto fail;
238	break;
239    case NMAGIC:
240        if (N_DATADDR(e) + e.a_data > max_sz)
241            goto fail;
242	lseek(fd, N_TXTOFF(e), SEEK_SET);
243	size = read_targphys(fd, addr, e.a_text);
244	if (size < 0)
245	    goto fail;
246	ret = read_targphys(fd, addr + N_DATADDR(e), e.a_data);
247	if (ret < 0)
248	    goto fail;
249	size += ret;
250	break;
251    default:
252	goto fail;
253    }
254    close(fd);
255    return size;
256 fail:
257    close(fd);
258    return -1;
259}
260
261/* ELF loader */
262
263static void *load_at(int fd, int offset, int size)
264{
265    void *ptr;
266    if (lseek(fd, offset, SEEK_SET) < 0)
267        return NULL;
268    ptr = qemu_malloc(size);
269    if (read(fd, ptr, size) != size) {
270        qemu_free(ptr);
271        return NULL;
272    }
273    return ptr;
274}
275
276
277#define ELF_CLASS   ELFCLASS32
278#include "elf.h"
279
280#define SZ		32
281#define elf_word        uint32_t
282#define elf_sword        int32_t
283#define bswapSZs	bswap32s
284#include "elf_ops.h"
285
286#undef elfhdr
287#undef elf_phdr
288#undef elf_shdr
289#undef elf_sym
290#undef elf_note
291#undef elf_word
292#undef elf_sword
293#undef bswapSZs
294#undef SZ
295#define elfhdr		elf64_hdr
296#define elf_phdr	elf64_phdr
297#define elf_note	elf64_note
298#define elf_shdr	elf64_shdr
299#define elf_sym		elf64_sym
300#define elf_word        uint64_t
301#define elf_sword        int64_t
302#define bswapSZs	bswap64s
303#define SZ		64
304#include "elf_ops.h"
305
306/* return < 0 if error, otherwise the number of bytes loaded in memory */
307int load_elf(const char *filename, int64_t address_offset,
308             uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr)
309{
310    int fd, data_order, host_data_order, must_swab, ret;
311    uint8_t e_ident[EI_NIDENT];
312
313    fd = open(filename, O_RDONLY | O_BINARY);
314    if (fd < 0) {
315        perror(filename);
316        return -1;
317    }
318    if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
319        goto fail;
320    if (e_ident[0] != ELFMAG0 ||
321        e_ident[1] != ELFMAG1 ||
322        e_ident[2] != ELFMAG2 ||
323        e_ident[3] != ELFMAG3)
324        goto fail;
325#ifdef HOST_WORDS_BIGENDIAN
326    data_order = ELFDATA2MSB;
327#else
328    data_order = ELFDATA2LSB;
329#endif
330    must_swab = data_order != e_ident[EI_DATA];
331
332#ifdef TARGET_WORDS_BIGENDIAN
333    host_data_order = ELFDATA2MSB;
334#else
335    host_data_order = ELFDATA2LSB;
336#endif
337    if (host_data_order != e_ident[EI_DATA])
338        return -1;
339
340    lseek(fd, 0, SEEK_SET);
341    if (e_ident[EI_CLASS] == ELFCLASS64) {
342        ret = load_elf64(fd, address_offset, must_swab, pentry,
343                         lowaddr, highaddr);
344    } else {
345        ret = load_elf32(fd, address_offset, must_swab, pentry,
346                         lowaddr, highaddr);
347    }
348
349    close(fd);
350    return ret;
351
352 fail:
353    close(fd);
354    return -1;
355}
356
357static void bswap_uboot_header(uboot_image_header_t *hdr)
358{
359#ifndef HOST_WORDS_BIGENDIAN
360    bswap32s(&hdr->ih_magic);
361    bswap32s(&hdr->ih_hcrc);
362    bswap32s(&hdr->ih_time);
363    bswap32s(&hdr->ih_size);
364    bswap32s(&hdr->ih_load);
365    bswap32s(&hdr->ih_ep);
366    bswap32s(&hdr->ih_dcrc);
367#endif
368}
369
370
371#define ZALLOC_ALIGNMENT	16
372
373static void *zalloc(void *x, unsigned items, unsigned size)
374{
375    void *p;
376
377    size *= items;
378    size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
379
380    p = qemu_malloc(size);
381
382    return (p);
383}
384
385static void zfree(void *x, void *addr)
386{
387    qemu_free(addr);
388}
389
390
391#define HEAD_CRC	2
392#define EXTRA_FIELD	4
393#define ORIG_NAME	8
394#define COMMENT		0x10
395#define RESERVED	0xe0
396
397#define DEFLATED	8
398
399/* This is the maximum in uboot, so if a uImage overflows this, it would
400 * overflow on real hardware too. */
401#define UBOOT_MAX_GUNZIP_BYTES 0x800000
402
403static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src,
404                      size_t srclen)
405{
406    z_stream s;
407    ssize_t dstbytes;
408    int r, i, flags;
409
410    /* skip header */
411    i = 10;
412    flags = src[3];
413    if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
414        puts ("Error: Bad gzipped data\n");
415        return -1;
416    }
417    if ((flags & EXTRA_FIELD) != 0)
418        i = 12 + src[10] + (src[11] << 8);
419    if ((flags & ORIG_NAME) != 0)
420        while (src[i++] != 0)
421            ;
422    if ((flags & COMMENT) != 0)
423        while (src[i++] != 0)
424            ;
425    if ((flags & HEAD_CRC) != 0)
426        i += 2;
427    if (i >= srclen) {
428        puts ("Error: gunzip out of data in header\n");
429        return -1;
430    }
431
432    s.zalloc = zalloc;
433    s.zfree = zfree;
434
435    r = inflateInit2(&s, -MAX_WBITS);
436    if (r != Z_OK) {
437        printf ("Error: inflateInit2() returned %d\n", r);
438        return (-1);
439    }
440    s.next_in = src + i;
441    s.avail_in = srclen - i;
442    s.next_out = dst;
443    s.avail_out = dstlen;
444    r = inflate(&s, Z_FINISH);
445    if (r != Z_OK && r != Z_STREAM_END) {
446        printf ("Error: inflate() returned %d\n", r);
447        return -1;
448    }
449    dstbytes = s.next_out - (unsigned char *) dst;
450    inflateEnd(&s);
451
452    return dstbytes;
453}
454
455/* Load a U-Boot image.  */
456int load_uimage(const char *filename, target_ulong *ep, target_ulong *loadaddr,
457                int *is_linux)
458{
459    int fd;
460    int size;
461    uboot_image_header_t h;
462    uboot_image_header_t *hdr = &h;
463    uint8_t *data = NULL;
464    int ret = -1;
465
466    fd = open(filename, O_RDONLY | O_BINARY);
467    if (fd < 0)
468        return -1;
469
470    size = read(fd, hdr, sizeof(uboot_image_header_t));
471    if (size < 0)
472        goto out;
473
474    bswap_uboot_header(hdr);
475
476    if (hdr->ih_magic != IH_MAGIC)
477        goto out;
478
479    /* TODO: Implement other image types.  */
480    if (hdr->ih_type != IH_TYPE_KERNEL) {
481        fprintf(stderr, "Can only load u-boot image type \"kernel\"\n");
482        goto out;
483    }
484
485    switch (hdr->ih_comp) {
486    case IH_COMP_NONE:
487    case IH_COMP_GZIP:
488        break;
489    default:
490        fprintf(stderr,
491                "Unable to load u-boot images with compression type %d\n",
492                hdr->ih_comp);
493        goto out;
494    }
495
496    /* TODO: Check CPU type.  */
497    if (is_linux) {
498        if (hdr->ih_os == IH_OS_LINUX)
499            *is_linux = 1;
500        else
501            *is_linux = 0;
502    }
503
504    *ep = hdr->ih_ep;
505    data = qemu_malloc(hdr->ih_size);
506
507    if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
508        fprintf(stderr, "Error reading file\n");
509        goto out;
510    }
511
512    if (hdr->ih_comp == IH_COMP_GZIP) {
513        uint8_t *compressed_data;
514        size_t max_bytes;
515        ssize_t bytes;
516
517        compressed_data = data;
518        max_bytes = UBOOT_MAX_GUNZIP_BYTES;
519        data = qemu_malloc(max_bytes);
520
521        bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
522        qemu_free(compressed_data);
523        if (bytes < 0) {
524            fprintf(stderr, "Unable to decompress gzipped image!\n");
525            goto out;
526        }
527        hdr->ih_size = bytes;
528    }
529
530    cpu_physical_memory_write_rom(hdr->ih_load, data, hdr->ih_size);
531
532    if (loadaddr)
533        *loadaddr = hdr->ih_load;
534
535    ret = hdr->ih_size;
536
537out:
538    if (data)
539        qemu_free(data);
540    close(fd);
541    return ret;
542}
543