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