Statistics
| Branch: | Revision:

root / hw / loader.c @ 235f86ef

History | View | Annotate | Download (19.1 kB)

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

    
52
#include <zlib.h>
53

    
54
static int roms_loaded;
55

    
56
/* return the size or -1 if error */
57
int get_image_size(const char *filename)
58
{
59
    int fd, size;
60
    fd = open(filename, O_RDONLY | O_BINARY);
61
    if (fd < 0)
62
        return -1;
63
    size = lseek(fd, 0, SEEK_END);
64
    close(fd);
65
    return size;
66
}
67

    
68
/* return the size or -1 if error */
69
/* deprecated, because caller does not specify buffer size! */
70
int load_image(const char *filename, uint8_t *addr)
71
{
72
    int fd, size;
73
    fd = open(filename, O_RDONLY | O_BINARY);
74
    if (fd < 0)
75
        return -1;
76
    size = lseek(fd, 0, SEEK_END);
77
    lseek(fd, 0, SEEK_SET);
78
    if (read(fd, addr, size) != size) {
79
        close(fd);
80
        return -1;
81
    }
82
    close(fd);
83
    return size;
84
}
85

    
86
/* read()-like version */
87
int read_targphys(const char *name,
88
                  int fd, target_phys_addr_t dst_addr, size_t nbytes)
89
{
90
    uint8_t *buf;
91
    size_t did;
92

    
93
    buf = qemu_malloc(nbytes);
94
    did = read(fd, buf, nbytes);
95
    if (did > 0)
96
        rom_add_blob_fixed("read", buf, did, dst_addr);
97
    qemu_free(buf);
98
    return did;
99
}
100

    
101
/* return the size or -1 if error */
102
int load_image_targphys(const char *filename,
103
                        target_phys_addr_t addr, int max_sz)
104
{
105
    int size;
106

    
107
    size = get_image_size(filename);
108
    if (size > 0)
109
        rom_add_file_fixed(filename, addr);
110
    return size;
111
}
112

    
113
void pstrcpy_targphys(const char *name, target_phys_addr_t dest, int buf_size,
114
                      const char *source)
115
{
116
    const char *nulp;
117
    char *ptr;
118

    
119
    if (buf_size <= 0) return;
120
    nulp = memchr(source, 0, buf_size);
121
    if (nulp) {
122
        rom_add_blob_fixed(name, source, (nulp - source) + 1, dest);
123
    } else {
124
        rom_add_blob_fixed(name, source, buf_size, dest);
125
        ptr = rom_ptr(dest + buf_size - 1);
126
        *ptr = 0;
127
    }
128
}
129

    
130
/* A.OUT loader */
131

    
132
struct exec
133
{
134
  uint32_t a_info;   /* Use macros N_MAGIC, etc for access */
135
  uint32_t a_text;   /* length of text, in bytes */
136
  uint32_t a_data;   /* length of data, in bytes */
137
  uint32_t a_bss;    /* length of uninitialized data area, in bytes */
138
  uint32_t a_syms;   /* length of symbol table data in file, in bytes */
139
  uint32_t a_entry;  /* start address */
140
  uint32_t a_trsize; /* length of relocation info for text, in bytes */
141
  uint32_t a_drsize; /* length of relocation info for data, in bytes */
142
};
143

    
144
static void bswap_ahdr(struct exec *e)
145
{
146
    bswap32s(&e->a_info);
147
    bswap32s(&e->a_text);
148
    bswap32s(&e->a_data);
149
    bswap32s(&e->a_bss);
150
    bswap32s(&e->a_syms);
151
    bswap32s(&e->a_entry);
152
    bswap32s(&e->a_trsize);
153
    bswap32s(&e->a_drsize);
154
}
155

    
156
#define N_MAGIC(exec) ((exec).a_info & 0xffff)
157
#define OMAGIC 0407
158
#define NMAGIC 0410
159
#define ZMAGIC 0413
160
#define QMAGIC 0314
161
#define _N_HDROFF(x) (1024 - sizeof (struct exec))
162
#define N_TXTOFF(x)                                                        \
163
    (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) :        \
