]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * QEMU Executable loader | |
3 | * | |
4 | * Copyright (c) 2006 Fabrice Bellard | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | * | |
24 | * Gunzip functionality in this file is derived from u-boot: | |
25 | * | |
26 | * (C) Copyright 2008 Semihalf | |
27 | * | |
28 | * (C) Copyright 2000-2005 | |
29 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
30 | * | |
31 | * This program is free software; you can redistribute it and/or | |
32 | * modify it under the terms of the GNU General Public License as | |
33 | * published by the Free Software Foundation; either version 2 of | |
34 | * the License, or (at your option) any later version. | |
35 | * | |
36 | * This program is distributed in the hope that it will be useful, | |
37 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
38 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
39 | * GNU General Public License for more details. | |
40 | * | |
41 | * You should have received a copy of the GNU General Public License along | |
42 | * with this program; if not, see <http://www.gnu.org/licenses/>. | |
43 | */ | |
44 | ||
45 | #include "hw.h" | |
46 | #include "disas.h" | |
47 | #include "monitor.h" | |
48 | #include "sysemu.h" | |
49 | #include "uboot_image.h" | |
50 | #include "loader.h" | |
51 | #include "fw_cfg.h" | |
52 | #include "memory.h" | |
53 | #include "exec-memory.h" | |
54 | ||
55 | #include <zlib.h> | |
56 | ||
57 | static int roms_loaded; | |
58 | ||
59 | /* return the size or -1 if error */ | |
60 | int get_image_size(const char *filename) | |
61 | { | |
62 | int fd, size; | |
63 | fd = open(filename, O_RDONLY | O_BINARY); | |
64 | if (fd < 0) | |
65 | return -1; | |
66 | size = lseek(fd, 0, SEEK_END); | |
67 | close(fd); | |
68 | return size; | |
69 | } | |
70 | ||
71 | /* return the size or -1 if error */ | |
72 | /* deprecated, because caller does not specify buffer size! */ | |
73 | int load_image(const char *filename, uint8_t *addr) | |
74 | { | |
75 | int fd, size; | |
76 | fd = open(filename, O_RDONLY | O_BINARY); | |
77 | if (fd < 0) | |
78 | return -1; | |
79 | size = lseek(fd, 0, SEEK_END); | |
80 | lseek(fd, 0, SEEK_SET); | |
81 | if (read(fd, addr, size) != size) { | |
82 | close(fd); | |
83 | return -1; | |
84 | } | |
85 | close(fd); | |
86 | return size; | |
87 | } | |
88 | ||
89 | /* read()-like version */ | |
90 | ssize_t read_targphys(const char *name, | |
91 | int fd, target_phys_addr_t dst_addr, size_t nbytes) | |
92 | { | |
93 | uint8_t *buf; | |
94 | ssize_t did; | |
95 | ||
96 | buf = g_malloc(nbytes); | |
97 | did = read(fd, buf, nbytes); | |
98 | if (did > 0) | |
99 | rom_add_blob_fixed("read", buf, did, dst_addr); | |
100 | g_free(buf); | |
101 | return did; | |
102 | } | |
103 | ||
104 | /* return the size or -1 if error */ | |
105 | int load_image_targphys(const char *filename, | |
106 | target_phys_addr_t addr, uint64_t max_sz) | |
107 | { | |
108 | int size; | |
109 | ||
110 | size = get_image_size(filename); | |
111 | if (size > max_sz) { | |
112 | return -1; | |
113 | } | |
114 | if (size > 0) { | |
115 | rom_add_file_fixed(filename, addr, -1); | |
116 | } | |
117 | return size; | |
118 | } | |
119 | ||
120 | void pstrcpy_targphys(const char *name, target_phys_addr_t dest, int buf_size, | |
121 | const char *source) | |
122 | { | |
123 | const char *nulp; | |
124 | char *ptr; | |
125 | ||
126 | if (buf_size <= 0) return; | |
127 | nulp = memchr(source, 0, buf_size); | |
128 | if (nulp) { | |
129 | rom_add_blob_fixed(name, source, (nulp - source) + 1, dest); | |
130 | } else { | |
131 | rom_add_blob_fixed(name, source, buf_size, dest); | |
132 | ptr = rom_ptr(dest + buf_size - 1); | |
133 | *ptr = 0; | |
134 | } | |
135 | } | |
136 | ||
137 | /* A.OUT loader */ | |
138 | ||
139 | struct exec | |
140 | { | |
141 | uint32_t a_info; /* Use macros N_MAGIC, etc for access */ | |
142 | uint32_t a_text; /* length of text, in bytes */ | |
143 | uint32_t a_data; /* length of data, in bytes */ | |
144 | uint32_t a_bss; /* length of uninitialized data area, in bytes */ | |
145 | uint32_t a_syms; /* length of symbol table data in file, in bytes */ | |
146 | uint32_t a_entry; /* start address */ | |
147 | uint32_t a_trsize; /* length of relocation info for text, in bytes */ | |
148 | uint32_t a_drsize; /* length of relocation info for data, in bytes */ | |
149 | }; | |
150 | ||
151 | static void bswap_ahdr(struct exec *e) | |
152 | { | |
153 | bswap32s(&e->a_info); | |
154 | bswap32s(&e->a_text); | |
155 | bswap32s(&e->a_data); | |
156 | bswap32s(&e->a_bss); | |
157 | bswap32s(&e->a_syms); | |
158 | bswap32s(&e->a_entry); | |
159 | bswap32s(&e->a_trsize); | |
160 | bswap32s(&e->a_drsize); | |
161 | } | |
162 | ||
163 | #define N_MAGIC(exec) ((exec).a_info & 0xffff) | |
164 | #define OMAGIC 0407 | |
165 | #define NMAGIC 0410 | |
166 | #define ZMAGIC 0413 | |
167 | #define QMAGIC 0314 | |
168 | #define _N_HDROFF(x) (1024 - sizeof (struct exec)) | |
169 | #define N_TXTOFF(x) \ | |
170 | (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \ | |
171 | (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec))) | |
172 | #define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0) | |
173 | #define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1)) | |
174 | ||
175 | #define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text) | |
176 | ||
177 | #define N_DATADDR(x, target_page_size) \ | |
178 | (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \ | |
179 | : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size))) | |
180 | ||
181 | ||
182 | int load_aout(const char *filename, target_phys_addr_t addr, int max_sz, | |
183 | int bswap_needed, target_phys_addr_t target_page_size) | |
184 | { | |
185 | int fd; | |
186 | ssize_t size, ret; | |
187 | struct exec e; | |
188 | uint32_t magic; | |
189 | ||
190 | fd = open(filename, O_RDONLY | O_BINARY); | |
191 | if (fd < 0) | |
192 | return -1; | |
193 | ||
194 | size = read(fd, &e, sizeof(e)); | |
195 | if (size < 0) | |
196 | goto fail; | |
197 | ||
198 | if (bswap_needed) { | |
199 | bswap_ahdr(&e); | |
200 | } | |
201 | ||
202 | magic = N_MAGIC(e); | |
203 | switch (magic) { | |
204 | case ZMAGIC: | |
205 | case QMAGIC: | |
206 | case OMAGIC: | |
207 | if (e.a_text + e.a_data > max_sz) | |
208 | goto fail; | |
209 | lseek(fd, N_TXTOFF(e), SEEK_SET); | |
210 | size = read_targphys(filename, fd, addr, e.a_text + e.a_data); | |
211 | if (size < 0) | |
212 | goto fail; | |
213 | break; | |
214 | case NMAGIC: | |
215 | if (N_DATADDR(e, target_page_size) + e.a_data > max_sz) | |
216 | goto fail; | |
217 | lseek(fd, N_TXTOFF(e), SEEK_SET); | |
218 | size = read_targphys(filename, fd, addr, e.a_text); | |
219 | if (size < 0) | |
220 | goto fail; | |
221 | ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size), | |
222 | e.a_data); | |
223 | if (ret < 0) | |
224 | goto fail; | |
225 | size += ret; | |
226 | break; | |
227 | default: | |
228 | goto fail; | |
229 | } | |
230 | close(fd); | |
231 | return size; | |
232 | fail: | |
233 | close(fd); | |
234 | return -1; | |
235 | } | |
236 | ||
237 | /* ELF loader */ | |
238 | ||
239 | static void *load_at(int fd, int offset, int size) | |
240 | { | |
241 | void *ptr; | |
242 | if (lseek(fd, offset, SEEK_SET) < 0) | |
243 | return NULL; | |
244 | ptr = g_malloc(size); | |
245 | if (read(fd, ptr, size) != size) { | |
246 | g_free(ptr); | |
247 | return NULL; | |
248 | } | |
249 | return ptr; | |
250 | } | |
251 | ||
252 | #ifdef ELF_CLASS | |
253 | #undef ELF_CLASS | |
254 | #endif | |
255 | ||
256 | #define ELF_CLASS ELFCLASS32 | |
257 | #include "elf.h" | |
258 | ||
259 | #define SZ 32 | |
260 | #define elf_word uint32_t | |
261 | #define elf_sword int32_t | |
262 | #define bswapSZs bswap32s | |
263 | #include "elf_ops.h" | |
264 | ||
265 | #undef elfhdr | |
266 | #undef elf_phdr | |
267 | #undef elf_shdr | |
268 | #undef elf_sym | |
269 | #undef elf_note | |
270 | #undef elf_word | |
271 | #undef elf_sword | |
272 | #undef bswapSZs | |
273 | #undef SZ | |
274 | #define elfhdr elf64_hdr | |
275 | #define elf_phdr elf64_phdr | |
276 | #define elf_note elf64_note | |
277 | #define elf_shdr elf64_shdr | |
278 | #define elf_sym elf64_sym | |
279 | #define elf_word uint64_t | |
280 | #define elf_sword int64_t | |
281 | #define bswapSZs bswap64s | |
282 | #define SZ 64 | |
283 | #include "elf_ops.h" | |
284 | ||
285 | /* return < 0 if error, otherwise the number of bytes loaded in memory */ | |
286 | int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t), | |
287 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, | |
288 | uint64_t *highaddr, int big_endian, int elf_machine, int clear_lsb) | |
289 | { | |
290 | int fd, data_order, target_data_order, must_swab, ret; | |
291 | uint8_t e_ident[EI_NIDENT]; | |
292 | ||
293 | fd = open(filename, O_RDONLY | O_BINARY); | |
294 | if (fd < 0) { | |
295 | perror(filename); | |
296 | return -1; | |
297 | } | |
298 | if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident)) | |
299 | goto fail; | |
300 | if (e_ident[0] != ELFMAG0 || | |
301 | e_ident[1] != ELFMAG1 || | |
302 | e_ident[2] != ELFMAG2 || | |
303 | e_ident[3] != ELFMAG3) | |
304 | goto fail; | |
305 | #ifdef HOST_WORDS_BIGENDIAN | |
306 | data_order = ELFDATA2MSB; | |
307 | #else | |
308 | data_order = ELFDATA2LSB; | |
309 | #endif | |
310 | must_swab = data_order != e_ident[EI_DATA]; | |
311 | if (big_endian) { | |
312 | target_data_order = ELFDATA2MSB; | |
313 | } else { | |
314 | target_data_order = ELFDATA2LSB; | |
315 | } | |
316 | ||
317 | if (target_data_order != e_ident[EI_DATA]) { | |
318 | goto fail; | |
319 | } | |
320 | ||
321 | lseek(fd, 0, SEEK_SET); | |
322 | if (e_ident[EI_CLASS] == ELFCLASS64) { | |
323 | ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab, | |
324 | pentry, lowaddr, highaddr, elf_machine, clear_lsb); | |
325 | } else { | |
326 | ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab, | |
327 | pentry, lowaddr, highaddr, elf_machine, clear_lsb); | |
328 | } | |
329 | ||
330 | close(fd); | |
331 | return ret; | |
332 | ||
333 | fail: | |
334 | close(fd); | |
335 | return -1; | |
336 | } | |
337 | ||
338 | static void bswap_uboot_header(uboot_image_header_t *hdr) | |
339 | { | |
340 | #ifndef HOST_WORDS_BIGENDIAN | |
341 | bswap32s(&hdr->ih_magic); | |
342 | bswap32s(&hdr->ih_hcrc); | |
343 | bswap32s(&hdr->ih_time); | |
344 | bswap32s(&hdr->ih_size); | |
345 | bswap32s(&hdr->ih_load); | |
346 | bswap32s(&hdr->ih_ep); | |
347 | bswap32s(&hdr->ih_dcrc); | |
348 | #endif | |
349 | } | |
350 | ||
351 | ||
352 | #define ZALLOC_ALIGNMENT 16 | |
353 | ||
354 | static void *zalloc(void *x, unsigned items, unsigned size) | |
355 | { | |
356 | void *p; | |
357 | ||
358 | size *= items; | |
359 | size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1); | |
360 | ||
361 | p = g_malloc(size); | |
362 | ||
363 | return (p); | |
364 | } | |
365 | ||
366 | static void zfree(void *x, void *addr) | |
367 | { | |
368 | g_free(addr); | |
369 | } | |
370 | ||
371 | ||
372 | #define HEAD_CRC 2 | |
373 | #define EXTRA_FIELD 4 | |
374 | #define ORIG_NAME 8 | |
375 | #define COMMENT 0x10 | |
376 | #define RESERVED 0xe0 | |
377 | ||
378 | #define DEFLATED 8 | |
379 | ||
380 | /* This is the usual maximum in uboot, so if a uImage overflows this, it would | |
381 | * overflow on real hardware too. */ | |
382 | #define UBOOT_MAX_GUNZIP_BYTES (64 << 20) | |
383 | ||
384 | static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, | |
385 | size_t srclen) | |
386 | { | |
387 | z_stream s; | |
388 | ssize_t dstbytes; | |
389 | int r, i, flags; | |
390 | ||
391 | /* skip header */ | |
392 | i = 10; | |
393 | flags = src[3]; | |
394 | if (src[2] != DEFLATED || (flags & RESERVED) != 0) { | |
395 | puts ("Error: Bad gzipped data\n"); | |
396 | return -1; | |
397 | } | |
398 | if ((flags & EXTRA_FIELD) != 0) | |
399 | i = 12 + src[10] + (src[11] << 8); | |
400 | if ((flags & ORIG_NAME) != 0) | |
401 | while (src[i++] != 0) | |
402 | ; | |
403 | if ((flags & COMMENT) != 0) | |
404 | while (src[i++] != 0) | |
405 | ; | |
406 | if ((flags & HEAD_CRC) != 0) | |
407 | i += 2; | |
408 | if (i >= srclen) { | |
409 | puts ("Error: gunzip out of data in header\n"); | |
410 | return -1; | |
411 | } | |
412 | ||
413 | s.zalloc = zalloc; | |
414 | s.zfree = zfree; | |
415 | ||
416 | r = inflateInit2(&s, -MAX_WBITS); | |
417 | if (r != Z_OK) { | |
418 | printf ("Error: inflateInit2() returned %d\n", r); | |
419 | return (-1); | |
420 | } | |
421 | s.next_in = src + i; | |
422 | s.avail_in = srclen - i; | |
423 | s.next_out = dst; | |
424 | s.avail_out = dstlen; | |
425 | r = inflate(&s, Z_FINISH); | |
426 | if (r != Z_OK && r != Z_STREAM_END) { | |
427 | printf ("Error: inflate() returned %d\n", r); | |
428 | return -1; | |
429 | } | |
430 | dstbytes = s.next_out - (unsigned char *) dst; | |
431 | inflateEnd(&s); | |
432 | ||
433 | return dstbytes; | |
434 | } | |
435 | ||
436 | /* Load a U-Boot image. */ | |
437 | int load_uimage(const char *filename, target_phys_addr_t *ep, | |
438 | target_phys_addr_t *loadaddr, int *is_linux) | |
439 | { | |
440 | int fd; | |
441 | int size; | |
442 | uboot_image_header_t h; | |
443 | uboot_image_header_t *hdr = &h; | |
444 | uint8_t *data = NULL; | |
445 | int ret = -1; | |
446 | ||
447 | fd = open(filename, O_RDONLY | O_BINARY); | |
448 | if (fd < 0) | |
449 | return -1; | |
450 | ||
451 | size = read(fd, hdr, sizeof(uboot_image_header_t)); | |
452 | if (size < 0) | |
453 | goto out; | |
454 | ||
455 | bswap_uboot_header(hdr); | |
456 | ||
457 | if (hdr->ih_magic != IH_MAGIC) | |
458 | goto out; | |
459 | ||
460 | /* TODO: Implement other image types. */ | |
461 | if (hdr->ih_type != IH_TYPE_KERNEL) { | |
462 | fprintf(stderr, "Can only load u-boot image type \"kernel\"\n"); | |
463 | goto out; | |
464 | } | |
465 | ||
466 | switch (hdr->ih_comp) { | |
467 | case IH_COMP_NONE: | |
468 | case IH_COMP_GZIP: | |
469 | break; | |
470 | default: | |
471 | fprintf(stderr, | |
472 | "Unable to load u-boot images with compression type %d\n", | |
473 | hdr->ih_comp); | |
474 | goto out; | |
475 | } | |
476 | ||
477 | /* TODO: Check CPU type. */ | |
478 | if (is_linux) { | |
479 | if (hdr->ih_os == IH_OS_LINUX) | |
480 | *is_linux = 1; | |
481 | else | |
482 | *is_linux = 0; | |
483 | } | |
484 | ||
485 | *ep = hdr->ih_ep; | |
486 | data = g_malloc(hdr->ih_size); | |
487 | ||
488 | if (read(fd, data, hdr->ih_size) != hdr->ih_size) { | |
489 | fprintf(stderr, "Error reading file\n"); | |
490 | goto out; | |
491 | } | |
492 | ||
493 | if (hdr->ih_comp == IH_COMP_GZIP) { | |
494 | uint8_t *compressed_data; | |
495 | size_t max_bytes; | |
496 | ssize_t bytes; | |
497 | ||
498 | compressed_data = data; | |
499 | max_bytes = UBOOT_MAX_GUNZIP_BYTES; | |
500 | data = g_malloc(max_bytes); | |
501 | ||
502 | bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size); | |
503 | g_free(compressed_data); | |
504 | if (bytes < 0) { | |
505 | fprintf(stderr, "Unable to decompress gzipped image!\n"); | |
506 | goto out; | |
507 | } | |
508 | hdr->ih_size = bytes; | |
509 | } | |
510 | ||
511 | rom_add_blob_fixed(filename, data, hdr->ih_size, hdr->ih_load); | |
512 | ||
513 | if (loadaddr) | |
514 | *loadaddr = hdr->ih_load; | |
515 | ||
516 | ret = hdr->ih_size; | |
517 | ||
518 | out: | |
519 | if (data) | |
520 | g_free(data); | |
521 | close(fd); | |
522 | return ret; | |
523 | } | |
524 | ||
525 | /* | |
526 | * Functions for reboot-persistent memory regions. | |
527 | * - used for vga bios and option roms. | |
528 | * - also linux kernel (-kernel / -initrd). | |
529 | */ | |
530 | ||
531 | typedef struct Rom Rom; | |
532 | ||
533 | struct Rom { | |
534 | char *name; | |
535 | char *path; | |
536 | size_t romsize; | |
537 | uint8_t *data; | |
538 | int isrom; | |
539 | char *fw_dir; | |
540 | char *fw_file; | |
541 | ||
542 | target_phys_addr_t addr; | |
543 | QTAILQ_ENTRY(Rom) next; | |
544 | }; | |
545 | ||
546 | static FWCfgState *fw_cfg; | |
547 | static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms); | |
548 | ||
549 | static void rom_insert(Rom *rom) | |
550 | { | |
551 | Rom *item; | |
552 | ||
553 | if (roms_loaded) { | |
554 | hw_error ("ROM images must be loaded at startup\n"); | |
555 | } | |
556 | ||
557 | /* list is ordered by load address */ | |
558 | QTAILQ_FOREACH(item, &roms, next) { | |
559 | if (rom->addr >= item->addr) | |
560 | continue; | |
561 | QTAILQ_INSERT_BEFORE(item, rom, next); | |
562 | return; | |
563 | } | |
564 | QTAILQ_INSERT_TAIL(&roms, rom, next); | |
565 | } | |
566 | ||
567 | int rom_add_file(const char *file, const char *fw_dir, | |
568 | target_phys_addr_t addr, int32_t bootindex) | |
569 | { | |
570 | Rom *rom; | |
571 | int rc, fd = -1; | |
572 | char devpath[100]; | |
573 | ||
574 | rom = g_malloc0(sizeof(*rom)); | |
575 | rom->name = g_strdup(file); | |
576 | rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name); | |
577 | if (rom->path == NULL) { | |
578 | rom->path = g_strdup(file); | |
579 | } | |
580 | ||
581 | fd = open(rom->path, O_RDONLY | O_BINARY); | |
582 | if (fd == -1) { | |
583 | fprintf(stderr, "Could not open option rom '%s': %s\n", | |
584 | rom->path, strerror(errno)); | |
585 | goto err; | |
586 | } | |
587 | ||
588 | if (fw_dir) { | |
589 | rom->fw_dir = g_strdup(fw_dir); | |
590 | rom->fw_file = g_strdup(file); | |
591 | } | |
592 | rom->addr = addr; | |
593 | rom->romsize = lseek(fd, 0, SEEK_END); | |
594 | rom->data = g_malloc0(rom->romsize); | |
595 | lseek(fd, 0, SEEK_SET); | |
596 | rc = read(fd, rom->data, rom->romsize); | |
597 | if (rc != rom->romsize) { | |
598 | fprintf(stderr, "rom: file %-20s: read error: rc=%d (expected %zd)\n", | |
599 | rom->name, rc, rom->romsize); | |
600 | goto err; | |
601 | } | |
602 | close(fd); | |
603 | rom_insert(rom); | |
604 | if (rom->fw_file && fw_cfg) { | |
605 | const char *basename; | |
606 | char fw_file_name[56]; | |
607 | ||
608 | basename = strrchr(rom->fw_file, '/'); | |
609 | if (basename) { | |
610 | basename++; | |
611 | } else { | |
612 | basename = rom->fw_file; | |
613 | } | |
614 | snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir, | |
615 | basename); | |
616 | fw_cfg_add_file(fw_cfg, fw_file_name, rom->data, rom->romsize); | |
617 | snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); | |
618 | } else { | |
619 | snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr); | |
620 | } | |
621 | ||
622 | add_boot_device_path(bootindex, NULL, devpath); | |
623 | return 0; | |
624 | ||
625 | err: | |
626 | if (fd != -1) | |
627 | close(fd); | |
628 | g_free(rom->data); | |
629 | g_free(rom->path); | |
630 | g_free(rom->name); | |
631 | g_free(rom); | |
632 | return -1; | |
633 | } | |
634 | ||
635 | int rom_add_blob(const char *name, const void *blob, size_t len, | |
636 | target_phys_addr_t addr) | |
637 | { | |
638 | Rom *rom; | |
639 | ||
640 | rom = g_malloc0(sizeof(*rom)); | |
641 | rom->name = g_strdup(name); | |
642 | rom->addr = addr; | |
643 | rom->romsize = len; | |
644 | rom->data = g_malloc0(rom->romsize); | |
645 | memcpy(rom->data, blob, len); | |
646 | rom_insert(rom); | |
647 | return 0; | |
648 | } | |
649 | ||
650 | int rom_add_vga(const char *file) | |
651 | { | |
652 | return rom_add_file(file, "vgaroms", 0, -1); | |
653 | } | |
654 | ||
655 | int rom_add_option(const char *file, int32_t bootindex) | |
656 | { | |
657 | return rom_add_file(file, "genroms", 0, bootindex); | |
658 | } | |
659 | ||
660 | static void rom_reset(void *unused) | |
661 | { | |
662 | Rom *rom; | |
663 | ||
664 | QTAILQ_FOREACH(rom, &roms, next) { | |
665 | if (rom->fw_file) { | |
666 | continue; | |
667 | } | |
668 | if (rom->data == NULL) { | |
669 | continue; | |
670 | } | |
671 | cpu_physical_memory_write_rom(rom->addr, rom->data, rom->romsize); | |
672 | if (rom->isrom) { | |
673 | /* rom needs to be written only once */ | |
674 | g_free(rom->data); | |
675 | rom->data = NULL; | |
676 | } | |
677 | } | |
678 | } | |
679 | ||
680 | int rom_load_all(void) | |
681 | { | |
682 | target_phys_addr_t addr = 0; | |
683 | MemoryRegionSection section; | |
684 | Rom *rom; | |
685 | ||
686 | QTAILQ_FOREACH(rom, &roms, next) { | |
687 | if (rom->fw_file) { | |
688 | continue; | |
689 | } | |
690 | if (addr > rom->addr) { | |
691 | fprintf(stderr, "rom: requested regions overlap " | |
692 | "(rom %s. free=0x" TARGET_FMT_plx | |
693 | ", addr=0x" TARGET_FMT_plx ")\n", | |
694 | rom->name, addr, rom->addr); | |
695 | return -1; | |
696 | } | |
697 | addr = rom->addr; | |
698 | addr += rom->romsize; | |
699 | section = memory_region_find(get_system_memory(), rom->addr, 1); | |
700 | rom->isrom = section.size && memory_region_is_rom(section.mr); | |
701 | } | |
702 | qemu_register_reset(rom_reset, NULL); | |
703 | roms_loaded = 1; | |
704 | return 0; | |
705 | } | |
706 | ||
707 | void rom_set_fw(void *f) | |
708 | { | |
709 | fw_cfg = f; | |
710 | } | |
711 | ||
712 | static Rom *find_rom(target_phys_addr_t addr) | |
713 | { | |
714 | Rom *rom; | |
715 | ||
716 | QTAILQ_FOREACH(rom, &roms, next) { | |
717 | if (rom->fw_file) { | |
718 | continue; | |
719 | } | |
720 | if (rom->addr > addr) { | |
721 | continue; | |
722 | } | |
723 | if (rom->addr + rom->romsize < addr) { | |
724 | continue; | |
725 | } | |
726 | return rom; | |
727 | } | |
728 | return NULL; | |
729 | } | |
730 | ||
731 | /* | |
732 | * Copies memory from registered ROMs to dest. Any memory that is contained in | |
733 | * a ROM between addr and addr + size is copied. Note that this can involve | |
734 | * multiple ROMs, which need not start at addr and need not end at addr + size. | |
735 | */ | |
736 | int rom_copy(uint8_t *dest, target_phys_addr_t addr, size_t size) | |
737 | { | |
738 | target_phys_addr_t end = addr + size; | |
739 | uint8_t *s, *d = dest; | |
740 | size_t l = 0; | |
741 | Rom *rom; | |
742 | ||
743 | QTAILQ_FOREACH(rom, &roms, next) { | |
744 | if (rom->fw_file) { | |
745 | continue; | |
746 | } | |
747 | if (rom->addr + rom->romsize < addr) { | |
748 | continue; | |
749 | } | |
750 | if (rom->addr > end) { | |
751 | break; | |
752 | } | |
753 | if (!rom->data) { | |
754 | continue; | |
755 | } | |
756 | ||
757 | d = dest + (rom->addr - addr); | |
758 | s = rom->data; | |
759 | l = rom->romsize; | |
760 | ||
761 | if ((d + l) > (dest + size)) { | |
762 | l = dest - d; | |
763 | } | |
764 | ||
765 | memcpy(d, s, l); | |
766 | } | |
767 | ||
768 | return (d + l) - dest; | |
769 | } | |
770 | ||
771 | void *rom_ptr(target_phys_addr_t addr) | |
772 | { | |
773 | Rom *rom; | |
774 | ||
775 | rom = find_rom(addr); | |
776 | if (!rom || !rom->data) | |
777 | return NULL; | |
778 | return rom->data + (addr - rom->addr); | |
779 | } | |
780 | ||
781 | void do_info_roms(Monitor *mon) | |
782 | { | |
783 | Rom *rom; | |
784 | ||
785 | QTAILQ_FOREACH(rom, &roms, next) { | |
786 | if (!rom->fw_file) { | |
787 | monitor_printf(mon, "addr=" TARGET_FMT_plx | |
788 | " size=0x%06zx mem=%s name=\"%s\"\n", | |
789 | rom->addr, rom->romsize, | |
790 | rom->isrom ? "rom" : "ram", | |
791 | rom->name); | |
792 | } else { | |
793 | monitor_printf(mon, "fw=%s/%s" | |
794 | " size=0x%06zx name=\"%s\"\n", | |
795 | rom->fw_dir, | |
796 | rom->fw_file, | |
797 | rom->romsize, | |
798 | rom->name); | |
799 | } | |
800 | } | |
801 | } |