1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include "qemu/osdep.h"
46#include "qemu/datadir.h"
47#include "qemu/error-report.h"
48#include "qapi/error.h"
49#include "qapi/qapi-commands-machine.h"
50#include "qapi/type-helpers.h"
51#include "trace.h"
52#include "hw/hw.h"
53#include "disas/disas.h"
54#include "migration/vmstate.h"
55#include "monitor/monitor.h"
56#include "sysemu/reset.h"
57#include "sysemu/sysemu.h"
58#include "uboot_image.h"
59#include "hw/loader.h"
60#include "hw/nvram/fw_cfg.h"
61#include "exec/memory.h"
62#include "hw/boards.h"
63#include "qemu/cutils.h"
64#include "sysemu/runstate.h"
65#include "accel/tcg/debuginfo.h"
66
67#include <zlib.h>
68
69static int roms_loaded;
70
71
72int64_t get_image_size(const char *filename)
73{
74 int fd;
75 int64_t size;
76 fd = open(filename, O_RDONLY | O_BINARY);
77 if (fd < 0)
78 return -1;
79 size = lseek(fd, 0, SEEK_END);
80 close(fd);
81 return size;
82}
83
84
85ssize_t load_image_size(const char *filename, void *addr, size_t size)
86{
87 int fd;
88 ssize_t actsize, l = 0;
89
90 fd = open(filename, O_RDONLY | O_BINARY);
91 if (fd < 0) {
92 return -1;
93 }
94
95 while ((actsize = read(fd, addr + l, size - l)) > 0) {
96 l += actsize;
97 }
98
99 close(fd);
100
101 return actsize < 0 ? -1 : l;
102}
103
104
105ssize_t read_targphys(const char *name,
106 int fd, hwaddr dst_addr, size_t nbytes)
107{
108 uint8_t *buf;
109 ssize_t did;
110
111 buf = g_malloc(nbytes);
112 did = read(fd, buf, nbytes);
113 if (did > 0)
114 rom_add_blob_fixed("read", buf, did, dst_addr);
115 g_free(buf);
116 return did;
117}
118
119ssize_t load_image_targphys(const char *filename,
120 hwaddr addr, uint64_t max_sz)
121{
122 return load_image_targphys_as(filename, addr, max_sz, NULL);
123}
124
125
126ssize_t load_image_targphys_as(const char *filename,
127 hwaddr addr, uint64_t max_sz, AddressSpace *as)
128{
129 ssize_t size;
130
131 size = get_image_size(filename);
132 if (size < 0 || size > max_sz) {
133 return -1;
134 }
135 if (size > 0) {
136 if (rom_add_file_fixed_as(filename, addr, -1, as) < 0) {
137 return -1;
138 }
139 }
140 return size;
141}
142
143ssize_t load_image_mr(const char *filename, MemoryRegion *mr)
144{
145 ssize_t size;
146
147 if (!memory_access_is_direct(mr, false)) {
148
149 return -1;
150 }
151
152 size = get_image_size(filename);
153
154 if (size < 0 || size > memory_region_size(mr)) {
155 return -1;
156 }
157 if (size > 0) {
158 if (rom_add_file_mr(filename, mr, -1) < 0) {
159 return -1;
160 }
161 }
162 return size;
163}
164
165void pstrcpy_targphys(const char *name, hwaddr dest, int buf_size,
166 const char *source)
167{
168 const char *nulp;
169 char *ptr;
170
171 if (buf_size <= 0) return;
172 nulp = memchr(source, 0, buf_size);
173 if (nulp) {
174 rom_add_blob_fixed(name, source, (nulp - source) + 1, dest);
175 } else {
176 rom_add_blob_fixed(name, source, buf_size, dest);
177 ptr = rom_ptr(dest + buf_size - 1, sizeof(*ptr));
178 *ptr = 0;
179 }
180}
181
182
183
184struct exec
185{
186 uint32_t a_info;
187 uint32_t a_text;
188 uint32_t a_data;
189 uint32_t a_bss;
190 uint32_t a_syms;
191 uint32_t a_entry;
192 uint32_t a_trsize;
193 uint32_t a_drsize;
194};
195
196static void bswap_ahdr(struct exec *e)
197{
198 bswap32s(&e->a_info);
199 bswap32s(&e->a_text);
200 bswap32s(&e->a_data);
201 bswap32s(&e->a_bss);
202 bswap32s(&e->a_syms);
203 bswap32s(&e->a_entry);
204 bswap32s(&e->a_trsize);
205 bswap32s(&e->a_drsize);
206}
207
208#define N_MAGIC(exec) ((exec).a_info & 0xffff)
209#define OMAGIC 0407
210#define NMAGIC 0410
211#define ZMAGIC 0413
212#define QMAGIC 0314
213#define _N_HDROFF(x) (1024 - sizeof (struct exec))
214#define N_TXTOFF(x) \
215 (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \
216 (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
217#define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0)
218#define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1))
219
220#define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text)
221
222#define N_DATADDR(x, target_page_size) \
223 (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \
224 : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size)))
225
226
227ssize_t load_aout(const char *filename, hwaddr addr, int max_sz,
228 int bswap_needed, hwaddr target_page_size)
229{
230 int fd;
231 ssize_t size, ret;
232 struct exec e;
233 uint32_t magic;
234
235 fd = open(filename, O_RDONLY | O_BINARY);
236 if (fd < 0)
237 return -1;
238
239 size = read(fd, &e, sizeof(e));
240 if (size < 0)
241 goto fail;
242
243 if (bswap_needed) {
244 bswap_ahdr(&e);
245 }
246
247 magic = N_MAGIC(e);
248 switch (magic) {
249 case ZMAGIC:
250 case QMAGIC:
251 case OMAGIC:
252 if (e.a_text + e.a_data > max_sz)
253 goto fail;
254 lseek(fd, N_TXTOFF(e), SEEK_SET);
255 size = read_targphys(filename, fd, addr, e.a_text + e.a_data);
256 if (size < 0)
257 goto fail;
258 break;
259 case NMAGIC:
260 if (N_DATADDR(e, target_page_size) + e.a_data > max_sz)
261 goto fail;
262 lseek(fd, N_TXTOFF(e), SEEK_SET);
263 size = read_targphys(filename, fd, addr, e.a_text);
264 if (size < 0)
265 goto fail;
266 ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size),
267 e.a_data);
268 if (ret < 0)
269 goto fail;
270 size += ret;
271 break;
272 default:
273 goto fail;
274 }
275 close(fd);
276 return size;
277 fail:
278 close(fd);
279 return -1;
280}
281
282
283
284static void *load_at(int fd, off_t offset, size_t size)
285{
286 void *ptr;
287 if (lseek(fd, offset, SEEK_SET) < 0)
288 return NULL;
289 ptr = g_malloc(size);
290 if (read(fd, ptr, size) != size) {
291 g_free(ptr);
292 return NULL;
293 }
294 return ptr;
295}
296
297#ifdef ELF_CLASS
298#undef ELF_CLASS
299#endif
300
301#define ELF_CLASS ELFCLASS32
302#include "elf.h"
303
304#define SZ 32
305#define elf_word uint32_t
306#define elf_sword int32_t
307#define bswapSZs bswap32s
308#include "hw/elf_ops.h"
309
310#undef elfhdr
311#undef elf_phdr
312#undef elf_shdr
313#undef elf_sym
314#undef elf_rela
315#undef elf_note
316#undef elf_word
317#undef elf_sword
318#undef bswapSZs
319#undef SZ
320#define elfhdr elf64_hdr
321#define elf_phdr elf64_phdr
322#define elf_note elf64_note
323#define elf_shdr elf64_shdr
324#define elf_sym elf64_sym
325#define elf_rela elf64_rela
326#define elf_word uint64_t
327#define elf_sword int64_t
328#define bswapSZs bswap64s
329#define SZ 64
330#include "hw/elf_ops.h"
331
332const char *load_elf_strerror(ssize_t error)
333{
334 switch (error) {
335 case 0:
336 return "No error";
337 case ELF_LOAD_FAILED:
338 return "Failed to load ELF";
339 case ELF_LOAD_NOT_ELF:
340 return "The image is not ELF";
341 case ELF_LOAD_WRONG_ARCH:
342 return "The image is from incompatible architecture";
343 case ELF_LOAD_WRONG_ENDIAN:
344 return "The image has incorrect endianness";
345 case ELF_LOAD_TOO_BIG:
346 return "The image segments are too big to load";
347 default:
348 return "Unknown error";
349 }
350}
351
352void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp)
353{
354 int fd;
355 uint8_t e_ident_local[EI_NIDENT];
356 uint8_t *e_ident;
357 size_t hdr_size, off;
358 bool is64l;
359
360 if (!hdr) {
361 hdr = e_ident_local;
362 }
363 e_ident = hdr;
364
365 fd = open(filename, O_RDONLY | O_BINARY);
366 if (fd < 0) {
367 error_setg_errno(errp, errno, "Failed to open file: %s", filename);
368 return;
369 }
370 if (read(fd, hdr, EI_NIDENT) != EI_NIDENT) {
371 error_setg_errno(errp, errno, "Failed to read file: %s", filename);
372 goto fail;
373 }
374 if (e_ident[0] != ELFMAG0 ||
375 e_ident[1] != ELFMAG1 ||
376 e_ident[2] != ELFMAG2 ||
377 e_ident[3] != ELFMAG3) {
378 error_setg(errp, "Bad ELF magic");
379 goto fail;
380 }
381
382 is64l = e_ident[EI_CLASS] == ELFCLASS64;
383 hdr_size = is64l ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr);
384 if (is64) {
385 *is64 = is64l;
386 }
387
388 off = EI_NIDENT;
389 while (hdr != e_ident_local && off < hdr_size) {
390 size_t br = read(fd, hdr + off, hdr_size - off);
391 switch (br) {
392 case 0:
393 error_setg(errp, "File too short: %s", filename);
394 goto fail;
395 case -1:
396 error_setg_errno(errp, errno, "Failed to read file: %s",
397 filename);
398 goto fail;
399 }
400 off += br;
401 }
402
403fail:
404 close(fd);
405}
406
407
408ssize_t load_elf(const char *filename,
409 uint64_t (*elf_note_fn)(void *, void *, bool),
410 uint64_t (*translate_fn)(void *, uint64_t),
411 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
412 uint64_t *highaddr, uint32_t *pflags, int big_endian,
413 int elf_machine, int clear_lsb, int data_swab)
414{
415 return load_elf_as(filename, elf_note_fn, translate_fn, translate_opaque,
416 pentry, lowaddr, highaddr, pflags, big_endian,
417 elf_machine, clear_lsb, data_swab, NULL);
418}
419
420
421ssize_t load_elf_as(const char *filename,
422 uint64_t (*elf_note_fn)(void *, void *, bool),
423 uint64_t (*translate_fn)(void *, uint64_t),
424 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
425 uint64_t *highaddr, uint32_t *pflags, int big_endian,
426 int elf_machine, int clear_lsb, int data_swab,
427 AddressSpace *as)
428{
429 return load_elf_ram(filename, elf_note_fn, translate_fn, translate_opaque,
430 pentry, lowaddr, highaddr, pflags, big_endian,
431 elf_machine, clear_lsb, data_swab, as, true);
432}
433
434
435ssize_t load_elf_ram(const char *filename,
436 uint64_t (*elf_note_fn)(void *, void *, bool),
437 uint64_t (*translate_fn)(void *, uint64_t),
438 void *translate_opaque, uint64_t *pentry,
439 uint64_t *lowaddr, uint64_t *highaddr, uint32_t *pflags,
440 int big_endian, int elf_machine, int clear_lsb,
441 int data_swab, AddressSpace *as, bool load_rom)
442{
443 return load_elf_ram_sym(filename, elf_note_fn,
444 translate_fn, translate_opaque,
445 pentry, lowaddr, highaddr, pflags, big_endian,
446 elf_machine, clear_lsb, data_swab, as,
447 load_rom, NULL);
448}
449
450
451ssize_t load_elf_ram_sym(const char *filename,
452 uint64_t (*elf_note_fn)(void *, void *, bool),
453 uint64_t (*translate_fn)(void *, uint64_t),
454 void *translate_opaque, uint64_t *pentry,
455 uint64_t *lowaddr, uint64_t *highaddr,
456 uint32_t *pflags, int big_endian, int elf_machine,
457 int clear_lsb, int data_swab,
458 AddressSpace *as, bool load_rom, symbol_fn_t sym_cb)
459{
460 int fd, data_order, target_data_order, must_swab;
461 ssize_t ret = ELF_LOAD_FAILED;
462 uint8_t e_ident[EI_NIDENT];
463
464 fd = open(filename, O_RDONLY | O_BINARY);
465 if (fd < 0) {
466 perror(filename);
467 return -1;
468 }
469 if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
470 goto fail;
471 if (e_ident[0] != ELFMAG0 ||
472 e_ident[1] != ELFMAG1 ||
473 e_ident[2] != ELFMAG2 ||
474 e_ident[3] != ELFMAG3) {
475 ret = ELF_LOAD_NOT_ELF;
476 goto fail;
477 }
478#if HOST_BIG_ENDIAN
479 data_order = ELFDATA2MSB;
480#else
481 data_order = ELFDATA2LSB;
482#endif
483 must_swab = data_order != e_ident[EI_DATA];
484 if (big_endian) {
485 target_data_order = ELFDATA2MSB;
486 } else {
487 target_data_order = ELFDATA2LSB;
488 }
489
490 if (target_data_order != e_ident[EI_DATA]) {
491 ret = ELF_LOAD_WRONG_ENDIAN;
492 goto fail;
493 }
494
495 lseek(fd, 0, SEEK_SET);
496 if (e_ident[EI_CLASS] == ELFCLASS64) {
497 ret = load_elf64(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 } else {
502 ret = load_elf32(filename, fd, elf_note_fn,
503 translate_fn, translate_opaque, must_swab,
504 pentry, lowaddr, highaddr, pflags, elf_machine,
505 clear_lsb, data_swab, as, load_rom, sym_cb);
506 }
507
508 if (ret != ELF_LOAD_FAILED) {
509 debuginfo_report_elf(filename, fd, 0);
510 }
511
512 fail:
513 close(fd);
514 return ret;
515}
516
517static void bswap_uboot_header(uboot_image_header_t *hdr)
518{
519#if !HOST_BIG_ENDIAN
520 bswap32s(&hdr->ih_magic);
521 bswap32s(&hdr->ih_hcrc);
522 bswap32s(&hdr->ih_time);
523 bswap32s(&hdr->ih_size);
524 bswap32s(&hdr->ih_load);
525 bswap32s(&hdr->ih_ep);
526 bswap32s(&hdr->ih_dcrc);
527#endif
528}
529
530
531#define ZALLOC_ALIGNMENT 16
532
533static void *zalloc(void *x, unsigned items, unsigned size)
534{
535 void *p;
536
537 size *= items;
538 size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
539
540 p = g_malloc(size);
541
542 return (p);
543}
544
545static void zfree(void *x, void *addr)
546{
547 g_free(addr);
548}
549
550
551#define HEAD_CRC 2
552#define EXTRA_FIELD 4
553#define ORIG_NAME 8
554#define COMMENT 0x10
555#define RESERVED 0xe0
556
557#define DEFLATED 8
558
559ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, size_t srclen)
560{
561 z_stream s;
562 ssize_t dstbytes;
563 int r, i, flags;
564
565
566 i = 10;
567 if (srclen < 4) {
568 goto toosmall;
569 }
570 flags = src[3];
571 if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
572 puts ("Error: Bad gzipped data\n");
573 return -1;
574 }
575 if ((flags & EXTRA_FIELD) != 0) {
576 if (srclen < 12) {
577 goto toosmall;
578 }
579 i = 12 + src[10] + (src[11] << 8);
580 }
581 if ((flags & ORIG_NAME) != 0) {
582 while (i < srclen && src[i++] != 0) {
583
584 }
585 }
586 if ((flags & COMMENT) != 0) {
587 while (i < srclen && src[i++] != 0) {
588
589 }
590 }
591 if ((flags & HEAD_CRC) != 0) {
592 i += 2;
593 }
594 if (i >= srclen) {
595 goto toosmall;
596 }
597
598 s.zalloc = zalloc;
599 s.zfree = zfree;
600
601 r = inflateInit2(&s, -MAX_WBITS);
602 if (r != Z_OK) {
603 printf ("Error: inflateInit2() returned %d\n", r);
604 return (-1);
605 }
606 s.next_in = src + i;
607 s.avail_in = srclen - i;
608 s.next_out = dst;
609 s.avail_out = dstlen;
610 r = inflate(&s, Z_FINISH);
611 if (r != Z_OK && r != Z_STREAM_END) {
612 printf ("Error: inflate() returned %d\n", r);
613 return -1;
614 }
615 dstbytes = s.next_out - (unsigned char *) dst;
616 inflateEnd(&s);
617
618 return dstbytes;
619
620toosmall:
621 puts("Error: gunzip out of data in header\n");
622 return -1;
623}
624
625
626static ssize_t load_uboot_image(const char *filename, hwaddr *ep,
627 hwaddr *loadaddr, int *is_linux,
628 uint8_t image_type,
629 uint64_t (*translate_fn)(void *, uint64_t),
630 void *translate_opaque, AddressSpace *as)
631{
632 int fd;
633 ssize_t size;
634 hwaddr address;
635 uboot_image_header_t h;
636 uboot_image_header_t *hdr = &h;
637 uint8_t *data = NULL;
638 int ret = -1;
639 int do_uncompress = 0;
640
641 fd = open(filename, O_RDONLY | O_BINARY);
642 if (fd < 0)
643 return -1;
644
645 size = read(fd, hdr, sizeof(uboot_image_header_t));
646 if (size < sizeof(uboot_image_header_t)) {
647 goto out;
648 }
649
650 bswap_uboot_header(hdr);
651
652 if (hdr->ih_magic != IH_MAGIC)
653 goto out;
654
655 if (hdr->ih_type != image_type) {
656 if (!(image_type == IH_TYPE_KERNEL &&
657 hdr->ih_type == IH_TYPE_KERNEL_NOLOAD)) {
658 fprintf(stderr, "Wrong image type %d, expected %d\n", hdr->ih_type,
659 image_type);
660 goto out;
661 }
662 }
663
664
665 switch (hdr->ih_type) {
666 case IH_TYPE_KERNEL_NOLOAD:
667 if (!loadaddr || *loadaddr == LOAD_UIMAGE_LOADADDR_INVALID) {
668 fprintf(stderr, "this image format (kernel_noload) cannot be "
669 "loaded on this machine type");
670 goto out;
671 }
672
673 hdr->ih_load = *loadaddr + sizeof(*hdr);
674 hdr->ih_ep += hdr->ih_load;
675
676 case IH_TYPE_KERNEL:
677 address = hdr->ih_load;
678 if (translate_fn) {
679 address = translate_fn(translate_opaque, address);
680 }
681 if (loadaddr) {
682 *loadaddr = hdr->ih_load;
683 }
684
685 switch (hdr->ih_comp) {
686 case IH_COMP_NONE:
687 break;
688 case IH_COMP_GZIP:
689 do_uncompress = 1;
690 break;
691 default:
692 fprintf(stderr,
693 "Unable to load u-boot images with compression type %d\n",
694 hdr->ih_comp);
695 goto out;
696 }
697
698 if (ep) {
699 *ep = hdr->ih_ep;
700 }
701
702
703 if (is_linux) {
704 if (hdr->ih_os == IH_OS_LINUX) {
705 *is_linux = 1;
706 } else if (hdr->ih_os == IH_OS_VXWORKS) {
707
708
709
710
711 switch (hdr->ih_arch) {
712 case IH_ARCH_ARM64:
713 case IH_ARCH_PPC:
714 case IH_ARCH_RISCV:
715 *is_linux = 1;
716 break;
717 default:
718 *is_linux = 0;
719 break;
720 }
721 } else {
722 *is_linux = 0;
723 }
724 }
725
726 break;
727 case IH_TYPE_RAMDISK:
728 address = *loadaddr;
729 break;
730 default:
731 fprintf(stderr, "Unsupported u-boot image type %d\n", hdr->ih_type);
732 goto out;
733 }
734
735 data = g_malloc(hdr->ih_size);
736
737 if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
738 fprintf(stderr, "Error reading file\n");
739 goto out;
740 }
741
742 if (do_uncompress) {
743 uint8_t *compressed_data;
744 size_t max_bytes;
745 ssize_t bytes;
746
747 compressed_data = data;
748 max_bytes = UBOOT_MAX_GUNZIP_BYTES;
749 data = g_malloc(max_bytes);
750
751 bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
752 g_free(compressed_data);
753 if (bytes < 0) {
754 fprintf(stderr, "Unable to decompress gzipped image!\n");
755 goto out;
756 }
757 hdr->ih_size = bytes;
758 }
759
760 rom_add_blob_fixed_as(filename, data, hdr->ih_size, address, as);
761
762 ret = hdr->ih_size;
763
764out:
765 g_free(data);
766 close(fd);
767 return ret;
768}
769
770ssize_t load_uimage(const char *filename, hwaddr *ep, hwaddr *loadaddr,
771 int *is_linux,
772 uint64_t (*translate_fn)(void *, uint64_t),
773 void *translate_opaque)
774{
775 return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
776 translate_fn, translate_opaque, NULL);
777}
778
779ssize_t load_uimage_as(const char *filename, hwaddr *ep, hwaddr *loadaddr,
780 int *is_linux,
781 uint64_t (*translate_fn)(void *, uint64_t),
782 void *translate_opaque, AddressSpace *as)
783{
784 return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
785 translate_fn, translate_opaque, as);
786}
787
788
789ssize_t load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz)
790{
791 return load_ramdisk_as(filename, addr, max_sz, NULL);
792}
793
794ssize_t load_ramdisk_as(const char *filename, hwaddr addr, uint64_t max_sz,
795 AddressSpace *as)
796{
797 return load_uboot_image(filename, NULL, &addr, NULL, IH_TYPE_RAMDISK,
798 NULL, NULL, as);
799}
800
801
802ssize_t load_image_gzipped_buffer(const char *filename, uint64_t max_sz,
803 uint8_t **buffer)
804{
805 uint8_t *compressed_data = NULL;
806 uint8_t *data = NULL;
807 gsize len;
808 ssize_t bytes;
809 int ret = -1;
810
811 if (!g_file_get_contents(filename, (char **) &compressed_data, &len,
812 NULL)) {
813 goto out;
814 }
815
816
817 if (len < 2 ||
818 compressed_data[0] != 0x1f ||
819 compressed_data[1] != 0x8b) {
820 goto out;
821 }
822
823 if (max_sz > LOAD_IMAGE_MAX_GUNZIP_BYTES) {
824 max_sz = LOAD_IMAGE_MAX_GUNZIP_BYTES;
825 }
826
827 data = g_malloc(max_sz);
828 bytes = gunzip(data, max_sz, compressed_data, len);
829 if (bytes < 0) {
830 fprintf(stderr, "%s: unable to decompress gzipped kernel file\n",
831 filename);
832 goto out;
833 }
834
835
836 *buffer = g_realloc(data, bytes);
837 ret = bytes;
838
839 data = NULL;
840
841 out:
842 g_free(compressed_data);
843 g_free(data);
844 return ret;
845}
846
847
848ssize_t load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz)
849{
850 ssize_t bytes;
851 uint8_t *data;
852
853 bytes = load_image_gzipped_buffer(filename, max_sz, &data);
854 if (bytes != -1) {
855 rom_add_blob_fixed(filename, data, bytes, addr);
856 g_free(data);
857 }
858 return bytes;
859}
860
861
862#define EFI_PE_MSDOS_MAGIC "MZ"
863
864
865
866
867
868#define EFI_PE_LINUX_MAGIC "\xcd\x23\x82\x81"
869
870
871
872
873
874
875
876
877
878
879
880
881struct linux_efi_zboot_header {
882 uint8_t msdos_magic[2];
883 uint8_t reserved0[2];
884 uint8_t zimg[4];
885 uint32_t payload_offset;
886 uint32_t payload_size;
887 uint8_t reserved1[8];
888 char compression_type[32];
889 uint8_t linux_magic[4];
890 uint32_t pe_header_offset;
891};
892
893
894
895
896
897
898
899
900
901ssize_t unpack_efi_zboot_image(uint8_t **buffer, int *size)
902{
903 const struct linux_efi_zboot_header *header;
904 uint8_t *data = NULL;
905 int ploff, plsize;
906 ssize_t bytes;
907
908
909 if (*size < sizeof(*header)) {
910 return 0;
911 }
912
913 header = (struct linux_efi_zboot_header *)*buffer;
914
915
916 if (memcmp(&header->msdos_magic, EFI_PE_MSDOS_MAGIC, 2) != 0 ||
917 memcmp(&header->zimg, "zimg", 4) != 0 ||
918 memcmp(&header->linux_magic, EFI_PE_LINUX_MAGIC, 4) != 0) {
919 return 0;
920 }
921
922 if (strcmp(header->compression_type, "gzip") != 0) {
923 fprintf(stderr,
924 "unable to handle EFI zboot image with \"%.*s\" compression\n",
925 (int)sizeof(header->compression_type) - 1,
926 header->compression_type);
927 return -1;
928 }
929
930 ploff = ldl_le_p(&header->payload_offset);
931 plsize = ldl_le_p(&header->payload_size);
932
933 if (ploff < 0 || plsize < 0 || ploff + plsize > *size) {
934 fprintf(stderr, "unable to handle corrupt EFI zboot image\n");
935 return -1;
936 }
937
938 data = g_malloc(LOAD_IMAGE_MAX_GUNZIP_BYTES);
939 bytes = gunzip(data, LOAD_IMAGE_MAX_GUNZIP_BYTES, *buffer + ploff, plsize);
940 if (bytes < 0) {
941 fprintf(stderr, "failed to decompress EFI zboot image\n");
942 g_free(data);
943 return -1;
944 }
945
946 g_free(*buffer);
947 *buffer = g_realloc(data, bytes);
948 *size = bytes;
949 return bytes;
950}
951
952
953
954
955
956
957
958typedef struct Rom Rom;
959
960struct Rom {
961 char *name;
962 char *path;
963
964
965
966
967
968 size_t romsize;
969 size_t datasize;
970
971 uint8_t *data;
972 MemoryRegion *mr;
973 AddressSpace *as;
974 int isrom;
975 char *fw_dir;
976 char *fw_file;
977 GMappedFile *mapped_file;
978
979 bool committed;
980
981 hwaddr addr;
982 QTAILQ_ENTRY(Rom) next;
983};
984
985static FWCfgState *fw_cfg;
986static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms);
987
988
989
990
991
992static void rom_free_data(Rom *rom)
993{
994 if (rom->mapped_file) {
995 g_mapped_file_unref(rom->mapped_file);
996 rom->mapped_file = NULL;
997 } else {
998 g_free(rom->data);
999 }
1000
1001 rom->data = NULL;
1002}
1003
1004static void rom_free(Rom *rom)
1005{
1006 rom_free_data(rom);
1007 g_free(rom->path);
1008 g_free(rom->name);
1009 g_free(rom->fw_dir);
1010 g_free(rom->fw_file);
1011 g_free(rom);
1012}
1013
1014static inline bool rom_order_compare(Rom *rom, Rom *item)
1015{
1016 return ((uintptr_t)(void *)rom->as > (uintptr_t)(void *)item->as) ||
1017 (rom->as == item->as && rom->addr >= item->addr);
1018}
1019
1020static void rom_insert(Rom *rom)
1021{
1022 Rom *item;
1023
1024 if (roms_loaded) {
1025 hw_error ("ROM images must be loaded at startup\n");
1026 }
1027
1028
1029 if (!rom->as) {
1030 rom->as = &address_space_memory;
1031 }
1032
1033 rom->committed = false;
1034
1035
1036 QTAILQ_FOREACH(item, &roms, next) {
1037 if (rom_order_compare(rom, item)) {
1038 continue;
1039 }
1040 QTAILQ_INSERT_BEFORE(item, rom, next);
1041 return;
1042 }
1043 QTAILQ_INSERT_TAIL(&roms, rom, next);
1044}
1045
1046static void fw_cfg_resized(const char *id, uint64_t length, void *host)
1047{
1048 if (fw_cfg) {
1049 fw_cfg_modify_file(fw_cfg, id + strlen("/rom@"), host, length);
1050 }
1051}
1052
1053static void *rom_set_mr(Rom *rom, Object *owner, const char *name, bool ro)
1054{
1055 void *data;
1056
1057 rom->mr = g_malloc(sizeof(*rom->mr));
1058 memory_region_init_resizeable_ram(rom->mr, owner, name,
1059 rom->datasize, rom->romsize,
1060 fw_cfg_resized,
1061 &error_fatal);
1062 memory_region_set_readonly(rom->mr, ro);
1063 vmstate_register_ram_global(rom->mr);
1064
1065 data = memory_region_get_ram_ptr(rom->mr);
1066 memcpy(data, rom->data, rom->datasize);
1067
1068 return data;
1069}
1070
1071ssize_t rom_add_file(const char *file, const char *fw_dir,
1072 hwaddr addr, int32_t bootindex,
1073 bool option_rom, MemoryRegion *mr,
1074 AddressSpace *as)
1075{
1076 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
1077 Rom *rom;
1078 ssize_t rc;
1079 int fd = -1;
1080 char devpath[100];
1081
1082 if (as && mr) {
1083 fprintf(stderr, "Specifying an Address Space and Memory Region is " \
1084 "not valid when loading a rom\n");
1085
1086 return -1;
1087 }
1088
1089 rom = g_malloc0(sizeof(*rom));
1090 rom->name = g_strdup(file);
1091 rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name);
1092 rom->as = as;
1093 if (rom->path == NULL) {
1094 rom->path = g_strdup(file);
1095 }
1096
1097 fd = open(rom->path, O_RDONLY | O_BINARY);
1098 if (fd == -1) {
1099 fprintf(stderr, "Could not open option rom '%s': %s\n",
1100 rom->path, strerror(errno));
1101 goto err;
1102 }
1103
1104 if (fw_dir) {
1105 rom->fw_dir = g_strdup(fw_dir);
1106 rom->fw_file = g_strdup(file);
1107 }
1108 rom->addr = addr;
1109 rom->romsize = lseek(fd, 0, SEEK_END);
1110 if (rom->romsize == -1) {
1111 fprintf(stderr, "rom: file %-20s: get size error: %s\n",
1112 rom->name, strerror(errno));
1113 goto err;
1114 }
1115
1116 rom->datasize = rom->romsize;
1117 rom->data = g_malloc0(rom->datasize);
1118 lseek(fd, 0, SEEK_SET);
1119 rc = read(fd, rom->data, rom->datasize);
1120 if (rc != rom->datasize) {
1121 fprintf(stderr, "rom: file %-20s: read error: rc=%zd (expected %zd)\n",
1122 rom->name, rc, rom->datasize);
1123 goto err;
1124 }
1125 close(fd);
1126 rom_insert(rom);
1127 if (rom->fw_file && fw_cfg) {
1128 const char *basename;
1129 char fw_file_name[FW_CFG_MAX_FILE_PATH];
1130 void *data;
1131
1132 basename = strrchr(rom->fw_file, '/');
1133 if (basename) {
1134 basename++;
1135 } else {
1136 basename = rom->fw_file;
1137 }
1138 snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir,
1139 basename);
1140 snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
1141
1142 if ((!option_rom || mc->option_rom_has_mr) && mc->rom_file_has_mr) {
1143 data = rom_set_mr(rom, OBJECT(fw_cfg), devpath, true);
1144 } else {
1145 data = rom->data;
1146 }
1147
1148 fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize);
1149 } else {
1150 if (mr) {
1151 rom->mr = mr;
1152 snprintf(devpath, sizeof(devpath), "/rom@%s", file);
1153 } else {
1154 snprintf(devpath, sizeof(devpath), "/rom@" HWADDR_FMT_plx, addr);
1155 }
1156 }
1157
1158 add_boot_device_path(bootindex, NULL, devpath);
1159 return 0;
1160
1161err:
1162 if (fd != -1)
1163 close(fd);
1164
1165 rom_free(rom);
1166 return -1;
1167}
1168
1169MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len,
1170 size_t max_len, hwaddr addr, const char *fw_file_name,
1171 FWCfgCallback fw_callback, void *callback_opaque,
1172 AddressSpace *as, bool read_only)
1173{
1174 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
1175 Rom *rom;
1176 MemoryRegion *mr = NULL;
1177
1178 rom = g_malloc0(sizeof(*rom));
1179 rom->name = g_strdup(name);
1180 rom->as = as;
1181 rom->addr = addr;
1182 rom->romsize = max_len ? max_len : len;
1183 rom->datasize = len;
1184 g_assert(rom->romsize >= rom->datasize);
1185 rom->data = g_malloc0(rom->datasize);
1186 memcpy(rom->data, blob, len);
1187 rom_insert(rom);
1188 if (fw_file_name && fw_cfg) {
1189 char devpath[100];
1190 void *data;
1191
1192 if (read_only) {
1193 snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
1194 } else {
1195 snprintf(devpath, sizeof(devpath), "/ram@%s", fw_file_name);
1196 }
1197
1198 if (mc->rom_file_has_mr) {
1199 data = rom_set_mr(rom, OBJECT(fw_cfg), devpath, read_only);
1200 mr = rom->mr;
1201 } else {
1202 data = rom->data;
1203 }
1204
1205 fw_cfg_add_file_callback(fw_cfg, fw_file_name,
1206 fw_callback, NULL, callback_opaque,
1207 data, rom->datasize, read_only);
1208 }
1209 return mr;
1210}
1211
1212
1213
1214
1215
1216
1217int rom_add_elf_program(const char *name, GMappedFile *mapped_file, void *data,
1218 size_t datasize, size_t romsize, hwaddr addr,
1219 AddressSpace *as)
1220{
1221 Rom *rom;
1222
1223 rom = g_malloc0(sizeof(*rom));
1224 rom->name = g_strdup(name);
1225 rom->addr = addr;
1226 rom->datasize = datasize;
1227 rom->romsize = romsize;
1228 rom->data = data;
1229 rom->as = as;
1230
1231 if (mapped_file && data) {
1232 g_mapped_file_ref(mapped_file);
1233 rom->mapped_file = mapped_file;
1234 }
1235
1236 rom_insert(rom);
1237 return 0;
1238}
1239
1240ssize_t rom_add_vga(const char *file)
1241{
1242 return rom_add_file(file, "vgaroms", 0, -1, true, NULL, NULL);
1243}
1244
1245ssize_t rom_add_option(const char *file, int32_t bootindex)
1246{
1247 return rom_add_file(file, "genroms", 0, bootindex, true, NULL, NULL);
1248}
1249
1250static void rom_reset(void *unused)
1251{
1252 Rom *rom;
1253
1254 QTAILQ_FOREACH(rom, &roms, next) {
1255 if (rom->fw_file) {
1256 continue;
1257 }
1258
1259
1260
1261
1262
1263 if (runstate_check(RUN_STATE_INMIGRATE)) {
1264 if (rom->data && rom->isrom) {
1265
1266
1267
1268
1269 rom_free_data(rom);
1270 }
1271 continue;
1272 }
1273
1274 if (rom->data == NULL) {
1275 continue;
1276 }
1277 if (rom->mr) {
1278 void *host = memory_region_get_ram_ptr(rom->mr);
1279 memcpy(host, rom->data, rom->datasize);
1280 memset(host + rom->datasize, 0, rom->romsize - rom->datasize);
1281 } else {
1282 address_space_write_rom(rom->as, rom->addr, MEMTXATTRS_UNSPECIFIED,
1283 rom->data, rom->datasize);
1284 address_space_set(rom->as, rom->addr + rom->datasize, 0,
1285 rom->romsize - rom->datasize,
1286 MEMTXATTRS_UNSPECIFIED);
1287 }
1288 if (rom->isrom) {
1289
1290 rom_free_data(rom);
1291 }
1292
1293
1294
1295
1296
1297
1298 cpu_flush_icache_range(rom->addr, rom->datasize);
1299
1300 trace_loader_write_rom(rom->name, rom->addr, rom->datasize, rom->isrom);
1301 }
1302}
1303
1304
1305static bool roms_overlap(Rom *last_rom, Rom *this_rom)
1306{
1307 if (!last_rom) {
1308 return false;
1309 }
1310 return last_rom->as == this_rom->as &&
1311 last_rom->addr + last_rom->romsize > this_rom->addr;
1312}
1313
1314static const char *rom_as_name(Rom *rom)
1315{
1316 const char *name = rom->as ? rom->as->name : NULL;
1317 return name ?: "anonymous";
1318}
1319
1320static void rom_print_overlap_error_header(void)
1321{
1322 error_report("Some ROM regions are overlapping");
1323 error_printf(
1324 "These ROM regions might have been loaded by "
1325 "direct user request or by default.\n"
1326 "They could be BIOS/firmware images, a guest kernel, "
1327 "initrd or some other file loaded into guest memory.\n"
1328 "Check whether you intended to load all this guest code, and "
1329 "whether it has been built to load to the correct addresses.\n");
1330}
1331
1332static void rom_print_one_overlap_error(Rom *last_rom, Rom *rom)
1333{
1334 error_printf(
1335 "\nThe following two regions overlap (in the %s address space):\n",
1336 rom_as_name(rom));
1337 error_printf(
1338 " %s (addresses 0x" HWADDR_FMT_plx " - 0x" HWADDR_FMT_plx ")\n",
1339 last_rom->name, last_rom->addr, last_rom->addr + last_rom->romsize);
1340 error_printf(
1341 " %s (addresses 0x" HWADDR_FMT_plx " - 0x" HWADDR_FMT_plx ")\n",
1342 rom->name, rom->addr, rom->addr + rom->romsize);
1343}
1344
1345int rom_check_and_register_reset(void)
1346{
1347 MemoryRegionSection section;
1348 Rom *rom, *last_rom = NULL;
1349 bool found_overlap = false;
1350
1351 QTAILQ_FOREACH(rom, &roms, next) {
1352 if (rom->fw_file) {
1353 continue;
1354 }
1355 if (!rom->mr) {
1356 if (roms_overlap(last_rom, rom)) {
1357 if (!found_overlap) {
1358 found_overlap = true;
1359 rom_print_overlap_error_header();
1360 }
1361 rom_print_one_overlap_error(last_rom, rom);
1362
1363 }
1364 last_rom = rom;
1365 }
1366 section = memory_region_find(rom->mr ? rom->mr : get_system_memory(),
1367 rom->addr, 1);
1368 rom->isrom = int128_nz(section.size) && memory_region_is_rom(section.mr);
1369 memory_region_unref(section.mr);
1370 }
1371 if (found_overlap) {
1372 return -1;
1373 }
1374
1375 qemu_register_reset(rom_reset, NULL);
1376 roms_loaded = 1;
1377 return 0;
1378}
1379
1380void rom_set_fw(FWCfgState *f)
1381{
1382 fw_cfg = f;
1383}
1384
1385void rom_set_order_override(int order)
1386{
1387 if (!fw_cfg)
1388 return;
1389 fw_cfg_set_order_override(fw_cfg, order);
1390}
1391
1392void rom_reset_order_override(void)
1393{
1394 if (!fw_cfg)
1395 return;
1396 fw_cfg_reset_order_override(fw_cfg);
1397}
1398
1399void rom_transaction_begin(void)
1400{
1401 Rom *rom;
1402
1403
1404 QTAILQ_FOREACH(rom, &roms, next) {
1405 rom->committed = true;
1406 }
1407}
1408
1409void rom_transaction_end(bool commit)
1410{
1411 Rom *rom;
1412 Rom *tmp;
1413
1414 QTAILQ_FOREACH_SAFE(rom, &roms, next, tmp) {
1415 if (rom->committed) {
1416 continue;
1417 }
1418 if (commit) {
1419 rom->committed = true;
1420 } else {
1421 QTAILQ_REMOVE(&roms, rom, next);
1422 rom_free(rom);
1423 }
1424 }
1425}
1426
1427static Rom *find_rom(hwaddr addr, size_t size)
1428{
1429 Rom *rom;
1430
1431 QTAILQ_FOREACH(rom, &roms, next) {
1432 if (rom->fw_file) {
1433 continue;
1434 }
1435 if (rom->mr) {
1436 continue;
1437 }
1438 if (rom->addr > addr) {
1439 continue;
1440 }
1441 if (rom->addr + rom->romsize < addr + size) {
1442 continue;
1443 }
1444 return rom;
1445 }
1446 return NULL;
1447}
1448
1449typedef struct RomSec {
1450 hwaddr base;
1451 int se;
1452} RomSec;
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462static gint sort_secs(gconstpointer a, gconstpointer b)
1463{
1464 RomSec *ra = (RomSec *) a;
1465 RomSec *rb = (RomSec *) b;
1466
1467 if (ra->base == rb->base) {
1468 return ra->se - rb->se;
1469 }
1470 return ra->base > rb->base ? 1 : -1;
1471}
1472
1473static GList *add_romsec_to_list(GList *secs, hwaddr base, int se)
1474{
1475 RomSec *cand = g_new(RomSec, 1);
1476 cand->base = base;
1477 cand->se = se;
1478 return g_list_prepend(secs, cand);
1479}
1480
1481RomGap rom_find_largest_gap_between(hwaddr base, size_t size)
1482{
1483 Rom *rom;
1484 RomSec *cand;
1485 RomGap res = {0, 0};
1486 hwaddr gapstart = base;
1487 GList *it, *secs = NULL;
1488 int count = 0;
1489
1490 QTAILQ_FOREACH(rom, &roms, next) {
1491
1492 if (rom->mr || rom->fw_file) {
1493 continue;
1494 }
1495
1496 if (rom->addr + rom->romsize <= base) {
1497 continue;
1498 }
1499
1500 if (rom->addr >= base + size) {
1501 continue;
1502 }
1503
1504
1505 secs = add_romsec_to_list(secs, rom->addr, 1);
1506
1507 if (rom->addr + rom->romsize < base + size) {
1508 secs = add_romsec_to_list(secs, rom->addr + rom->romsize, -1);
1509 }
1510 }
1511
1512
1513 secs = add_romsec_to_list(secs, base + size, 1);
1514
1515 secs = g_list_sort(secs, sort_secs);
1516
1517 for (it = g_list_first(secs); it; it = g_list_next(it)) {
1518 cand = (RomSec *) it->data;
1519 if (count == 0 && count + cand->se == 1) {
1520 size_t gap = cand->base - gapstart;
1521 if (gap > res.size) {
1522 res.base = gapstart;
1523 res.size = gap;
1524 }
1525 } else if (count == 1 && count + cand->se == 0) {
1526 gapstart = cand->base;
1527 }
1528 count += cand->se;
1529 }
1530
1531 g_list_free_full(secs, g_free);
1532 return res;
1533}
1534
1535
1536
1537
1538
1539
1540int rom_copy(uint8_t *dest, hwaddr addr, size_t size)
1541{
1542 hwaddr end = addr + size;
1543 uint8_t *s, *d = dest;
1544 size_t l = 0;
1545 Rom *rom;
1546
1547 QTAILQ_FOREACH(rom, &roms, next) {
1548 if (rom->fw_file) {
1549 continue;
1550 }
1551 if (rom->mr) {
1552 continue;
1553 }
1554 if (rom->addr + rom->romsize < addr) {
1555 continue;
1556 }
1557 if (rom->addr > end || rom->addr < addr) {
1558 break;
1559 }
1560
1561 d = dest + (rom->addr - addr);
1562 s = rom->data;
1563 l = rom->datasize;
1564
1565 if ((d + l) > (dest + size)) {
1566 l = dest - d;
1567 }
1568
1569 if (l > 0) {
1570 memcpy(d, s, l);
1571 }
1572
1573 if (rom->romsize > rom->datasize) {
1574
1575
1576
1577
1578 d += l;
1579 l = rom->romsize - rom->datasize;
1580
1581 if ((d + l) > (dest + size)) {
1582
1583
1584
1585 l = dest - d;
1586 }
1587
1588 if (l > 0) {
1589 memset(d, 0x0, l);
1590 }
1591 }
1592 }
1593
1594 return (d + l) - dest;
1595}
1596
1597void *rom_ptr(hwaddr addr, size_t size)
1598{
1599 Rom *rom;
1600
1601 rom = find_rom(addr, size);
1602 if (!rom || !rom->data)
1603 return NULL;
1604 return rom->data + (addr - rom->addr);
1605}
1606
1607typedef struct FindRomCBData {
1608 size_t size;
1609 MemoryRegion *mr;
1610 hwaddr xlat;
1611 void *rom;
1612} FindRomCBData;
1613
1614static bool find_rom_cb(Int128 start, Int128 len, const MemoryRegion *mr,
1615 hwaddr offset_in_region, void *opaque)
1616{
1617 FindRomCBData *cbdata = opaque;
1618 hwaddr alias_addr;
1619
1620 if (mr != cbdata->mr) {
1621 return false;
1622 }
1623
1624 alias_addr = int128_get64(start) + cbdata->xlat - offset_in_region;
1625 cbdata->rom = rom_ptr(alias_addr, cbdata->size);
1626 if (!cbdata->rom) {
1627 return false;
1628 }
1629
1630 return true;
1631}
1632
1633void *rom_ptr_for_as(AddressSpace *as, hwaddr addr, size_t size)
1634{
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657 FlatView *fv;
1658 void *rom;
1659 hwaddr len_unused;
1660 FindRomCBData cbdata = {};
1661
1662
1663 rom = rom_ptr(addr, size);
1664 if (rom) {
1665 return rom;
1666 }
1667
1668 RCU_READ_LOCK_GUARD();
1669
1670 fv = address_space_to_flatview(as);
1671 cbdata.mr = flatview_translate(fv, addr, &cbdata.xlat, &len_unused,
1672 false, MEMTXATTRS_UNSPECIFIED);
1673 if (!cbdata.mr) {
1674
1675 return NULL;
1676 }
1677 cbdata.size = size;
1678 flatview_for_each_range(fv, find_rom_cb, &cbdata);
1679 return cbdata.rom;
1680}
1681
1682HumanReadableText *qmp_x_query_roms(Error **errp)
1683{
1684 Rom *rom;
1685 g_autoptr(GString) buf = g_string_new("");
1686
1687 QTAILQ_FOREACH(rom, &roms, next) {
1688 if (rom->mr) {
1689 g_string_append_printf(buf, "%s"
1690 " size=0x%06zx name=\"%s\"\n",
1691 memory_region_name(rom->mr),
1692 rom->romsize,
1693 rom->name);
1694 } else if (!rom->fw_file) {
1695 g_string_append_printf(buf, "addr=" HWADDR_FMT_plx
1696 " size=0x%06zx mem=%s name=\"%s\"\n",
1697 rom->addr, rom->romsize,
1698 rom->isrom ? "rom" : "ram",
1699 rom->name);
1700 } else {
1701 g_string_append_printf(buf, "fw=%s/%s"
1702 " size=0x%06zx name=\"%s\"\n",
1703 rom->fw_dir,
1704 rom->fw_file,
1705 rom->romsize,
1706 rom->name);
1707 }
1708 }
1709
1710 return human_readable_text_from_str(buf);
1711}
1712
1713typedef enum HexRecord HexRecord;
1714enum HexRecord {
1715 DATA_RECORD = 0,
1716 EOF_RECORD,
1717 EXT_SEG_ADDR_RECORD,
1718 START_SEG_ADDR_RECORD,
1719 EXT_LINEAR_ADDR_RECORD,
1720 START_LINEAR_ADDR_RECORD,
1721};
1722
1723
1724
1725
1726#define NEXT_ADDR_MASK 0xffff0000
1727
1728#define DATA_FIELD_MAX_LEN 0xff
1729#define LEN_EXCEPT_DATA 0x5
1730
1731
1732typedef struct {
1733 uint8_t byte_count;
1734 uint16_t address;
1735 uint8_t record_type;
1736 uint8_t data[DATA_FIELD_MAX_LEN];
1737 uint8_t checksum;
1738} HexLine;
1739
1740
1741static bool parse_record(HexLine *line, uint8_t *our_checksum, const uint8_t c,
1742 uint32_t *index, const bool in_process)
1743{
1744
1745
1746
1747
1748
1749
1750
1751 uint8_t value = 0;
1752 uint32_t idx = *index;
1753
1754 if (g_ascii_isspace(c)) {
1755 return true;
1756 }
1757 if (!g_ascii_isxdigit(c) || !in_process) {
1758 return false;
1759 }
1760 value = g_ascii_xdigit_value(c);
1761 value = (idx & 0x1) ? (value & 0xf) : (value << 4);
1762 if (idx < 2) {
1763 line->byte_count |= value;
1764 } else if (2 <= idx && idx < 6) {
1765 line->address <<= 4;
1766 line->address += g_ascii_xdigit_value(c);
1767 } else if (6 <= idx && idx < 8) {
1768 line->record_type |= value;
1769 } else if (8 <= idx && idx < 8 + 2 * line->byte_count) {
1770 line->data[(idx - 8) >> 1] |= value;
1771 } else if (8 + 2 * line->byte_count <= idx &&
1772 idx < 10 + 2 * line->byte_count) {
1773 line->checksum |= value;
1774 } else {
1775 return false;
1776 }
1777 *our_checksum += value;
1778 ++(*index);
1779 return true;
1780}
1781
1782typedef struct {
1783 const char *filename;
1784 HexLine line;
1785 uint8_t *bin_buf;
1786 hwaddr *start_addr;
1787 int total_size;
1788 uint32_t next_address_to_write;
1789 uint32_t current_address;
1790 uint32_t current_rom_index;
1791 uint32_t rom_start_address;
1792 AddressSpace *as;
1793 bool complete;
1794} HexParser;
1795
1796
1797static int handle_record_type(HexParser *parser)
1798{
1799 HexLine *line = &(parser->line);
1800 switch (line->record_type) {
1801 case DATA_RECORD:
1802 parser->current_address =
1803 (parser->next_address_to_write & NEXT_ADDR_MASK) | line->address;
1804
1805 if (parser->current_address != parser->next_address_to_write) {
1806 if (parser->current_rom_index != 0) {
1807 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1808 parser->current_rom_index,
1809 parser->rom_start_address, parser->as);
1810 }
1811 parser->rom_start_address = parser->current_address;
1812 parser->current_rom_index = 0;
1813 }
1814
1815
1816 memcpy(parser->bin_buf + parser->current_rom_index, line->data,
1817 line->byte_count);
1818 parser->current_rom_index += line->byte_count;
1819 parser->total_size += line->byte_count;
1820
1821 parser->next_address_to_write =
1822 parser->current_address + line->byte_count;
1823 break;
1824
1825 case EOF_RECORD:
1826 if (parser->current_rom_index != 0) {
1827 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1828 parser->current_rom_index,
1829 parser->rom_start_address, parser->as);
1830 }
1831 parser->complete = true;
1832 return parser->total_size;
1833 case EXT_SEG_ADDR_RECORD:
1834 case EXT_LINEAR_ADDR_RECORD:
1835 if (line->byte_count != 2 && line->address != 0) {
1836 return -1;
1837 }
1838
1839 if (parser->current_rom_index != 0) {
1840 rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
1841 parser->current_rom_index,
1842 parser->rom_start_address, parser->as);
1843 }
1844
1845
1846
1847 parser->next_address_to_write = (line->data[0] << 12) |
1848 (line->data[1] << 4);
1849 if (line->record_type == EXT_LINEAR_ADDR_RECORD) {
1850 parser->next_address_to_write <<= 12;
1851 }
1852
1853 parser->rom_start_address = parser->next_address_to_write;
1854 parser->current_rom_index = 0;
1855 break;
1856
1857 case START_SEG_ADDR_RECORD:
1858 if (line->byte_count != 4 && line->address != 0) {
1859 return -1;
1860 }
1861
1862
1863 *(parser->start_addr) = (((line->data[0] << 8) | line->data[1]) << 4) +
1864 ((line->data[2] << 8) | line->data[3]);
1865 break;
1866
1867 case START_LINEAR_ADDR_RECORD:
1868 if (line->byte_count != 4 && line->address != 0) {
1869 return -1;
1870 }
1871
1872 *(parser->start_addr) = ldl_be_p(line->data);
1873 break;
1874
1875 default:
1876 return -1;
1877 }
1878
1879 return parser->total_size;
1880}
1881
1882
1883static int parse_hex_blob(const char *filename, hwaddr *addr, uint8_t *hex_blob,
1884 size_t hex_blob_size, AddressSpace *as)
1885{
1886 bool in_process = false;
1887
1888 uint8_t *end = hex_blob + hex_blob_size;
1889 uint8_t our_checksum = 0;
1890 uint32_t record_index = 0;
1891 HexParser parser = {
1892 .filename = filename,
1893 .bin_buf = g_malloc(hex_blob_size),
1894 .start_addr = addr,
1895 .as = as,
1896 .complete = false
1897 };
1898
1899 rom_transaction_begin();
1900
1901 for (; hex_blob < end && !parser.complete; ++hex_blob) {
1902 switch (*hex_blob) {
1903 case '\r':
1904 case '\n':
1905 if (!in_process) {
1906 break;
1907 }
1908
1909 in_process = false;
1910 if ((LEN_EXCEPT_DATA + parser.line.byte_count) * 2 !=
1911 record_index ||
1912 our_checksum != 0) {
1913 parser.total_size = -1;
1914 goto out;
1915 }
1916
1917 if (handle_record_type(&parser) == -1) {
1918 parser.total_size = -1;
1919 goto out;
1920 }
1921 break;
1922
1923
1924 case ':':
1925 memset(&parser.line, 0, sizeof(HexLine));
1926 in_process = true;
1927 record_index = 0;
1928 break;
1929
1930
1931 default:
1932 if (!parse_record(&parser.line, &our_checksum, *hex_blob,
1933 &record_index, in_process)) {
1934 parser.total_size = -1;
1935 goto out;
1936 }
1937 break;
1938 }
1939 }
1940
1941out:
1942 g_free(parser.bin_buf);
1943 rom_transaction_end(parser.total_size != -1);
1944 return parser.total_size;
1945}
1946
1947
1948ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
1949 AddressSpace *as)
1950{
1951 gsize hex_blob_size;
1952 gchar *hex_blob;
1953 ssize_t total_size = 0;
1954
1955 if (!g_file_get_contents(filename, &hex_blob, &hex_blob_size, NULL)) {
1956 return -1;
1957 }
1958
1959 total_size = parse_hex_blob(filename, entry, (uint8_t *)hex_blob,
1960 hex_blob_size, as);
1961
1962 g_free(hex_blob);
1963 return total_size;
1964}
1965