164
     (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
165
#define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0)
166
#define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1))
167

    
168
#define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text)
169

    
170
#define N_DATADDR(x, target_page_size) \
171
    (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \
172
     : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size)))
173

    
174

    
175
int load_aout(const char *filename, target_phys_addr_t addr, int max_sz,
176
              int bswap_needed, target_phys_addr_t target_page_size)
177
{
178
    int fd, size, ret;
179
    struct exec e;
180
    uint32_t magic;
181

    
182
    fd = open(filename, O_RDONLY | O_BINARY);
183
    if (fd < 0)
184
        return -1;
185

    
186
    size = read(fd, &e, sizeof(e));
187
    if (size < 0)
188
        goto fail;
189

    
190
    if (bswap_needed) {
191
        bswap_ahdr(&e);
192
    }
193

    
194
    magic = N_MAGIC(e);
195
    switch (magic) {
196
    case ZMAGIC:
197
    case QMAGIC:
198
    case OMAGIC:
199
        if (e.a_text + e.a_data > max_sz)
200
            goto fail;
201
        lseek(fd, N_TXTOFF(e), SEEK_SET);
202
        size = read_targphys(filename, fd, addr, e.a_text + e.a_data);
203
        if (size < 0)
204
            goto fail;
205
        break;
206
    case NMAGIC:
207
        if (N_DATADDR(e, target_page_size) + 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);
211
        if (size < 0)
212
            goto fail;
213
        ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size),
214
                            e.a_data);
215
        if (ret < 0)
216
            goto fail;
217
        size += ret;
218
        break;
219
    default:
220
        goto fail;
221
    }
222
    close(fd);
223
    return size;
224
 fail:
225
    close(fd);
226
    return -1;
227
}
228

    
229
/* ELF loader */
230

    
231
static void *load_at(int fd, int offset, int size)
232
{
233
    void *ptr;
234
    if (lseek(fd, offset, SEEK_SET) < 0)
235
        return NULL;
236
    ptr = qemu_malloc(size);
237
    if (read(fd, ptr, size) != size) {
238
        qemu_free(ptr);
239
        return NULL;
240
    }
241
    return ptr;
242
}
243

    
244
#ifdef ELF_CLASS
245
#undef ELF_CLASS
246
#endif
247

    
248
#define ELF_CLASS   ELFCLASS32
249
#include "elf.h"
250

    
251
#define SZ                32
252
#define elf_word        uint32_t
253
#define elf_sword        int32_t
254
#define bswapSZs        bswap32s
255
#include "elf_ops.h"
256

    
257
#undef elfhdr
258
#undef elf_phdr
259
#undef elf_shdr
260
#undef elf_sym
261
#undef elf_note
262
#undef elf_word
263
#undef elf_sword
264
#undef bswapSZs
265
#undef SZ
266
#define elfhdr                elf64_hdr
267
#define elf_phdr        elf64_phdr
268
#define elf_note        elf64_note
269
#define elf_shdr        elf64_shdr
270
#define elf_sym                elf64_sym
271
#define elf_word        uint64_t
272
#define elf_sword        int64_t
273
#define bswapSZs        bswap64s
274
#define SZ                64
275
#include "elf_ops.h"
276

    
277
/* return < 0 if error, otherwise the number of bytes loaded in memory */
278
int load_elf(const char *filename, int64_t address_offset,
279
             uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr,
280
             int big_endian, int elf_machine, int clear_lsb)
