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