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