281
{
282
    int fd, data_order, target_data_order, must_swab, ret;
283
    uint8_t e_ident[EI_NIDENT];
284

    
285
    fd = open(filename, O_RDONLY | O_BINARY);
286
    if (fd < 0) {
287
        perror(filename);
288
        return -1;
289
    }
290
    if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
291
        goto fail;
292
    if (e_ident[0] != ELFMAG0 ||
293
        e_ident[1] != ELFMAG1 ||
294
        e_ident[2] != ELFMAG2 ||
295
        e_ident[3] != ELFMAG3)
296
        goto fail;
297
#ifdef HOST_WORDS_BIGENDIAN
298
    data_order = ELFDATA2MSB;
299
#else
300
    data_order = ELFDATA2LSB;
301
#endif
302
    must_swab = data_order != e_ident[EI_DATA];
303
    if (big_endian) {
304
        target_data_order = ELFDATA2MSB;
305
    } else {
306
        target_data_order = ELFDATA2LSB;
307
    }
308

    
309
    if (target_data_order != e_ident[EI_DATA])
310
        return -1;
311

    
312
    lseek(fd, 0, SEEK_SET);
313
    if (e_ident[EI_CLASS] == ELFCLASS64) {
314
        ret = load_elf64(filename, fd, address_offset, must_swab, pentry,
315
                         lowaddr, highaddr, elf_machine, clear_lsb);
316
    } else {
317
        ret = load_elf32(filename, fd, address_offset, must_swab, pentry,
318
                         lowaddr, highaddr, elf_machine, clear_lsb);
319
    }
320

    
321
    close(fd);
322
    return ret;
323

    
324
 fail:
325
    close(fd);
326
    return -1;
327
}
328

    
329
static void bswap_uboot_header(uboot_image_header_t *hdr)
330
{
331
#ifndef HOST_WORDS_BIGENDIAN
332
    bswap32s(&hdr->ih_magic);
333
    bswap32s(&hdr->ih_hcrc);
334
    bswap32s(&hdr->ih_time);
335
    bswap32s(&hdr->ih_size);
336
    bswap32s(&hdr->ih_load);
337
    bswap32s(&hdr->ih_ep);
338
    bswap32s(&hdr->ih_dcrc);
339
#endif
340
}
341

    
342

    
343
#define ZALLOC_ALIGNMENT        16
344

    
345
static void *zalloc(void *x, unsigned items, unsigned size)
346
{
347
    void *p;
348

    
349
    size *= items;
350
    size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
351

    
352
    p = qemu_malloc(size);
353

    
354
    return (p);
355
}
356

    
357
static void zfree(void *x, void *addr)
358
{
359
    qemu_free(addr);
360
}
361

    
362

    
363
#define HEAD_CRC        2
364
#define EXTRA_FIELD        4
365
#define ORIG_NAME        8
366
#define COMMENT                0x10
367
#define RESERVED        0xe0
368

    
369
#define DEFLATED        8
370

    
371
/* This is the maximum in uboot, so if a uImage overflows this, it would
372
 * overflow on real hardware too. */
373
#define UBOOT_MAX_GUNZIP_BYTES 0x800000
374

    
375
static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src,
376
                      size_t srclen)
377
{
378
    z_stream s;
379
    ssize_t dstbytes;
380
    int r, i, flags;
381

    
382
    /* skip header */
383
    i = 10;
384
    flags = src[3];
385
    if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
386
        puts ("Error: Bad gzipped data\n");
387
        return -1;
388
    }
389
    if ((flags & EXTRA_FIELD) != 0)
390
        i = 12 + src[10] + (src[11] << 8);
391
    if ((flags & ORIG_NAME) != 0)
392
        while (src[i++] != 0)
393
            ;
394
    if ((flags & COMMENT) != 0)
395
        while (src[i++] != 0)
396
            ;
397
    if ((flags & HEAD_CRC) != 0)
398
        i += 2;
399
    if (i >= srclen) {
400
        puts ("Error: gunzip out of data in header\n");
401
        return -1;
402
    }
403

    
404
    s.zalloc = zalloc;
405
    s.zfree = zfree;
406

    
407
    r = inflateInit2(&s, -MAX_WBITS);
408
    if (r != Z_OK) {
409
        printf ("Error: inflateInit2() returned %d\n", r);
410
        return (-1);
411
    }
