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