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