412
    s.next_in = src + i;
413
    s.avail_in = srclen - i;
414
    s.next_out = dst;
415
    s.avail_out = dstlen;
416
    r = inflate(&s, Z_FINISH);
417
    if (r != Z_OK && r != Z_STREAM_END) {
418
        printf ("Error: inflate() returned %d\n", r);
419
        return -1;
420
    }
421
    dstbytes = s.next_out - (unsigned char *) dst;
422
    inflateEnd(&s);
423

    
424
    return dstbytes;
425
}
426

    
427
/* Load a U-Boot image.  */
428
int load_uimage(const char *filename, target_phys_addr_t *ep,
429
                target_phys_addr_t *loadaddr, int *is_linux)
430
{
431
    int fd;
432
    int size;
433
    uboot_image_header_t h;
434
    uboot_image_header_t *hdr = &h;
435
    uint8_t *data = NULL;
436
    int ret = -1;
437

    
438
    fd = open(filename, O_RDONLY | O_BINARY);
439
    if (fd < 0)
440
        return -1;
441

    
442
    size = read(fd, hdr, sizeof(uboot_image_header_t));
443
    if (size < 0)
444
        goto out;
445

    
446
    bswap_uboot_header(hdr);
447

    
448
    if (hdr->ih_magic != IH_MAGIC)
449
        goto out;
450

    
451
    /* TODO: Implement other image types.  */
452
    if (hdr->ih_type != IH_TYPE_KERNEL) {
453
        fprintf(stderr, "Can only load u-boot image type \"kernel\"\n");
454
        goto out;
455
    }
456

    
457
    switch (hdr->ih_comp) {
458
    case IH_COMP_NONE:
459
    case IH_COMP_GZIP:
460
        break;
461
    default:
462
        fprintf(stderr,
463
                "Unable to load u-boot images with compression type %d\n",
464
                hdr->ih_comp);
465
        goto out;
466
    }
467

    
468
    /* TODO: Check CPU type.  */
469
    if (is_linux) {
470
        if (hdr->ih_os == IH_OS_LINUX)
471
            *is_linux = 1;
472
        else
473
            *is_linux = 0;
474
    }
475

    
476
    *ep = hdr->ih_ep;
477
    data = qemu_malloc(hdr->ih_size);
478

    
479
    if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
480
        fprintf(stderr, "Error reading file\n");
481
        goto out;
482
    }
483

    
484
    if (hdr->ih_comp == IH_COMP_GZIP) {
485
        uint8_t *compressed_data;
486
        size_t max_bytes;
487
        ssize_t bytes;
488

    
489
        compressed_data = data;
490
        max_bytes = UBOOT_MAX_GUNZIP_BYTES;
491
        data = qemu_malloc(max_bytes);
492

    
493
        bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
494
        qemu_free(compressed_data);
495
        if (bytes < 0) {
496
            fprintf(stderr, "Unable to decompress gzipped image!\n");
497
            goto out;
498
        }
499
        hdr->ih_size = bytes;
500
    }
501

    
502
    rom_add_blob_fixed(filename, data, hdr->ih_size, hdr->ih_load);
503

    
504
    if (loadaddr)
505
        *loadaddr = hdr->ih_load;
506

    
507
    ret = hdr->ih_size;
508

    
509
out:
510
    if (data)
511
        qemu_free(data);
512
    close(fd);
513
    return ret;
514
}
515

    
516
/*
517
 * Functions for reboot-persistent memory regions.
518
 *  - used for vga bios and option roms.
519
 *  - also linux kernel (-kernel / -initrd).
520
 */
