hw/core/loader.c

   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, see <http://www.gnu.org/licenses/>.
  43  */
  44
  45 #include "qemu/osdep.h"
  46 #include "hw/hw.h"
  47 #include "disas/disas.h"
  48 #include "monitor/monitor.h"
  49 #include "sysemu/sysemu.h"
  50 #include "uboot_image.h"
  51 #include "hw/loader.h"
  52 #include "hw/nvram/fw_cfg.h"
  53 #include "exec/memory.h"
  54 #include "exec/address-spaces.h"
  55 #include "hw/boards.h"
  56
  57 #include <zlib.h>
  58
  59 static int roms_loaded;
  60
  61 /* return the size or -1 if error */
  62 int get_image_size(const char *filename)
  63 {
  64     int fd, size;
  65     fd = open(filename, O_RDONLY | O_BINARY);
  66     if (fd < 0)
  67         return -1;
  68     size = lseek(fd, 0, SEEK_END);
  69     close(fd);
  70     return size;
  71 }
  72
  73 /* return the size or -1 if error */
  74 /* deprecated, because caller does not specify buffer size! */
  75 int load_image(const char *filename, uint8_t *addr)
  76 {
  77     int fd, size;
  78     fd = open(filename, O_RDONLY | O_BINARY);
  79     if (fd < 0)
  80         return -1;
  81     size = lseek(fd, 0, SEEK_END);
  82     if (size == -1) {
  83         fprintf(stderr, "file %-20s: get size error: %s\n",
  84                 filename, strerror(errno));
  85         close(fd);
  86         return -1;
  87     }
  88
  89     lseek(fd, 0, SEEK_SET);
  90     if (read(fd, addr, size) != size) {
  91         close(fd);
  92         return -1;
  93     }
  94     close(fd);
  95     return size;
  96 }
  97
  98 /* return the size or -1 if error */
  99 ssize_t load_image_size(const char *filename, void *addr, size_t size)
 100 {
 101     int fd;
 102     ssize_t actsize;
 103
 104     fd = open(filename, O_RDONLY | O_BINARY);
 105     if (fd < 0) {
 106         return -1;
 107     }
 108
 109     actsize = read(fd, addr, size);
 110     if (actsize < 0) {
 111         close(fd);
 112         return -1;
 113     }
 114     close(fd);
 115
 116     return actsize;
 117 }
 118
 119 /* read()-like version */
 120 ssize_t read_targphys(const char *name,
 121                       int fd, hwaddr dst_addr, size_t nbytes)
 122 {
 123     uint8_t *buf;
 124     ssize_t did;
 125
 126     buf = g_malloc(nbytes);
 127     did = read(fd, buf, nbytes);
 128     if (did > 0)
 129         rom_add_blob_fixed("read", buf, did, dst_addr);
 130     g_free(buf);
 131     return did;
 132 }
 133
 134 /* return the size or -1 if error */
 135 int load_image_targphys(const char *filename,
 136                         hwaddr addr, uint64_t max_sz)
 137 {
 138     int size;
 139
 140     size = get_image_size(filename);
 141     if (size > max_sz) {
 142         return -1;
 143     }
 144     if (size > 0) {
 145         rom_add_file_fixed(filename, addr, -1);
 146     }
 147     return size;
 148 }
 149
 150 int load_image_mr(const char *filename, MemoryRegion *mr)
 151 {
 152     int size;
 153
 154     if (!memory_access_is_direct(mr, false)) {
 155         /* Can only load an image into RAM or ROM */
 156         return -1;
 157     }
 158
 159     size = get_image_size(filename);
 160
 161     if (size > memory_region_size(mr)) {
 162         return -1;
 163     }
 164     if (size > 0) {
 165         if (rom_add_file_mr(filename, mr, -1) < 0) {
 166             return -1;
 167         }
 168     }
 169     return size;
 170 }
 171
 172 void pstrcpy_targphys(const char *name, hwaddr dest, int buf_size,
 173                       const char *source)
 174 {
 175     const char *nulp;
 176     char *ptr;
 177
 178     if (buf_size <= 0) return;
 179     nulp = memchr(source, 0, buf_size);
 180     if (nulp) {
 181         rom_add_blob_fixed(name, source, (nulp - source) + 1, dest);
 182     } else {
 183         rom_add_blob_fixed(name, source, buf_size, dest);
 184         ptr = rom_ptr(dest + buf_size - 1);
 185         *ptr = 0;
 186     }
 187 }
 188
 189 /* A.OUT loader */
 190
 191 struct exec
 192 {
 193   uint32_t a_info;   /* Use macros N_MAGIC, etc for access */
 194   uint32_t a_text;   /* length of text, in bytes */
 195   uint32_t a_data;   /* length of data, in bytes */
 196   uint32_t a_bss;    /* length of uninitialized data area, in bytes */
 197   uint32_t a_syms;   /* length of symbol table data in file, in bytes */
 198   uint32_t a_entry;  /* start address */
 199   uint32_t a_trsize; /* length of relocation info for text, in bytes */
 200   uint32_t a_drsize; /* length of relocation info for data, in bytes */
 201 };
 202
 203 static void bswap_ahdr(struct exec *e)
 204 {
 205     bswap32s(&e->a_info);
 206     bswap32s(&e->a_text);
 207     bswap32s(&e->a_data);
 208     bswap32s(&e->a_bss);
 209     bswap32s(&e->a_syms);
 210     bswap32s(&e->a_entry);
 211     bswap32s(&e->a_trsize);
 212     bswap32s(&e->a_drsize);
 213 }
 214
 215 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
 216 #define OMAGIC 0407
 217 #define NMAGIC 0410
 218 #define ZMAGIC 0413
 219 #define QMAGIC 0314
 220 #define _N_HDROFF(x) (1024 - sizeof (struct exec))
 221 #define N_TXTOFF(x)                                                     \
 222     (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) :     \
 223      (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
 224 #define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0)
 225 #define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1))
 226
 227 #define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text)
 228
 229 #define N_DATADDR(x, target_page_size) \
 230     (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \
 231      : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size)))
 232
 233
 234 int load_aout(const char *filename, hwaddr addr, int max_sz,
 235               int bswap_needed, hwaddr target_page_size)
 236 {
 237     int fd;
 238     ssize_t size, ret;
 239     struct exec e;
 240     uint32_t magic;
 241
 242     fd = open(filename, O_RDONLY | O_BINARY);
 243     if (fd < 0)
 244         return -1;
 245
 246     size = read(fd, &e, sizeof(e));
 247     if (size < 0)
 248         goto fail;
 249
 250     if (bswap_needed) {
 251         bswap_ahdr(&e);
 252     }
 253
 254     magic = N_MAGIC(e);
 255     switch (magic) {
 256     case ZMAGIC:
 257     case QMAGIC:
 258     case OMAGIC:
 259         if (e.a_text + e.a_data > max_sz)
 260             goto fail;
 261         lseek(fd, N_TXTOFF(e), SEEK_SET);
 262         size = read_targphys(filename, fd, addr, e.a_text + e.a_data);
 263         if (size < 0)
 264             goto fail;
 265         break;
 266     case NMAGIC:
 267         if (N_DATADDR(e, target_page_size) + e.a_data > max_sz)
 268             goto fail;
 269         lseek(fd, N_TXTOFF(e), SEEK_SET);
 270         size = read_targphys(filename, fd, addr, e.a_text);
 271         if (size < 0)
 272             goto fail;
 273         ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size),
 274                             e.a_data);
 275         if (ret < 0)
 276             goto fail;
 277         size += ret;
 278         break;
 279     default:
 280         goto fail;
 281     }
 282     close(fd);
 283     return size;
 284  fail:
 285     close(fd);
 286     return -1;
 287 }
 288
 289 /* ELF loader */
 290
 291 static void *load_at(int fd, off_t offset, size_t size)
 292 {
 293     void *ptr;
 294     if (lseek(fd, offset, SEEK_SET) < 0)
 295         return NULL;
 296     ptr = g_malloc(size);
 297     if (read(fd, ptr, size) != size) {
 298         g_free(ptr);
 299         return NULL;
 300     }
 301     return ptr;
 302 }
 303
 304 #ifdef ELF_CLASS
 305 #undef ELF_CLASS
 306 #endif
 307
 308 #define ELF_CLASS   ELFCLASS32
 309 #include "elf.h"
 310
 311 #define SZ              32
 312 #define elf_word        uint32_t
 313 #define elf_sword        int32_t
 314 #define bswapSZs        bswap32s
 315 #include "hw/elf_ops.h"
 316
 317 #undef elfhdr
 318 #undef elf_phdr
 319 #undef elf_shdr
 320 #undef elf_sym
 321 #undef elf_rela
 322 #undef elf_note
 323 #undef elf_word
 324 #undef elf_sword
 325 #undef bswapSZs
 326 #undef SZ
 327 #define elfhdr          elf64_hdr
 328 #define elf_phdr        elf64_phdr
 329 #define elf_note        elf64_note
 330 #define elf_shdr        elf64_shdr
 331 #define elf_sym         elf64_sym
 332 #define elf_rela        elf64_rela
 333 #define elf_word        uint64_t
 334 #define elf_sword        int64_t
 335 #define bswapSZs        bswap64s
 336 #define SZ              64
 337 #include "hw/elf_ops.h"
 338
 339 const char *load_elf_strerror(int error)
 340 {
 341     switch (error) {
 342     case 0:
 343         return "No error";
 344     case ELF_LOAD_FAILED:
 345         return "Failed to load ELF";
 346     case ELF_LOAD_NOT_ELF:
 347         return "The image is not ELF";
 348     case ELF_LOAD_WRONG_ARCH:
 349         return "The image is from incompatible architecture";
 350     case ELF_LOAD_WRONG_ENDIAN:
 351         return "The image has incorrect endianness";
 352     default:
 353         return "Unknown error";
 354     }
 355 }
 356
 357 void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp)
 358 {
 359     int fd;
 360     uint8_t e_ident_local[EI_NIDENT];
 361     uint8_t *e_ident;
 362     size_t hdr_size, off;
 363     bool is64l;
 364
 365     if (!hdr) {
 366         hdr = e_ident_local;
 367     }
 368     e_ident = hdr;
 369
 370     fd = open(filename, O_RDONLY | O_BINARY);
 371     if (fd < 0) {
 372         error_setg_errno(errp, errno, "Failed to open file: %s", filename);
 373         return;
 374     }
 375     if (read(fd, hdr, EI_NIDENT) != EI_NIDENT) {
 376         error_setg_errno(errp, errno, "Failed to read file: %s", filename);
 377         goto fail;
 378     }
 379     if (e_ident[0] != ELFMAG0 ||
 380         e_ident[1] != ELFMAG1 ||
 381         e_ident[2] != ELFMAG2 ||
 382         e_ident[3] != ELFMAG3) {
 383         error_setg(errp, "Bad ELF magic");
 384         goto fail;
 385     }
 386
 387     is64l = e_ident[EI_CLASS] == ELFCLASS64;
 388     hdr_size = is64l ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr);
 389     if (is64) {
 390         *is64 = is64l;
 391     }
 392
 393     off = EI_NIDENT;
 394     while (hdr != e_ident_local && off < hdr_size) {
 395         size_t br = read(fd, hdr + off, hdr_size - off);
 396         switch (br) {
 397         case 0:
 398             error_setg(errp, "File too short: %s", filename);
 399             goto fail;
 400         case -1:
 401             error_setg_errno(errp, errno, "Failed to read file: %s",
 402                              filename);
 403             goto fail;
 404         }
 405         off += br;
 406     }
 407
 408 fail:
 409     close(fd);
 410 }
 411
 412 /* return < 0 if error, otherwise the number of bytes loaded in memory */
 413 int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
 414              void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
 415              uint64_t *highaddr, int big_endian, int elf_machine,
 416              int clear_lsb, int data_swab)
 417 {
 418     int fd, data_order, target_data_order, must_swab, ret = ELF_LOAD_FAILED;
 419     uint8_t e_ident[EI_NIDENT];
 420
 421     fd = open(filename, O_RDONLY | O_BINARY);
 422     if (fd < 0) {
 423         perror(filename);
 424         return -1;
 425     }
 426     if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
 427         goto fail;
 428     if (e_ident[0] != ELFMAG0 ||
 429         e_ident[1] != ELFMAG1 ||
 430         e_ident[2] != ELFMAG2 ||
 431         e_ident[3] != ELFMAG3) {
 432         ret = ELF_LOAD_NOT_ELF;
 433         goto fail;
 434     }
 435 #ifdef HOST_WORDS_BIGENDIAN
 436     data_order = ELFDATA2MSB;
 437 #else
 438     data_order = ELFDATA2LSB;
 439 #endif
 440     must_swab = data_order != e_ident[EI_DATA];
 441     if (big_endian) {
 442         target_data_order = ELFDATA2MSB;
 443     } else {
 444         target_data_order = ELFDATA2LSB;
 445     }
 446
 447     if (target_data_order != e_ident[EI_DATA]) {
 448         ret = ELF_LOAD_WRONG_ENDIAN;
 449         goto fail;
 450     }
 451
 452     lseek(fd, 0, SEEK_SET);
 453     if (e_ident[EI_CLASS] == ELFCLASS64) {
 454         ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab,
 455                          pentry, lowaddr, highaddr, elf_machine, clear_lsb,
 456                          data_swab);
 457     } else {
 458         ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab,
 459                          pentry, lowaddr, highaddr, elf_machine, clear_lsb,
 460                          data_swab);
 461     }
 462
 463  fail:
 464     close(fd);
 465     return ret;
 466 }
 467
 468 static void bswap_uboot_header(uboot_image_header_t *hdr)
 469 {
 470 #ifndef HOST_WORDS_BIGENDIAN
 471     bswap32s(&hdr->ih_magic);
 472     bswap32s(&hdr->ih_hcrc);
 473     bswap32s(&hdr->ih_time);
 474     bswap32s(&hdr->ih_size);
 475     bswap32s(&hdr->ih_load);
 476     bswap32s(&hdr->ih_ep);
 477     bswap32s(&hdr->ih_dcrc);
 478 #endif
 479 }
 480
 481
 482 #define ZALLOC_ALIGNMENT        16
 483
 484 static void *zalloc(void *x, unsigned items, unsigned size)
 485 {
 486     void *p;
 487
 488     size *= items;
 489     size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
 490
 491     p = g_malloc(size);
 492
 493     return (p);
 494 }
 495
 496 static void zfree(void *x, void *addr)
 497 {
 498     g_free(addr);
 499 }
 500
 501
 502 #define HEAD_CRC        2
 503 #define EXTRA_FIELD     4
 504 #define ORIG_NAME       8
 505 #define COMMENT         0x10
 506 #define RESERVED        0xe0
 507
 508 #define DEFLATED        8
 509
 510 /* This is the usual maximum in uboot, so if a uImage overflows this, it would
 511  * overflow on real hardware too. */
 512 #define UBOOT_MAX_GUNZIP_BYTES (64 << 20)
 513
 514 static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src,
 515                       size_t srclen)
 516 {
 517     z_stream s;
 518     ssize_t dstbytes;
 519     int r, i, flags;
 520
 521     /* skip header */
 522     i = 10;
 523     flags = src[3];
 524     if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
 525         puts ("Error: Bad gzipped data\n");
 526         return -1;
 527     }
 528     if ((flags & EXTRA_FIELD) != 0)
 529         i = 12 + src[10] + (src[11] << 8);
 530     if ((flags & ORIG_NAME) != 0)
 531         while (src[i++] != 0)
 532             ;
 533     if ((flags & COMMENT) != 0)
 534         while (src[i++] != 0)
 535             ;
 536     if ((flags & HEAD_CRC) != 0)
 537         i += 2;
 538     if (i >= srclen) {
 539         puts ("Error: gunzip out of data in header\n");
 540         return -1;
 541     }
 542
 543     s.zalloc = zalloc;
 544     s.zfree = zfree;
 545
 546     r = inflateInit2(&s, -MAX_WBITS);
 547     if (r != Z_OK) {
 548         printf ("Error: inflateInit2() returned %d\n", r);
 549         return (-1);
 550     }
 551     s.next_in = src + i;
 552     s.avail_in = srclen - i;
 553     s.next_out = dst;
 554     s.avail_out = dstlen;
 555     r = inflate(&s, Z_FINISH);
 556     if (r != Z_OK && r != Z_STREAM_END) {
 557         printf ("Error: inflate() returned %d\n", r);
 558         return -1;
 559     }
 560     dstbytes = s.next_out - (unsigned char *) dst;
 561     inflateEnd(&s);
 562
 563     return dstbytes;
 564 }
 565
 566 /* Load a U-Boot image.  */
 567 static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,
 568                             int *is_linux, uint8_t image_type,
 569                             uint64_t (*translate_fn)(void *, uint64_t),
 570                             void *translate_opaque)
 571 {
 572     int fd;
 573     int size;
 574     hwaddr address;
 575     uboot_image_header_t h;
 576     uboot_image_header_t *hdr = &h;
 577     uint8_t *data = NULL;
 578     int ret = -1;
 579     int do_uncompress = 0;
 580
 581     fd = open(filename, O_RDONLY | O_BINARY);
 582     if (fd < 0)
 583         return -1;
 584
 585     size = read(fd, hdr, sizeof(uboot_image_header_t));
 586     if (size < 0)
 587         goto out;
 588
 589     bswap_uboot_header(hdr);
 590
 591     if (hdr->ih_magic != IH_MAGIC)
 592         goto out;
 593
 594     if (hdr->ih_type != image_type) {
 595         fprintf(stderr, "Wrong image type %d, expected %d\n", hdr->ih_type,
 596                 image_type);
 597         goto out;
 598     }
 599
 600     /* TODO: Implement other image types.  */
 601     switch (hdr->ih_type) {
 602     case IH_TYPE_KERNEL:
 603         address = hdr->ih_load;
 604         if (translate_fn) {
 605             address = translate_fn(translate_opaque, address);
 606         }
 607         if (loadaddr) {
 608             *loadaddr = hdr->ih_load;
 609         }
 610
 611         switch (hdr->ih_comp) {
 612         case IH_COMP_NONE:
 613             break;
 614         case IH_COMP_GZIP:
 615             do_uncompress = 1;
 616             break;
 617         default:
 618             fprintf(stderr,
 619                     "Unable to load u-boot images with compression type %d\n",
 620                     hdr->ih_comp);
 621             goto out;
 622         }
 623
 624         if (ep) {
 625             *ep = hdr->ih_ep;
 626         }
 627
 628         /* TODO: Check CPU type.  */
 629         if (is_linux) {
 630             if (hdr->ih_os == IH_OS_LINUX) {
 631                 *is_linux = 1;
 632             } else {
 633                 *is_linux = 0;
 634             }
 635         }
 636
 637         break;
 638     case IH_TYPE_RAMDISK:
 639         address = *loadaddr;
 640         break;
 641     default:
 642         fprintf(stderr, "Unsupported u-boot image type %d\n", hdr->ih_type);
 643         goto out;
 644     }
 645
 646     data = g_malloc(hdr->ih_size);
 647
 648     if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
 649         fprintf(stderr, "Error reading file\n");
 650         goto out;
 651     }
 652
 653     if (do_uncompress) {
 654         uint8_t *compressed_data;
 655         size_t max_bytes;
 656         ssize_t bytes;
 657
 658         compressed_data = data;
 659         max_bytes = UBOOT_MAX_GUNZIP_BYTES;
 660         data = g_malloc(max_bytes);
 661
 662         bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
 663         g_free(compressed_data);
 664         if (bytes < 0) {
 665             fprintf(stderr, "Unable to decompress gzipped image!\n");
 666             goto out;
 667         }
 668         hdr->ih_size = bytes;
 669     }
 670
 671     rom_add_blob_fixed(filename, data, hdr->ih_size, address);
 672
 673     ret = hdr->ih_size;
 674
 675 out:
 676     g_free(data);
 677     close(fd);
 678     return ret;
 679 }
 680
 681 int load_uimage(const char *filename, hwaddr *ep, hwaddr *loadaddr,
 682                 int *is_linux,
 683                 uint64_t (*translate_fn)(void *, uint64_t),
 684                 void *translate_opaque)
 685 {
 686     return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
 687                             translate_fn, translate_opaque);
 688 }
 689
 690 /* Load a ramdisk.  */
 691 int load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz)
 692 {
 693     return load_uboot_image(filename, NULL, &addr, NULL, IH_TYPE_RAMDISK,
 694                             NULL, NULL);
 695 }
 696
 697 /* Load a gzip-compressed kernel to a dynamically allocated buffer. */
 698 int load_image_gzipped_buffer(const char *filename, uint64_t max_sz,
 699                               uint8_t **buffer)
 700 {
 701     uint8_t *compressed_data = NULL;
 702     uint8_t *data = NULL;
 703     gsize len;
 704     ssize_t bytes;
 705     int ret = -1;
 706
 707     if (!g_file_get_contents(filename, (char **) &compressed_data, &len,
 708                              NULL)) {
 709         goto out;
 710     }
 711
 712     /* Is it a gzip-compressed file? */
 713     if (len < 2 ||
 714         compressed_data[0] != 0x1f ||
 715         compressed_data[1] != 0x8b) {
 716         goto out;
 717     }
 718
 719     if (max_sz > LOAD_IMAGE_MAX_GUNZIP_BYTES) {
 720         max_sz = LOAD_IMAGE_MAX_GUNZIP_BYTES;
 721     }
 722
 723     data = g_malloc(max_sz);
 724     bytes = gunzip(data, max_sz, compressed_data, len);
 725     if (bytes < 0) {
 726         fprintf(stderr, "%s: unable to decompress gzipped kernel file\n",
 727                 filename);
 728         goto out;
 729     }
 730
 731     /* trim to actual size and return to caller */
 732     *buffer = g_realloc(data, bytes);
 733     ret = bytes;
 734     /* ownership has been transferred to caller */
 735     data = NULL;
 736
 737  out:
 738     g_free(compressed_data);
 739     g_free(data);
 740     return ret;
 741 }
 742
 743 /* Load a gzip-compressed kernel. */
 744 int load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz)
 745 {
 746     int bytes;
 747     uint8_t *data;
 748
 749     bytes = load_image_gzipped_buffer(filename, max_sz, &data);
 750     if (bytes != -1) {
 751         rom_add_blob_fixed(filename, data, bytes, addr);
 752         g_free(data);
 753     }
 754     return bytes;
 755 }
 756
 757 /*
 758  * Functions for reboot-persistent memory regions.
 759  *  - used for vga bios and option roms.
 760  *  - also linux kernel (-kernel / -initrd).
 761  */
 762
 763 typedef struct Rom Rom;
 764
 765 struct Rom {
 766     char *name;
 767     char *path;
 768
 769     /* datasize is the amount of memory allocated in "data". If datasize is less
 770      * than romsize, it means that the area from datasize to romsize is filled
 771      * with zeros.
 772      */
 773     size_t romsize;
 774     size_t datasize;
 775
 776     uint8_t *data;
 777     MemoryRegion *mr;
 778     int isrom;
 779     char *fw_dir;
 780     char *fw_file;
 781
 782     hwaddr addr;
 783     QTAILQ_ENTRY(Rom) next;
 784 };
 785
 786 static FWCfgState *fw_cfg;
 787 static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms);
 788
 789 static void rom_insert(Rom *rom)
 790 {
 791     Rom *item;
 792
 793     if (roms_loaded) {
 794         hw_error ("ROM images must be loaded at startup\n");
 795     }
 796
 797     /* list is ordered by load address */
 798     QTAILQ_FOREACH(item, &roms, next) {
 799         if (rom->addr >= item->addr)
 800             continue;
 801         QTAILQ_INSERT_BEFORE(item, rom, next);
 802         return;
 803     }
 804     QTAILQ_INSERT_TAIL(&roms, rom, next);
 805 }
 806
 807 static void fw_cfg_resized(const char *id, uint64_t length, void *host)
 808 {
 809     if (fw_cfg) {
 810         fw_cfg_modify_file(fw_cfg, id + strlen("/rom@"), host, length);
 811     }
 812 }
 813
 814 static void *rom_set_mr(Rom *rom, Object *owner, const char *name)
 815 {
 816     void *data;
 817
 818     rom->mr = g_malloc(sizeof(*rom->mr));
 819     memory_region_init_resizeable_ram(rom->mr, owner, name,
 820                                       rom->datasize, rom->romsize,
 821                                       fw_cfg_resized,
 822                                       &error_fatal);
 823     memory_region_set_readonly(rom->mr, true);
 824     vmstate_register_ram_global(rom->mr);
 825
 826     data = memory_region_get_ram_ptr(rom->mr);
 827     memcpy(data, rom->data, rom->datasize);
 828
 829     return data;
 830 }
 831
 832 int rom_add_file(const char *file, const char *fw_dir,
 833                  hwaddr addr, int32_t bootindex,
 834                  bool option_rom, MemoryRegion *mr)
 835 {
 836     MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
 837     Rom *rom;
 838     int rc, fd = -1;
 839     char devpath[100];
 840
 841     rom = g_malloc0(sizeof(*rom));
 842     rom->name = g_strdup(file);
 843     rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name);
 844     if (rom->path == NULL) {
 845         rom->path = g_strdup(file);
 846     }
 847
 848     fd = open(rom->path, O_RDONLY | O_BINARY);
 849     if (fd == -1) {
 850         fprintf(stderr, "Could not open option rom '%s': %s\n",
 851                 rom->path, strerror(errno));
 852         goto err;
 853     }
 854
 855     if (fw_dir) {
 856         rom->fw_dir  = g_strdup(fw_dir);
 857         rom->fw_file = g_strdup(file);
 858     }
 859     rom->addr     = addr;
 860     rom->romsize  = lseek(fd, 0, SEEK_END);
 861     if (rom->romsize == -1) {
 862         fprintf(stderr, "rom: file %-20s: get size error: %s\n",
 863                 rom->name, strerror(errno));
 864         goto err;
 865     }
 866
 867     rom->datasize = rom->romsize;
 868     rom->data     = g_malloc0(rom->datasize);
 869     lseek(fd, 0, SEEK_SET);
 870     rc = read(fd, rom->data, rom->datasize);
 871     if (rc != rom->datasize) {
 872         fprintf(stderr, "rom: file %-20s: read error: rc=%d (expected %zd)\n",
 873                 rom->name, rc, rom->datasize);
 874         goto err;
 875     }
 876     close(fd);
 877     rom_insert(rom);
 878     if (rom->fw_file && fw_cfg) {
 879         const char *basename;
 880         char fw_file_name[FW_CFG_MAX_FILE_PATH];
 881         void *data;
 882
 883         basename = strrchr(rom->fw_file, '/');
 884         if (basename) {
 885             basename++;
 886         } else {
 887             basename = rom->fw_file;
 888         }
 889         snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir,
 890                  basename);
 891         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 892
 893         if ((!option_rom || mc->option_rom_has_mr) && mc->rom_file_has_mr) {
 894             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);
 895         } else {
 896             data = rom->data;
 897         }
 898
 899         fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize);
 900     } else {
 901         if (mr) {
 902             rom->mr = mr;
 903             snprintf(devpath, sizeof(devpath), "/rom@%s", file);
 904         } else {
 905             snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr);
 906         }
 907     }
 908
 909     add_boot_device_path(bootindex, NULL, devpath);
 910     return 0;
 911
 912 err:
 913     if (fd != -1)
 914         close(fd);
 915     g_free(rom->data);
 916     g_free(rom->path);
 917     g_free(rom->name);
 918     g_free(rom);
 919     return -1;
 920 }
 921
 922 MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len,
 923                    size_t max_len, hwaddr addr, const char *fw_file_name,
 924                    FWCfgReadCallback fw_callback, void *callback_opaque)
 925 {
 926     MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
 927     Rom *rom;
 928     MemoryRegion *mr = NULL;
 929
 930     rom           = g_malloc0(sizeof(*rom));
 931     rom->name     = g_strdup(name);
 932     rom->addr     = addr;
 933     rom->romsize  = max_len ? max_len : len;
 934     rom->datasize = len;
 935     rom->data     = g_malloc0(rom->datasize);
 936     memcpy(rom->data, blob, len);
 937     rom_insert(rom);
 938     if (fw_file_name && fw_cfg) {
 939         char devpath[100];
 940         void *data;
 941
 942         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 943
 944         if (mc->rom_file_has_mr) {
 945             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);
 946             mr = rom->mr;
 947         } else {
 948             data = rom->data;
 949         }
 950
 951         fw_cfg_add_file_callback(fw_cfg, fw_file_name,
 952                                  fw_callback, callback_opaque,
 953                                  data, rom->datasize);
 954     }
 955     return mr;
 956 }
 957
 958 /* This function is specific for elf program because we don't need to allocate
 959  * all the rom. We just allocate the first part and the rest is just zeros. This
 960  * is why romsize and datasize are different. Also, this function seize the
 961  * memory ownership of "data", so we don't have to allocate and copy the buffer.
 962  */
 963 int rom_add_elf_program(const char *name, void *data, size_t datasize,
 964                         size_t romsize, hwaddr addr)
 965 {
 966     Rom *rom;
 967
 968     rom           = g_malloc0(sizeof(*rom));
 969     rom->name     = g_strdup(name);
 970     rom->addr     = addr;
 971     rom->datasize = datasize;
 972     rom->romsize  = romsize;
 973     rom->data     = data;
 974     rom_insert(rom);
 975     return 0;
 976 }
 977
 978 int rom_add_vga(const char *file)
 979 {
 980     return rom_add_file(file, "vgaroms", 0, -1, true, NULL);
 981 }
 982
 983 int rom_add_option(const char *file, int32_t bootindex)
 984 {
 985     return rom_add_file(file, "genroms", 0, bootindex, true, NULL);
 986 }
 987
 988 static void rom_reset(void *unused)
 989 {
 990     Rom *rom;
 991
 992     QTAILQ_FOREACH(rom, &roms, next) {
 993         if (rom->fw_file) {
 994             continue;
 995         }
 996         if (rom->data == NULL) {
 997             continue;
 998         }
 999         if (rom->mr) {
1000             void *host = memory_region_get_ram_ptr(rom->mr);
1001             memcpy(host, rom->data, rom->datasize);
1002         } else {
1003             cpu_physical_memory_write_rom(&address_space_memory,
1004                                           rom->addr, rom->data, rom->datasize);
1005         }
1006         if (rom->isrom) {
1007             /* rom needs to be written only once */
1008             g_free(rom->data);
1009             rom->data = NULL;
1010         }
1011         /*
1012          * The rom loader is really on the same level as firmware in the guest
1013          * shadowing a ROM into RAM. Such a shadowing mechanism needs to ensure
1014          * that the instruction cache for that new region is clear, so that the
1015          * CPU definitely fetches its instructions from the just written data.
1016          */
1017         cpu_flush_icache_range(rom->addr, rom->datasize);
1018     }
1019 }
1020
1021 int rom_check_and_register_reset(void)
1022 {
1023     hwaddr addr = 0;
1024     MemoryRegionSection section;
1025     Rom *rom;
1026
1027     QTAILQ_FOREACH(rom, &roms, next) {
1028         if (rom->fw_file) {
1029             continue;
1030         }
1031         if (addr > rom->addr) {
1032             fprintf(stderr, "rom: requested regions overlap "
1033                     "(rom %s. free=0x" TARGET_FMT_plx
1034                     ", addr=0x" TARGET_FMT_plx ")\n",
1035                     rom->name, addr, rom->addr);
1036             return -1;
1037         }
1038         addr  = rom->addr;
1039         addr += rom->romsize;
1040         section = memory_region_find(get_system_memory(), rom->addr, 1);
1041         rom->isrom = int128_nz(section.size) && memory_region_is_rom(section.mr);
1042         memory_region_unref(section.mr);
1043     }
1044     qemu_register_reset(rom_reset, NULL);
1045     roms_loaded = 1;
1046     return 0;
1047 }
1048
1049 void rom_set_fw(FWCfgState *f)
1050 {
1051     fw_cfg = f;
1052 }
1053
1054 static Rom *find_rom(hwaddr addr)
1055 {
1056     Rom *rom;
1057
1058     QTAILQ_FOREACH(rom, &roms, next) {
1059         if (rom->fw_file) {
1060             continue;
1061         }
1062         if (rom->mr) {
1063             continue;
1064         }
1065         if (rom->addr > addr) {
1066             continue;
1067         }
1068         if (rom->addr + rom->romsize < addr) {
1069             continue;
1070         }
1071         return rom;
1072     }
1073     return NULL;
1074 }
1075
1076 /*
1077  * Copies memory from registered ROMs to dest. Any memory that is contained in
1078  * a ROM between addr and addr + size is copied. Note that this can involve
1079  * multiple ROMs, which need not start at addr and need not end at addr + size.
1080  */
1081 int rom_copy(uint8_t *dest, hwaddr addr, size_t size)
1082 {
1083     hwaddr end = addr + size;
1084     uint8_t *s, *d = dest;
1085     size_t l = 0;
1086     Rom *rom;
1087
1088     QTAILQ_FOREACH(rom, &roms, next) {
1089         if (rom->fw_file) {
1090             continue;
1091         }
1092         if (rom->mr) {
1093             continue;
1094         }
1095         if (rom->addr + rom->romsize < addr) {
1096             continue;
1097         }
1098         if (rom->addr > end) {
1099             break;
1100         }
1101
1102         d = dest + (rom->addr - addr);
1103         s = rom->data;
1104         l = rom->datasize;
1105
1106         if ((d + l) > (dest + size)) {
1107             l = dest - d;
1108         }
1109
1110         if (l > 0) {
1111             memcpy(d, s, l);
1112         }
1113
1114         if (rom->romsize > rom->datasize) {
1115             /* If datasize is less than romsize, it means that we didn't
1116              * allocate all the ROM because the trailing data are only zeros.
1117              */
1118
1119             d += l;
1120             l = rom->romsize - rom->datasize;
1121
1122             if ((d + l) > (dest + size)) {
1123                 /* Rom size doesn't fit in the destination area. Adjust to avoid
1124                  * overflow.
1125                  */
1126                 l = dest - d;
1127             }
1128
1129             if (l > 0) {
1130                 memset(d, 0x0, l);
1131             }
1132         }
1133     }
1134
1135     return (d + l) - dest;
1136 }
1137
1138 void *rom_ptr(hwaddr addr)
1139 {
1140     Rom *rom;
1141
1142     rom = find_rom(addr);
1143     if (!rom || !rom->data)
1144         return NULL;
1145     return rom->data + (addr - rom->addr);
1146 }
1147
1148 void hmp_info_roms(Monitor *mon, const QDict *qdict)
1149 {
1150     Rom *rom;
1151
1152     QTAILQ_FOREACH(rom, &roms, next) {
1153         if (rom->mr) {
1154             monitor_printf(mon, "%s"
1155                            " size=0x%06zx name=\"%s\"\n",
1156                            memory_region_name(rom->mr),
1157                            rom->romsize,
1158                            rom->name);
1159         } else if (!rom->fw_file) {
1160             monitor_printf(mon, "addr=" TARGET_FMT_plx
1161                            " size=0x%06zx mem=%s name=\"%s\"\n",
1162                            rom->addr, rom->romsize,
1163                            rom->isrom ? "rom" : "ram",
1164                            rom->name);
1165         } else {
1166             monitor_printf(mon, "fw=%s/%s"
1167                            " size=0x%06zx name=\"%s\"\n",
1168                            rom->fw_dir,
1169                            rom->fw_file,
1170                            rom->romsize,
1171                            rom->name);
1172         }
1173     }
1174 }