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