521

    
522
typedef struct Rom Rom;
523

    
524
struct Rom {
525
    char *name;
526
    char *path;
527
    size_t romsize;
528
    uint8_t *data;
529
    int align;
530
    int isrom;
531

    
532
    target_phys_addr_t min;
533
    target_phys_addr_t max;
534
    target_phys_addr_t addr;
535
    QTAILQ_ENTRY(Rom) next;
536
};
537

    
538
static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms);
539
int rom_enable_driver_roms;
540

    
541
static void rom_insert(Rom *rom)
542
{
543
    Rom *item;
544

    
545
    if (roms_loaded) {
546
        hw_error ("ROM images must be loaded at startup\n");
547
    }
548

    
549
    /* list is ordered by load address */
550
    QTAILQ_FOREACH(item, &roms, next) {
551
        if (rom->min >= item->min)
552
            continue;
553
        QTAILQ_INSERT_BEFORE(item, rom, next);
554
        return;
555
    }
556
    QTAILQ_INSERT_TAIL(&roms, rom, next);
557
}
558

    
559
int rom_add_file(const char *file,
560
                 target_phys_addr_t min, target_phys_addr_t max, int align)
561
{
562
    Rom *rom;
563
    int rc, fd = -1;
564

    
565
    rom = qemu_mallocz(sizeof(*rom));
566
    rom->name = qemu_strdup(file);
567
    rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name);
568
    if (rom->path == NULL) {
569
        rom->path = qemu_strdup(file);
570
    }
571

    
572
    fd = open(rom->path, O_RDONLY | O_BINARY);
573
    if (fd == -1) {
574
        fprintf(stderr, "Could not open option rom '%s': %s\n",
575
                rom->path, strerror(errno));
576
        goto err;
577
    }
578

    
579
    rom->align   = align;
580
    rom->min     = min;
581
    rom->max     = max;
582
    rom->romsize = lseek(fd, 0, SEEK_END);
583
    rom->data    = qemu_mallocz(rom->romsize);
584
    lseek(fd, 0, SEEK_SET);
585
    rc = read(fd, rom->data, rom->romsize);
586
    if (rc != rom->romsize) {
587
        fprintf(stderr, "rom: file %-20s: read error: rc=%d (expected %zd)\n",
588
                rom->name, rc, rom->romsize);
589
        goto err;
590
    }
591
    close(fd);
592
    rom_insert(rom);
593
    return 0;
594

    
595
err:
596
    if (fd != -1)
597
        close(fd);
598
    qemu_free(rom->data);
599
    qemu_free(rom->path);
600
    qemu_free(rom->name);
601
    qemu_free(rom);
602
    return -1;
603
}
604

    
605
int rom_add_blob(const char *name, const void *blob, size_t len,
606
                 target_phys_addr_t min, target_phys_addr_t max, int align)
