Merge remote-tracking branch 'remotes/philmd-gitlab/tags/renesas-20201027' into staging
[qemu.git] / 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 "qemu-common.h"
47 #include "qapi/error.h"
48 #include "trace.h"
49 #include "hw/hw.h"
50 #include "disas/disas.h"
51 #include "migration/vmstate.h"
52 #include "monitor/monitor.h"
53 #include "sysemu/reset.h"
54 #include "sysemu/sysemu.h"
55 #include "uboot_image.h"
56 #include "hw/loader.h"
57 #include "hw/nvram/fw_cfg.h"
58 #include "exec/memory.h"
59 #include "exec/address-spaces.h"
60 #include "hw/boards.h"
61 #include "qemu/cutils.h"
62 #include "sysemu/runstate.h"
63
64 #include <zlib.h>
65
66 static int roms_loaded;
67
68 /* return the size or -1 if error */
69 int64_t get_image_size(const char *filename)
70 {
71 int fd;
72 int64_t size;
73 fd = open(filename, O_RDONLY | O_BINARY);
74 if (fd < 0)
75 return -1;
76 size = lseek(fd, 0, SEEK_END);
77 close(fd);
78 return size;
79 }
80
81 /* return the size or -1 if error */
82 ssize_t load_image_size(const char *filename, void *addr, size_t size)
83 {
84 int fd;
85 ssize_t actsize, l = 0;
86
87 fd = open(filename, O_RDONLY | O_BINARY);
88 if (fd < 0) {
89 return -1;
90 }
91
92 while ((actsize = read(fd, addr + l, size - l)) > 0) {
93 l += actsize;
94 }
95
96 close(fd);
97
98 return actsize < 0 ? -1 : l;
99 }
100
101 /* read()-like version */
102 ssize_t read_targphys(const char *name,
103 int fd, hwaddr dst_addr, size_t nbytes)
104 {
105 uint8_t *buf;
106 ssize_t did;
107
108 buf = g_malloc(nbytes);
109 did = read(fd, buf, nbytes);
110 if (did > 0)
111 rom_add_blob_fixed("read", buf, did, dst_addr);
112 g_free(buf);
113 return did;
114 }
115
116 int load_image_targphys(const char *filename,
117 hwaddr addr, uint64_t max_sz)
118 {
119 return load_image_targphys_as(filename, addr, max_sz, NULL);
120 }
121
122 /* return the size or -1 if error */
123 int load_image_targphys_as(const char *filename,
124 hwaddr addr, uint64_t max_sz, AddressSpace *as)
125 {
126 int size;
127
128 size = get_image_size(filename);
129 if (size < 0 || size > max_sz) {
130 return -1;
131 }
132 if (size > 0) {
133 if (rom_add_file_fixed_as(filename, addr, -1, as) < 0) {
134 return -1;
135 }
136 }
137 return size;
138 }
139
140 int load_image_mr(const char *filename, MemoryRegion *mr)
141 {
142 int size;
143
144 if (!memory_access_is_direct(mr, false)) {
145 /* Can only load an image into RAM or ROM */
146 return -1;
147 }
148
149 size = get_image_size(filename);
150
151 if (size < 0 || size > memory_region_size(mr)) {
152 return -1;
153 }
154 if (size > 0) {
155 if (rom_add_file_mr(filename, mr, -1) < 0) {
156 return -1;
157 }
158 }
159 return size;
160 }
161
162 void pstrcpy_targphys(const char *name, hwaddr dest, int buf_size,
163 const char *source)
164 {
165 const char *nulp;
166 char *ptr;
167
168 if (buf_size <= 0) return;
169 nulp = memchr(source, 0, buf_size);
170 if (nulp) {
171 rom_add_blob_fixed(name, source, (nulp - source) + 1, dest);
172 } else {
173 rom_add_blob_fixed(name, source, buf_size, dest);
174 ptr = rom_ptr(dest + buf_size - 1, sizeof(*ptr));
175 *ptr = 0;
176 }
177 }
178
179 /* A.OUT loader */
180
181 struct exec
182 {
183 uint32_t a_info; /* Use macros N_MAGIC, etc for access */
184 uint32_t a_text; /* length of text, in bytes */
185 uint32_t a_data; /* length of data, in bytes */
186 uint32_t a_bss; /* length of uninitialized data area, in bytes */
187 uint32_t a_syms; /* length of symbol table data in file, in bytes */
188 uint32_t a_entry; /* start address */
189 uint32_t a_trsize; /* length of relocation info for text, in bytes */
190 uint32_t a_drsize; /* length of relocation info for data, in bytes */
191 };
192
193 static void bswap_ahdr(struct exec *e)
194 {
195 bswap32s(&e->a_info);
196 bswap32s(&e->a_text);
197 bswap32s(&e->a_data);
198 bswap32s(&e->a_bss);
199 bswap32s(&e->a_syms);
200 bswap32s(&e->a_entry);
201 bswap32s(&e->a_trsize);
202 bswap32s(&e->a_drsize);
203 }
204
205 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
206 #define OMAGIC 0407
207 #define NMAGIC 0410
208 #define ZMAGIC 0413
209 #define QMAGIC 0314
210 #define _N_HDROFF(x) (1024 - sizeof (struct exec))
211 #define N_TXTOFF(x) \
212 (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \
213 (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
214 #define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0)
215 #define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1))
216
217 #define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text)
218
219 #define N_DATADDR(x, target_page_size) \
220 (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \
221 : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size)))
222
223
224 int load_aout(const char *filename, hwaddr addr, int max_sz,
225 int bswap_needed, hwaddr target_page_size)
226 {
227 int fd;
228 ssize_t size, ret;
229 struct exec e;
230 uint32_t magic;
231
232 fd = open(filename, O_RDONLY | O_BINARY);
233 if (fd < 0)
234 return -1;
235
236 size = read(fd, &e, sizeof(e));
237 if (size < 0)
238 goto fail;
239
240 if (bswap_needed) {
241 bswap_ahdr(&e);
242 }
243
244 magic = N_MAGIC(e);
245 switch (magic) {
246 case ZMAGIC:
247 case QMAGIC:
248 case OMAGIC:
249 if (e.a_text + e.a_data > max_sz)
250 goto fail;
251 lseek(fd, N_TXTOFF(e), SEEK_SET);
252 size = read_targphys(filename, fd, addr, e.a_text + e.a_data);
253 if (size < 0)
254 goto fail;
255 break;
256 case NMAGIC:
257 if (N_DATADDR(e, target_page_size) + e.a_data > max_sz)
258 goto fail;
259 lseek(fd, N_TXTOFF(e), SEEK_SET);
260 size = read_targphys(filename, fd, addr, e.a_text);
261 if (size < 0)
262 goto fail;
263 ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size),
264 e.a_data);
265 if (ret < 0)
266 goto fail;
267 size += ret;
268 break;
269 default:
270 goto fail;
271 }
272 close(fd);
273 return size;
274 fail:
275 close(fd);
276 return -1;
277 }
278
279 /* ELF loader */
280
281 static void *load_at(int fd, off_t offset, size_t size)
282 {
283 void *ptr;
284 if (lseek(fd, offset, SEEK_SET) < 0)
285 return NULL;
286 ptr = g_malloc(size);
287 if (read(fd, ptr, size) != size) {
288 g_free(ptr);
289 return NULL;
290 }
291 return ptr;
292 }
293
294 #ifdef ELF_CLASS
295 #undef ELF_CLASS
296 #endif
297
298 #define ELF_CLASS ELFCLASS32
299 #include "elf.h"
300
301 #define SZ 32
302 #define elf_word uint32_t
303 #define elf_sword int32_t
304 #define bswapSZs bswap32s
305 #include "hw/elf_ops.h"
306
307 #undef elfhdr
308 #undef elf_phdr
309 #undef elf_shdr
310 #undef elf_sym
311 #undef elf_rela
312 #undef elf_note
313 #undef elf_word
314 #undef elf_sword
315 #undef bswapSZs
316 #undef SZ
317 #define elfhdr elf64_hdr
318 #define elf_phdr elf64_phdr
319 #define elf_note elf64_note
320 #define elf_shdr elf64_shdr
321 #define elf_sym elf64_sym
322 #define elf_rela elf64_rela
323 #define elf_word uint64_t
324 #define elf_sword int64_t
325 #define bswapSZs bswap64s
326 #define SZ 64
327 #include "hw/elf_ops.h"
328
329 const char *load_elf_strerror(int error)
330 {
331 switch (error) {
332 case 0:
333 return "No error";
334 case ELF_LOAD_FAILED:
335 return "Failed to load ELF";
336 case ELF_LOAD_NOT_ELF:
337 return "The image is not ELF";
338 case ELF_LOAD_WRONG_ARCH:
339 return "The image is from incompatible architecture";
340 case ELF_LOAD_WRONG_ENDIAN:
341 return "The image has incorrect endianness";
342 case ELF_LOAD_TOO_BIG:
343 return "The image segments are too big to load";
344 default:
345 return "Unknown error";
346 }
347 }
348
349 void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp)
350 {
351 int fd;
352 uint8_t e_ident_local[EI_NIDENT];
353 uint8_t *e_ident;
354 size_t hdr_size, off;
355 bool is64l;
356
357 if (!hdr) {
358 hdr = e_ident_local;
359 }
360 e_ident = hdr;
361
362 fd = open(filename, O_RDONLY | O_BINARY);
363 if (fd < 0) {
364 error_setg_errno(errp, errno, "Failed to open file: %s", filename);
365 return;
366 }
367 if (read(fd, hdr, EI_NIDENT) != EI_NIDENT) {
368 error_setg_errno(errp, errno, "Failed to read file: %s", filename);
369 goto fail;
370 }
371 if (e_ident[0] != ELFMAG0 ||
372 e_ident[1] != ELFMAG1 ||
373 e_ident[2] != ELFMAG2 ||
374 e_ident[3] != ELFMAG3) {
375 error_setg(errp, "Bad ELF magic");
376 goto fail;
377 }
378
379 is64l = e_ident[EI_CLASS] == ELFCLASS64;
380 hdr_size = is64l ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr);
381 if (is64) {
382 *is64 = is64l;
383 }
384
385 off = EI_NIDENT;
386 while (hdr != e_ident_local && off < hdr_size) {
387 size_t br = read(fd, hdr + off, hdr_size - off);
388 switch (br) {
389 case 0:
390 error_setg(errp, "File too short: %s", filename);
391 goto fail;
392 case -1:
393 error_setg_errno(errp, errno, "Failed to read file: %s",
394 filename);
395 goto fail;
396 }
397 off += br;
398 }
399
400 fail:
401 close(fd);
402 }
403
404 /* return < 0 if error, otherwise the number of bytes loaded in memory */
405 int load_elf(const char *filename,
406 uint64_t (*elf_note_fn)(void *, void *, bool),
407 uint64_t (*translate_fn)(void *, uint64_t),
408 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
409 uint64_t *highaddr, uint32_t *pflags, int big_endian,
410 int elf_machine, int clear_lsb, int data_swab)
411 {
412 return load_elf_as(filename, elf_note_fn, translate_fn, translate_opaque,
413 pentry, lowaddr, highaddr, pflags, big_endian,
414 elf_machine, clear_lsb, data_swab, NULL);
415 }
416
417 /* return < 0 if error, otherwise the number of bytes loaded in memory */
418 int load_elf_as(const char *filename,
419 uint64_t (*elf_note_fn)(void *, void *, bool),
420 uint64_t (*translate_fn)(void *, uint64_t),
421 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
422 uint64_t *highaddr, uint32_t *pflags, int big_endian,
423 int elf_machine, int clear_lsb, int data_swab, AddressSpace *as)
424 {
425 return load_elf_ram(filename, elf_note_fn, translate_fn, translate_opaque,
426 pentry, lowaddr, highaddr, pflags, big_endian,
427 elf_machine, clear_lsb, data_swab, as, true);
428 }
429
430 /* return < 0 if error, otherwise the number of bytes loaded in memory */
431 int load_elf_ram(const char *filename,
432 uint64_t (*elf_note_fn)(void *, void *, bool),
433 uint64_t (*translate_fn)(void *, uint64_t),
434 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
435 uint64_t *highaddr, uint32_t *pflags, int big_endian,
436 int elf_machine, int clear_lsb, int data_swab,
437 AddressSpace *as, bool load_rom)
438 {
439 return load_elf_ram_sym(filename, elf_note_fn,
440 translate_fn, translate_opaque,
441 pentry, lowaddr, highaddr, pflags, big_endian,
442 elf_machine, clear_lsb, data_swab, as,
443 load_rom, NULL);
444 }
445
446 /* return < 0 if error, otherwise the number of bytes loaded in memory */
447 int load_elf_ram_sym(const char *filename,
448 uint64_t (*elf_note_fn)(void *, void *, bool),
449 uint64_t (*translate_fn)(void *, uint64_t),
450 void *translate_opaque, uint64_t *pentry,
451 uint64_t *lowaddr, uint64_t *highaddr, uint32_t *pflags,
452 int big_endian, int elf_machine,
453 int clear_lsb, int data_swab,
454 AddressSpace *as, bool load_rom, symbol_fn_t sym_cb)
455 {
456 int fd, data_order, target_data_order, must_swab, ret = ELF_LOAD_FAILED;
457 uint8_t e_ident[EI_NIDENT];
458
459 fd = open(filename, O_RDONLY | O_BINARY);
460 if (fd < 0) {
461 perror(filename);
462 return -1;
463 }
464 if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
465 goto fail;
466 if (e_ident[0] != ELFMAG0 ||
467 e_ident[1] != ELFMAG1 ||
468 e_ident[2] != ELFMAG2 ||
469 e_ident[3] != ELFMAG3) {
470 ret = ELF_LOAD_NOT_ELF;
471 goto fail;
472 }
473 #ifdef HOST_WORDS_BIGENDIAN
474 data_order = ELFDATA2MSB;
475 #else
476 data_order = ELFDATA2LSB;
477 #endif
478 must_swab = data_order != e_ident[EI_DATA];
479 if (big_endian) {
480 target_data_order = ELFDATA2MSB;
481 } else {
482 target_data_order = ELFDATA2LSB;
483 }
484
485 if (target_data_order != e_ident[EI_DATA]) {
486 ret = ELF_LOAD_WRONG_ENDIAN;
487 goto fail;
488 }
489
490 lseek(fd, 0, SEEK_SET);
491 if (e_ident[EI_CLASS] == ELFCLASS64) {
492 ret = load_elf64(filename, fd, elf_note_fn,
493 translate_fn, translate_opaque, must_swab,
494 pentry, lowaddr, highaddr, pflags, elf_machine,
495 clear_lsb, data_swab, as, load_rom, sym_cb);
496 } else {
497 ret = load_elf32(filename, fd, elf_note_fn,
498 translate_fn, translate_opaque, must_swab,
499 pentry, lowaddr, highaddr, pflags, elf_machine,
500 clear_lsb, data_swab, as, load_rom, sym_cb);
501 }
502
503 fail:
504 close(fd);
505 return ret;
506 }
507
508 static void bswap_uboot_header(uboot_image_header_t *hdr)
509 {
510 #ifndef HOST_WORDS_BIGENDIAN
511 bswap32s(&hdr->ih_magic);
512 bswap32s(&hdr->ih_hcrc);
513 bswap32s(&hdr->ih_time);
514 bswap32s(&hdr->ih_size);
515 bswap32s(&hdr->ih_load);
516 bswap32s(&hdr->ih_ep);
517 bswap32s(&hdr->ih_dcrc);
518 #endif
519 }
520
521
522 #define ZALLOC_ALIGNMENT 16
523
524 static void *zalloc(void *x, unsigned items, unsigned size)
525 {
526 void *p;
527
528 size *= items;
529 size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
530
531 p = g_malloc(size);
532
533 return (p);
534 }
535
536 static void zfree(void *x, void *addr)
537 {
538 g_free(addr);
539 }
540
541
542 #define HEAD_CRC 2
543 #define EXTRA_FIELD 4
544 #define ORIG_NAME 8
545 #define COMMENT 0x10
546 #define RESERVED 0xe0
547
548 #define DEFLATED 8
549
550 ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, size_t srclen)
551 {
552 z_stream s;
553 ssize_t dstbytes;
554 int r, i, flags;
555
556 /* skip header */
557 i = 10;
558 flags = src[3];
559 if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
560 puts ("Error: Bad gzipped data\n");
561 return -1;
562 }
563 if ((flags & EXTRA_FIELD) != 0)
564 i = 12 + src[10] + (src[11] << 8);
565 if ((flags & ORIG_NAME) != 0)
566 while (src[i++] != 0)
567 ;
568 if ((flags & COMMENT) != 0)
569 while (src[i++] != 0)
570 ;
571 if ((flags & HEAD_CRC) != 0)
572 i += 2;
573 if (i >= srclen) {
574 puts ("Error: gunzip out of data in header\n");
575 return -1;
576 }
577
578 s.zalloc = zalloc;
579 s.zfree = zfree;
580
581 r = inflateInit2(&s, -MAX_WBITS);
582 if (r != Z_OK) {
583 printf ("Error: inflateInit2() returned %d\n", r);
584 return (-1);
585 }
586 s.next_in = src + i;
587 s.avail_in = srclen - i;
588 s.next_out = dst;
589 s.avail_out = dstlen;
590 r = inflate(&s, Z_FINISH);
591 if (r != Z_OK && r != Z_STREAM_END) {
592 printf ("Error: inflate() returned %d\n", r);
593 return -1;
594 }
595 dstbytes = s.next_out - (unsigned char *) dst;
596 inflateEnd(&s);
597
598 return dstbytes;
599 }
600
601 /* Load a U-Boot image. */
602 static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,
603 int *is_linux, uint8_t image_type,
604 uint64_t (*translate_fn)(void *, uint64_t),
605 void *translate_opaque, AddressSpace *as)
606 {
607 int fd;
608 int size;
609 hwaddr address;
610 uboot_image_header_t h;
611 uboot_image_header_t *hdr = &h;
612 uint8_t *data = NULL;
613 int ret = -1;
614 int do_uncompress = 0;
615
616 fd = open(filename, O_RDONLY | O_BINARY);
617 if (fd < 0)
618 return -1;
619
620 size = read(fd, hdr, sizeof(uboot_image_header_t));
621 if (size < sizeof(uboot_image_header_t)) {
622 goto out;
623 }
624
625 bswap_uboot_header(hdr);
626
627 if (hdr->ih_magic != IH_MAGIC)
628 goto out;
629
630 if (hdr->ih_type != image_type) {
631 if (!(image_type == IH_TYPE_KERNEL &&
632 hdr->ih_type == IH_TYPE_KERNEL_NOLOAD)) {
633 fprintf(stderr, "Wrong image type %d, expected %d\n", hdr->ih_type,
634 image_type);
635 goto out;
636 }
637 }
638
639 /* TODO: Implement other image types. */
640 switch (hdr->ih_type) {
641 case IH_TYPE_KERNEL_NOLOAD:
642 if (!loadaddr || *loadaddr == LOAD_UIMAGE_LOADADDR_INVALID) {
643 fprintf(stderr, "this image format (kernel_noload) cannot be "
644 "loaded on this machine type");
645 goto out;
646 }
647
648 hdr->ih_load = *loadaddr + sizeof(*hdr);
649 hdr->ih_ep += hdr->ih_load;
650 /* fall through */
651 case IH_TYPE_KERNEL:
652 address = hdr->ih_load;
653 if (translate_fn) {
654 address = translate_fn(translate_opaque, address);
655 }
656 if (loadaddr) {
657 *loadaddr = hdr->ih_load;
658 }
659
660 switch (hdr->ih_comp) {
661 case IH_COMP_NONE:
662 break;
663 case IH_COMP_GZIP:
664 do_uncompress = 1;
665 break;
666 default:
667 fprintf(stderr,
668 "Unable to load u-boot images with compression type %d\n",
669 hdr->ih_comp);
670 goto out;
671 }
672
673 if (ep) {
674 *ep = hdr->ih_ep;
675 }
676
677 /* TODO: Check CPU type. */
678 if (is_linux) {
679 if (hdr->ih_os == IH_OS_LINUX) {
680 *is_linux = 1;
681 } else {
682 *is_linux = 0;
683 }
684 }
685
686 break;
687 case IH_TYPE_RAMDISK:
688 address = *loadaddr;
689 break;
690 default:
691 fprintf(stderr, "Unsupported u-boot image type %d\n", hdr->ih_type);
692 goto out;
693 }
694
695 data = g_malloc(hdr->ih_size);
696
697 if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
698 fprintf(stderr, "Error reading file\n");
699 goto out;
700 }
701
702 if (do_uncompress) {
703 uint8_t *compressed_data;
704 size_t max_bytes;
705 ssize_t bytes;
706
707 compressed_data = data;
708 max_bytes = UBOOT_MAX_GUNZIP_BYTES;
709 data = g_malloc(max_bytes);
710
711 bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
712 g_free(compressed_data);
713 if (bytes < 0) {
714 fprintf(stderr, "Unable to decompress gzipped image!\n");
715 goto out;
716 }
717 hdr->ih_size = bytes;
718 }
719
720 rom_add_blob_fixed_as(filename, data, hdr->ih_size, address, as);
721
722 ret = hdr->ih_size;
723
724 out:
725 g_free(data);
726 close(fd);
727 return ret;
728 }
729
730 int load_uimage(const char *filename, hwaddr *ep, hwaddr *loadaddr,
731 int *is_linux,
732 uint64_t (*translate_fn)(void *, uint64_t),
733 void *translate_opaque)
734 {
735 return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
736 translate_fn, translate_opaque, NULL);
737 }
738
739 int load_uimage_as(const char *filename, hwaddr *ep, hwaddr *loadaddr,
740 int *is_linux,
741 uint64_t (*translate_fn)(void *, uint64_t),
742 void *translate_opaque, AddressSpace *as)
743 {
744 return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
745 translate_fn, translate_opaque, as);
746 }
747
748 /* Load a ramdisk. */
749 int load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz)
750 {
751 return load_ramdisk_as(filename, addr, max_sz, NULL);
752 }
753
754 int load_ramdisk_as(const char *filename, hwaddr addr, uint64_t max_sz,
755 AddressSpace *as)
756 {
757 return load_uboot_image(filename, NULL, &addr, NULL, IH_TYPE_RAMDISK,
758 NULL, NULL, as);
759 }
760
761 /* Load a gzip-compressed kernel to a dynamically allocated buffer. */
762 int load_image_gzipped_buffer(const char *filename, uint64_t max_sz,
763 uint8_t **buffer)
764 {
765 uint8_t *compressed_data = NULL;
766 uint8_t *data = NULL;
767 gsize len;
768 ssize_t bytes;
769 int ret = -1;
770
771 if (!g_file_get_contents(filename, (char **) &compressed_data, &len,
772 NULL)) {
773 goto out;
774 }
775
776 /* Is it a gzip-compressed file? */
777 if (len < 2 ||
778 compressed_data[0] != 0x1f ||
779 compressed_data[1] != 0x8b) {
780 goto out;
781 }
782
783 if (max_sz > LOAD_IMAGE_MAX_GUNZIP_BYTES) {
784 max_sz = LOAD_IMAGE_MAX_GUNZIP_BYTES;
785 }
786
787 data = g_malloc(max_sz);
788 bytes = gunzip(data, max_sz, compressed_data, len);
789 if (bytes < 0) {
790 fprintf(stderr, "%s: unable to decompress gzipped kernel file\n",
791 filename);
792 goto out;
793 }
794
795 /* trim to actual size and return to caller */
796 *buffer = g_realloc(data, bytes);
797 ret = bytes;
798 /* ownership has been transferred to caller */
799 data = NULL;
800
801 out:
802 g_free(compressed_data);
803 g_free(data);
804 return ret;
805 }
806
807 /* Load a gzip-compressed kernel. */
808 int load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz)
809 {
810 int bytes;
811 uint8_t *data;
812
813 bytes = load_image_gzipped_buffer(filename, max_sz, &data);
814 if (bytes != -1) {
815 rom_add_blob_fixed(filename, data, bytes, addr);
816 g_free(data);
817 }
818 return bytes;
819 }
820
821 /*
822 * Functions for reboot-persistent memory regions.
823 * - used for vga bios and option roms.
824 * - also linux kernel (-kernel / -initrd).
825 */
826
827 typedef struct Rom Rom;
828
829 struct Rom {
830 char *name;
831 char *path;
832
833 /* datasize is the amount of memory allocated in "data". If datasize is less
834 * than romsize, it means that the area from datasize to romsize is filled
835 * with zeros.
836 */
837 size_t romsize;
838 size_t datasize;
839
840 uint8_t *data;
841 MemoryRegion *mr;
842 AddressSpace *as;
843 int isrom;
844 char *fw_dir;
845 char *fw_file;
846 GMappedFile *mapped_file;
847
848 bool committed;
849
850 hwaddr addr;
851 QTAILQ_ENTRY(Rom) next;
852 };
853
854 static FWCfgState *fw_cfg;
855 static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms);
856
857 /*
858 * rom->data can be heap-allocated or memory-mapped (e.g. when added with
859 * rom_add_elf_program())
860 */
861 static void rom_free_data(Rom *rom)
862 {
863 if (rom->mapped_file) {
864 g_mapped_file_unref(rom->mapped_file);
865 rom->mapped_file = NULL;
866 } else {
867 g_free(rom->data);
868 }
869
870 rom->data = NULL;
871 }
872
873 static void rom_free(Rom *rom)
874 {
875 rom_free_data(rom);
876 g_free(rom->path);
877 g_free(rom->name);
878 g_free(rom->fw_dir);
879 g_free(rom->fw_file);
880 g_free(rom);
881 }
882
883 static inline bool rom_order_compare(Rom *rom, Rom *item)
884 {
885 return ((uintptr_t)(void *)rom->as > (uintptr_t)(void *)item->as) ||
886 (rom->as == item->as && rom->addr >= item->addr);
887 }
888
889 static void rom_insert(Rom *rom)
890 {
891 Rom *item;
892
893 if (roms_loaded) {
894 hw_error ("ROM images must be loaded at startup\n");
895 }
896
897 /* The user didn't specify an address space, this is the default */
898 if (!rom->as) {
899 rom->as = &address_space_memory;
900 }
901
902 rom->committed = false;
903
904 /* List is ordered by load address in the same address space */
905 QTAILQ_FOREACH(item, &roms, next) {
906 if (rom_order_compare(rom, item)) {
907 continue;
908 }
909 QTAILQ_INSERT_BEFORE(item, rom, next);
910 return;
911 }
912 QTAILQ_INSERT_TAIL(&roms, rom, next);
913 }
914
915 static void fw_cfg_resized(const char *id, uint64_t length, void *host)
916 {
917 if (fw_cfg) {
918 fw_cfg_modify_file(fw_cfg, id + strlen("/rom@"), host, length);
919 }
920 }
921
922 static void *rom_set_mr(Rom *rom, Object *owner, const char *name, bool ro)
923 {
924 void *data;
925
926 rom->mr = g_malloc(sizeof(*rom->mr));
927 memory_region_init_resizeable_ram(rom->mr, owner, name,
928 rom->datasize, rom->romsize,
929 fw_cfg_resized,
930 &error_fatal);
931 memory_region_set_readonly(rom->mr, ro);
932 vmstate_register_ram_global(rom->mr);
933
934 data = memory_region_get_ram_ptr(rom->mr);
935 memcpy(data, rom->data, rom->datasize);
936
937 return data;
938 }
939
940 int rom_add_file(const char *file, const char *fw_dir,
941 hwaddr addr, int32_t bootindex,
942 bool option_rom, MemoryRegion *mr,
943 AddressSpace *as)
944 {
945 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
946 Rom *rom;
947 int rc, fd = -1;
948 char devpath[100];
949
950 if (as && mr) {
951 fprintf(stderr, "Specifying an Address Space and Memory Region is " \
952 "not valid when loading a rom\n");
953 /* We haven't allocated anything so we don't need any cleanup */
954 return -1;
955 }
956
957 rom = g_malloc0(sizeof(*rom));
958 rom->name = g_strdup(file);
959 rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name);
960 rom->as = as;
961 if (rom->path == NULL) {
962 rom->path = g_strdup(file);
963 }
964
965 fd = open(rom->path, O_RDONLY | O_BINARY);
966 if (fd == -1) {
967 fprintf(stderr, "Could not open option rom '%s': %s\n",
968 rom->path, strerror(errno));
969 goto err;
970 }
971
972 if (fw_dir) {
973 rom->fw_dir = g_strdup(fw_dir);
974 rom->fw_file = g_strdup(file);
975 }
976 rom->addr = addr;
977 rom->romsize = lseek(fd, 0, SEEK_END);
978 if (rom->romsize == -1) {
979 fprintf(stderr, "rom: file %-20s: get size error: %s\n",
980 rom->name, strerror(errno));
981 goto err;
982 }
983
984 rom->datasize = rom->romsize;
985 rom->data = g_malloc0(rom->datasize);
986 lseek(fd, 0, SEEK_SET);
987 rc = read(fd, rom->data, rom->datasize);
988 if (rc != rom->datasize) {
989 fprintf(stderr, "rom: file %-20s: read error: rc=%d (expected %zd)\n",
990 rom->name, rc, rom->datasize);
991 goto err;
992 }
993 close(fd);
994 rom_insert(rom);
995 if (rom->fw_file && fw_cfg) {
996 const char *basename;
997 char fw_file_name[FW_CFG_MAX_FILE_PATH];
998 void *data;
999
1000 basename = strrchr(rom->fw_file, '/');
1001 if (basename) {
1002 basename++;
1003 } else {
1004 basename = rom->fw_file;
1005 }
1006 snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir,
1007 basename);
1008 snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
1009
1010 if ((!option_rom || mc->option_rom_has_mr) && mc->rom_file_has_mr) {
1011 data = rom_set_mr(rom, OBJECT(fw_cfg), devpath, true);
1012 } else {
1013 data = rom->data;
1014 }
1015
1016 fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize);
1017 } else {
1018 if (mr) {
1019 rom->mr = mr;
1020 snprintf(devpath, sizeof(devpath), "/rom@%s", file);
1021 } else {
1022 snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr);
1023 }
1024 }
1025
1026 add_boot_device_path(bootindex, NULL, devpath);
1027 return 0;
1028
1029 err:
1030 if (fd != -1)
1031 close(fd);
1032
1033 rom_free(rom);
1034 return -1;
1035 }
1036
1037 MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len,
1038 size_t max_len, hwaddr addr, const char *fw_file_name,
1039 FWCfgCallback fw_callback, void *callback_opaque,
1040 AddressSpace *as, bool read_only)
1041 {
1042 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
1043 Rom *rom;
1044 MemoryRegion *mr = NULL;
1045
1046 rom = g_malloc0(sizeof(*rom));
1047 rom->name = g_strdup(name);
1048 rom->as = as;
1049 rom->addr = addr;
1050 rom->romsize = max_len ? max_len : len;
1051 rom->datasize = len;
1052 g_assert(rom->romsize >= rom->datasize);
1053 rom->data = g_malloc0(rom->datasize);
1054 memcpy(rom->data, blob, len);
1055 rom_insert(rom);
1056 if (fw_file_name && fw_cfg) {
1057 char devpath[100];
1058 void *data;
1059
1060 if (read_only) {
1061 snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
1062 } else {
1063 snprintf(devpath, sizeof(devpath), "/ram@%s", fw_file_name);
1064 }
1065
1066 if (mc->rom_file_has_mr) {
1067 data = rom_set_mr(rom, OBJECT(fw_cfg), devpath, read_only);
1068 mr = rom->mr;
1069 } else {
1070 data = rom->data;
1071 }
1072
1073 fw_cfg_add_file_callback(fw_cfg, fw_file_name,
1074 fw_callback, NULL, callback_opaque,
1075 data, rom->datasize, read_only);
1076 }
1077 return mr;
1078 }
1079
1080 /* This function is specific for elf program because we don't need to allocate
1081 * all the rom. We just allocate the first part and the rest is just zeros. This
1082 * is why romsize and datasize are different. Also, this function takes its own
1083 * reference to "mapped_file", so we don't have to allocate and copy the buffer.
1084 */
1085 int rom_add_elf_program(const char *name, GMappedFile *mapped_file, void *data,
1086 size_t datasize, size_t romsize, hwaddr addr,
1087 AddressSpace *as)
1088 {
1089 Rom *rom;
1090
1091 rom = g_malloc0(sizeof(*rom));
1092 rom->name = g_strdup(name);
1093 rom->addr = addr;
1094 rom->datasize = datasize;
1095 rom->romsize = romsize;
1096 rom->data = data;
1097 rom->as = as;
1098
1099 if (mapped_file && data) {
1100 g_mapped_file_ref(mapped_file);
1101 rom->mapped_file = mapped_file;
1102 }
1103
1104 rom_insert(rom);
1105 return 0;
1106 }
1107
1108 int rom_add_vga(const char *file)
1109 {
1110 return rom_add_file(file, "vgaroms", 0, -1, true, NULL, NULL);
1111 }
1112
1113 int rom_add_option(const char *file, int32_t bootindex)
1114 {
1115 return rom_add_file(file, "genroms", 0, bootindex, true, NULL, NULL);
1116 }
1117
1118 static void rom_reset(void *unused)
1119 {
1120 Rom *rom;
1121
1122 QTAILQ_FOREACH(rom, &roms, next) {
1123 if (rom->fw_file) {
1124 continue;
1125 }
1126 /*
1127 * We don't need to fill in the RAM with ROM data because we'll fill
1128 * the data in during the next incoming migration in all cases. Note
1129 * that some of those RAMs can actually be modified by the guest.
1130 */
1131 if (runstate_check(RUN_STATE_INMIGRATE)) {
1132 if (rom->data && rom->isrom) {
1133 /*
1134 * Free it so that a rom_reset after migration doesn't
1135 * overwrite a potentially modified 'rom'.
1136 */
1137 rom_free_data(rom);
1138 }
1139 continue;
1140 }
1141
1142 if (rom->data == NULL) {
1143 continue;
1144 }
1145 if (rom->mr) {
1146 void *host = memory_region_get_ram_ptr(rom->mr);
1147 memcpy(host, rom->data, rom->datasize);
1148 } else {
1149 address_space_write_rom(rom->as, rom->addr, MEMTXATTRS_UNSPECIFIED,
1150 rom->data, rom->datasize);
1151 }
1152 if (rom->isrom) {
1153 /* rom needs to be written only once */
1154 rom_free_data(rom);
1155 }
1156 /*
1157 * The rom loader is really on the same level as firmware in the guest
1158 * shadowing a ROM into RAM. Such a shadowing mechanism needs to ensure
1159 * that the instruction cache for that new region is clear, so that the
1160 * CPU definitely fetches its instructions from the just written data.
1161 */
1162 cpu_flush_icache_range(rom->addr, rom->datasize);
1163
1164 trace_loader_write_rom(rom->name, rom->addr, rom->datasize, rom->isrom);
1165 }
1166 }
1167
1168 int rom_check_and_register_reset(void)
1169 {
1170 hwaddr addr = 0;
1171 MemoryRegionSection section;
1172 Rom *rom;
1173 AddressSpace *as = NULL;
1174
1175 QTAILQ_FOREACH(rom, &roms, next) {
1176 if (rom->fw_file) {
1177 continue;
1178 }
1179 if (!rom->mr) {
1180 if ((addr > rom->addr) && (as == rom->as)) {
1181 fprintf(stderr, "rom: requested regions overlap "
1182 "(rom %s. free=0x" TARGET_FMT_plx
1183 ", addr=0x" TARGET_FMT_plx ")\n",
1184 rom->name, addr, rom->addr);
1185 return -1;
1186 }
1187 addr = rom->addr;
1188 addr += rom->romsize;
1189 as = rom->as;
1190 }
1191 section = memory_region_find(rom->mr ? rom->mr : get_system_memory(),
1192 rom->addr, 1);
1193 rom->isrom = int128_nz(section.size) && memory_region_is_rom(section.mr);
1194 memory_region_unref(section.mr);
1195 }
1196 qemu_register_reset(rom_reset, NULL);
1197 roms_loaded = 1;
1198 return 0;
1199 }
1200
1201 void rom_set_fw(FWCfgState *f)
1202 {
1203 fw_cfg = f;
1204 }
1205
1206 void rom_set_order_override(int order)
1207 {
1208 if (!fw_cfg)
1209 return;
1210 fw_cfg_set_order_override(fw_cfg, order);
1211 }
1212
1213 void rom_reset_order_override(void)
1214 {
1215 if (!fw_cfg)
1216 return;
1217 fw_cfg_reset_order_override(fw_cfg);
1218 }
1219
1220 void rom_transaction_begin(void)
1221 {
1222 Rom *rom;
1223
1224 /* Ignore ROMs added without the transaction API */
1225 QTAILQ_FOREACH(rom, &roms, next) {
1226 rom->committed = true;
1227 }
1228 }
1229
1230 void rom_transaction_end(bool commit)
1231 {
1232 Rom *rom;
1233 Rom *tmp;
1234
1235 QTAILQ_FOREACH_SAFE(rom, &roms, next, tmp) {
1236 if (rom->committed) {
1237 continue;
1238 }
1239 if (commit) {
1240 rom->committed = true;
1241 } else {
1242 QTAILQ_REMOVE(&roms, rom, next);
1243 rom_free(rom);
1244 }
1245 }
1246 }
1247
1248 static Rom *find_rom(hwaddr addr, size_t size)
1249 {
1250 Rom *rom;
1251
1252 QTAILQ_FOREACH(rom, &roms, next) {
1253 if (rom->fw_file) {
1254 continue;
1255 }
1256 if (rom->mr) {
1257 continue;
1258 }
1259 if (rom->addr > addr) {
1260 continue;
1261 }
1262 if (rom->addr + rom->romsize < addr + size) {
1263 continue;
1264 }
1265 return rom;
1266 }
1267 return NULL;
1268 }
1269
1270 /*
1271 * Copies memory from registered ROMs to dest. Any memory that is contained in
1272 * a ROM between addr and addr + size is copied. Note that this can involve
1273 * multiple ROMs, which need not start at addr and need not end at addr + size.
1274 */
1275 int rom_copy(uint8_t *dest, hwaddr addr, size_t size)
1276 {
1277 hwaddr end = addr + size;
1278 uint8_t *s, *d = dest;
1279 size_t l = 0;
1280 Rom *rom;
1281
1282 QTAILQ_FOREACH(rom, &roms, next) {
1283 if (rom->fw_file) {
1284 continue;
1285 }
1286 if (rom->mr) {
1287 continue;
1288 }
1289 if (rom->addr + rom->romsize < addr) {
1290 continue;
1291 }
1292 if (rom->addr > end || rom->addr < addr) {
1293 break;
1294 }
1295
1296 d = dest + (rom->addr - addr);
1297 s = rom->data;
1298 l = rom->datasize;
1299
1300 if ((d + l) > (dest + size)) {
1301 l = dest - d;
1302 }
1303
1304 if (l > 0) {
1305 memcpy(d, s, l);
1306 }
1307
1308 if (rom->romsize > rom->datasize) {
1309 /* If datasize is less than romsize, it means that we didn't
1310 * allocate all the ROM because the trailing data are only zeros.
1311 */
1312
1313 d += l;
1314 l = rom->romsize - rom->datasize;
1315
1316 if ((d + l) > (dest + size)) {
1317 /* Rom size doesn't fit in the destination area. Adjust to avoid
1318 * overflow.
1319 */
1320 l = dest - d;
1321 }
1322
1323 if (l > 0) {
1324 memset(d, 0x0, l);
1325 }
1326 }
1327 }
1328
1329 return (d + l) - dest;
1330 }
1331
1332 void *rom_ptr(hwaddr addr, size_t size)
1333 {
1334 Rom *rom;
1335
1336 rom = find_rom(addr, size);
1337 if (!rom || !rom->data)
1338 return NULL;
1339 return rom->data + (addr - rom->addr);
1340 }
1341
1342 void hmp_info_roms(Monitor *mon, const QDict *qdict)
1343 {
1344 Rom *rom;
1345
1346 QTAILQ_FOREACH(rom, &roms, next) {
1347 if (rom->mr) {
1348 monitor_printf(mon, "%s"
1349 " size=0x%06zx name=\"%s\"\n",
1350 memory_region_name(rom->mr),
1351 rom->romsize,
1352 rom->name);
1353 } else if (!rom->fw_file) {
1354 monitor_printf(mon, "addr=" TARGET_FMT_plx
1355 " size=0x%06zx mem=%s name=\"%s\"\n",
1356 rom->addr, rom->romsize,
1357 rom->isrom ? "rom" : "ram",
1358 rom->name);
1359 } else {
1360 monitor_printf(mon, "fw=%s/%s"
1361 " size=0x%06zx name=\"%s\"\n",
1362 rom->fw_dir,
1363 rom->fw_file,
1364 rom->romsize,
1365 rom->name);
1366 }
1367 }
1368 }
1369
1370 typedef enum HexRecord HexRecord;
1371 enum HexRecord {
1372 DATA_RECORD = 0,
1373 EOF_RECORD,
1374 EXT_SEG_ADDR_RECORD,
1375 START_SEG_ADDR_RECORD,
1376 EXT_LINEAR_ADDR_RECORD,
1377 START_LINEAR_ADDR_RECORD,
1378 };
1379
1380 /* Each record contains a 16-bit address which is combined with the upper 16
1381 * bits of the implicit "next address" to form a 32-bit address.
1382 */
1383 #define NEXT_ADDR_MASK 0xffff0000
1384
1385 #define DATA_FIELD_MAX_LEN 0xff
1386 #define LEN_EXCEPT_DATA 0x5
1387 /* 0x5 = sizeof(byte_count) + sizeof(address) + sizeof(record_type) +
1388 * sizeof(checksum) */
1389 typedef struct {
1390 uint8_t byte_count;
1391 uint16_t address;
1392 uint8_t record_type;
1393 uint8_t data[DATA_FIELD_MAX_LEN];
1394 uint8_t checksum;
1395 } HexLine;
1396
1397 /* return 0 or -1 if error */
1398 static bool parse_record(HexLine *line, uint8_t *our_checksum, const uint8_t c,
1399 uint32_t *index, const bool in_process)
1400 {
1401 /* +-------+---------------+-------+---------------------+--------+
1402 * | byte | |record | | |
1403 * | count | address | type | data |checksum|
1404 * +-------+---------------+-------+---------------------+--------+
1405 * ^ ^ ^ ^ ^ ^
1406 * |1 byte | 2 bytes |1 byte | 0-255 bytes | 1 byte |
1407 */
1408 uint8_t value = 0;
1409 uint32_t idx = *index;
1410 /* ignore space */
1411 if (g_ascii_isspace(c)) {
1412 return true;
1413 }
1414 if (!g_ascii_isxdigit(c) || !in_process) {
1415 return false;
1416 }
1417 value = g_ascii_xdigit_value(c);
1418 value = (idx & 0x1) ? (value & 0xf) : (value << 4);
1419 if (idx < 2) {
1420 line->byte_count |= value;
1421 } else if (2 <= idx && idx < 6) {
1422 line->address <<= 4;
1423 line->address += g_ascii_xdigit_value(c);
1424 } else if (6 <= idx && idx < 8) {
1425 line->record_type |= value;
1426 } else if (8 <= idx && idx < 8 + 2 * line->byte_count) {
1427 line->data[(idx - 8) >> 1] |= value;
1428 } else if (8 + 2 * line->byte_count <= idx &&
1429 idx < 10 + 2 * line->byte_count) {
1430 line->checksum |= value;
1431 } else {
1432 return false;
1433 }
1434 *our_checksum += value;
1435 ++(*index);
1436 return true;
1437 }
1438
1439 typedef struct {
1440 const char *filename;
1441 HexLine line;
1442 uint8_t *bin_buf;
1443 hwaddr *start_addr;
1444 int total_size;
1445 uint32_t next_address_to_write;
1446 uint32_t current_address;
1447 uint32_t current_rom_index;
1448 uint32_t rom_start_address;
1449 AddressSpace *as;
1450 bool complete;
1451 } HexParser;
1452
1453 /* return size or -1 if error */
1454 static int handle_record_type(HexParser *parser)
1455 {
1456 HexLine *line = &(parser->line);
1457 switch (line->record_type) {
1458 case DATA_RECORD:
1459 parser->current_address =
1460 (parser->next_address_to_write & NEXT_ADDR_MASK) | line->address;
1461 /* verify this is a contiguous block of memory */
1462 if (parser->current_address != parser->next_address_to_write) {
1463 if (parser->current_rom_index != 0) {
1464 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1465 parser->current_rom_index,
1466 parser->rom_start_address, parser->as);
1467 }
1468 parser->rom_start_address = parser->current_address;
1469 parser->current_rom_index = 0;
1470 }
1471
1472 /* copy from line buffer to output bin_buf */
1473 memcpy(parser->bin_buf + parser->current_rom_index, line->data,
1474 line->byte_count);
1475 parser->current_rom_index += line->byte_count;
1476 parser->total_size += line->byte_count;
1477 /* save next address to write */
1478 parser->next_address_to_write =
1479 parser->current_address + line->byte_count;
1480 break;
1481
1482 case EOF_RECORD:
1483 if (parser->current_rom_index != 0) {
1484 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1485 parser->current_rom_index,
1486 parser->rom_start_address, parser->as);
1487 }
1488 parser->complete = true;
1489 return parser->total_size;
1490 case EXT_SEG_ADDR_RECORD:
1491 case EXT_LINEAR_ADDR_RECORD:
1492 if (line->byte_count != 2 && line->address != 0) {
1493 return -1;
1494 }
1495
1496 if (parser->current_rom_index != 0) {
1497 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1498 parser->current_rom_index,
1499 parser->rom_start_address, parser->as);
1500 }
1501
1502 /* save next address to write,
1503 * in case of non-contiguous block of memory */
1504 parser->next_address_to_write = (line->data[0] << 12) |
1505 (line->data[1] << 4);
1506 if (line->record_type == EXT_LINEAR_ADDR_RECORD) {
1507 parser->next_address_to_write <<= 12;
1508 }
1509
1510 parser->rom_start_address = parser->next_address_to_write;
1511 parser->current_rom_index = 0;
1512 break;
1513
1514 case START_SEG_ADDR_RECORD:
1515 if (line->byte_count != 4 && line->address != 0) {
1516 return -1;
1517 }
1518
1519 /* x86 16-bit CS:IP segmented addressing */
1520 *(parser->start_addr) = (((line->data[0] << 8) | line->data[1]) << 4) +
1521 ((line->data[2] << 8) | line->data[3]);
1522 break;
1523
1524 case START_LINEAR_ADDR_RECORD:
1525 if (line->byte_count != 4 && line->address != 0) {
1526 return -1;
1527 }
1528
1529 *(parser->start_addr) = ldl_be_p(line->data);
1530 break;
1531
1532 default:
1533 return -1;
1534 }
1535
1536 return parser->total_size;
1537 }
1538
1539 /* return size or -1 if error */
1540 static int parse_hex_blob(const char *filename, hwaddr *addr, uint8_t *hex_blob,
1541 size_t hex_blob_size, AddressSpace *as)
1542 {
1543 bool in_process = false; /* avoid re-enter and
1544 * check whether record begin with ':' */
1545 uint8_t *end = hex_blob + hex_blob_size;
1546 uint8_t our_checksum = 0;
1547 uint32_t record_index = 0;
1548 HexParser parser = {
1549 .filename = filename,
1550 .bin_buf = g_malloc(hex_blob_size),
1551 .start_addr = addr,
1552 .as = as,
1553 .complete = false
1554 };
1555
1556 rom_transaction_begin();
1557
1558 for (; hex_blob < end && !parser.complete; ++hex_blob) {
1559 switch (*hex_blob) {
1560 case '\r':
1561 case '\n':
1562 if (!in_process) {
1563 break;
1564 }
1565
1566 in_process = false;
1567 if ((LEN_EXCEPT_DATA + parser.line.byte_count) * 2 !=
1568 record_index ||
1569 our_checksum != 0) {
1570 parser.total_size = -1;
1571 goto out;
1572 }
1573
1574 if (handle_record_type(&parser) == -1) {
1575 parser.total_size = -1;
1576 goto out;
1577 }
1578 break;
1579
1580 /* start of a new record. */
1581 case ':':
1582 memset(&parser.line, 0, sizeof(HexLine));
1583 in_process = true;
1584 record_index = 0;
1585 break;
1586
1587 /* decoding lines */
1588 default:
1589 if (!parse_record(&parser.line, &our_checksum, *hex_blob,
1590 &record_index, in_process)) {
1591 parser.total_size = -1;
1592 goto out;
1593 }
1594 break;
1595 }
1596 }
1597
1598 out:
1599 g_free(parser.bin_buf);
1600 rom_transaction_end(parser.total_size != -1);
1601 return parser.total_size;
1602 }
1603
1604 /* return size or -1 if error */
1605 int load_targphys_hex_as(const char *filename, hwaddr *entry, AddressSpace *as)
1606 {
1607 gsize hex_blob_size;
1608 gchar *hex_blob;
1609 int total_size = 0;
1610
1611 if (!g_file_get_contents(filename, &hex_blob, &hex_blob_size, NULL)) {
1612 return -1;
1613 }
1614
1615 total_size = parse_hex_blob(filename, entry, (uint8_t *)hex_blob,
1616 hex_blob_size, as);
1617
1618 g_free(hex_blob);
1619 return total_size;
1620 }