607
{
608
    Rom *rom;
609

    
610
    rom = qemu_mallocz(sizeof(*rom));
611
    rom->name    = qemu_strdup(name);
612
    rom->align   = align;
613
    rom->min     = min;
614
    rom->max     = max;
615
    rom->romsize = len;
616
    rom->data    = qemu_mallocz(rom->romsize);
617
    memcpy(rom->data, blob, len);
618
    rom_insert(rom);
619
    return 0;
620
}
621

    
622
int rom_add_vga(const char *file)
623
{
624
    if (!rom_enable_driver_roms)
625
        return 0;
626
    return rom_add_file(file, PC_ROM_MIN_VGA, PC_ROM_MAX, PC_ROM_ALIGN);
627
}
628

    
629
int rom_add_option(const char *file)
630
{
631
    if (!rom_enable_driver_roms)
632
        return 0;
633
    return rom_add_file(file, PC_ROM_MIN_OPTION, PC_ROM_MAX, PC_ROM_ALIGN);
634
}
635

    
636
static void rom_reset(void *unused)
637
{
638
    Rom *rom;
639

    
640
    QTAILQ_FOREACH(rom, &roms, next) {
641
        if (rom->data == NULL)
642
            continue;
643
        cpu_physical_memory_write_rom(rom->addr, rom->data, rom->romsize);
644
        if (rom->isrom) {
645
            /* rom needs to be written only once */
646
            qemu_free(rom->data);
647
            rom->data = NULL;
648
        }
649
    }
650
}
651

    
652
int rom_load_all(void)
653
{
654
    target_phys_addr_t addr = 0;
655
    int memtype;
656
    Rom *rom;
657

    
658
    QTAILQ_FOREACH(rom, &roms, next) {
659
        if (addr < rom->min)
660
            addr = rom->min;
661
        if (rom->max) {
662
            /* load address range */
663
            if (rom->align) {
664
                addr += (rom->align-1);
665
                addr &= ~(rom->align-1);
666
            }
667
            if (addr + rom->romsize > rom->max) {
668
                fprintf(stderr, "rom: out of memory (rom %s, "
669
                        "addr 0x" TARGET_FMT_plx
670
                        ", size 0x%zx, max 0x" TARGET_FMT_plx ")\n",
671
                        rom->name, addr, rom->romsize, rom->max);
672
                return -1;
673
            }
674
        } else {
675
            /* fixed address requested */
676
            if (addr != rom->min) {
677
                fprintf(stderr, "rom: requested regions overlap "
678
                        "(rom %s. free=0x" TARGET_FMT_plx
679
                        ", addr=0x" TARGET_FMT_plx ")\n",
680
                        rom->name, addr, rom->min);
681
                return -1;
682
            }
683
        }
684
        rom->addr = addr;
685
        addr += rom->romsize;
686
        memtype = cpu_get_physical_page_desc(rom->addr) & (3 << IO_MEM_SHIFT);
687
        if (memtype == IO_MEM_ROM)
688
            rom->isrom = 1;
689
    }
690
    qemu_register_reset(rom_reset, NULL);
691
    roms_loaded = 1;
692
    return 0;
693
}
694

    
695
static Rom *find_rom(target_phys_addr_t addr)
696
{
697
    Rom *rom;
698

    
699
    QTAILQ_FOREACH(rom, &roms, next) {
700
        if (rom->max)
701
            continue;
702
        if (rom->min > addr)
703
            continue;
704
        if (rom->min + rom->romsize < addr)
705
            continue;
706
        return rom;
707
    }
708
    return NULL;
709
}
710

    
711
int rom_copy(uint8_t *dest, target_phys_addr_t addr, size_t size)
712
{
713
    target_phys_addr_t end = addr + size;
714
    uint8_t *s, *d = dest;
715
    size_t l = 0;
716
    Rom *rom;
717

    
718
    QTAILQ_FOREACH(rom, &roms, next) {
719
        if (rom->max)
720
            continue;
721
        if (rom->min > addr)
722
            continue;
723
        if (rom->min + rom->romsize < addr)
724
            continue;
725
        if (rom->min > end)
726
            break;
727
        if (!rom->data)
728
            continue;
729

    
730
        d = dest + (rom->min - addr);
731
        s = rom->data;
732
        l = rom->romsize;
733

    
734
        if (rom->min < addr) {
735
            d = dest;
736
            s += (addr - rom->min);
737
            l -= (addr - rom->min);
738
        }
739
        if ((d + l) > (dest + size)) {
740
            l = dest - d;
741
        }
742

    
743
        memcpy(d, s, l);
744
    }
745

    
746
    return (d + l) - dest;
747
}
748

    
749
void *rom_ptr(target_phys_addr_t addr)
750
{
751
    Rom *rom;
752

    
753
    rom = find_rom(addr);
754
    if (!rom || !rom->data)
755
        return NULL;
756
    return rom->data + (addr - rom->min);
757
}
758

    
759
void do_info_roms(Monitor *mon)
760
{
761
    Rom *rom;
762

    
763
    QTAILQ_FOREACH(rom, &roms, next) {
764
        monitor_printf(mon, "addr=" TARGET_FMT_plx
765
                       " size=0x%06zx mem=%s name=\"%s\" \n",
766
                       rom->addr, rom->romsize,
767
                       rom->isrom ? "rom" : "ram",
768
                       rom->name);
769
    }
770
}