Revision 3c178e72

b/hw/axis_dev88.c
365 365
            /* Let the kernel know we are modifying the cmdline.  */
366 366
            env->regs[10] = 0x87109563;
367 367
            env->regs[11] = 0x40000000;
368
            pstrcpy_targphys(env->regs[11], 256, kernel_cmdline);
368
            pstrcpy_targphys("cmdline", env->regs[11], 256, kernel_cmdline);
369 369
        }
370 370
    }
371 371
    env->pc = bootstrap_pc;
b/hw/etraxfs.c
157 157
            /* Let the kernel know we are modifying the cmdline.  */
158 158
            env->regs[10] = 0x87109563;
159 159
            env->regs[11] = 0x40000000;
160
            pstrcpy_targphys(env->regs[11], 256, kernel_cmdline);
160
            pstrcpy_targphys("cmdline", env->regs[11], 256, kernel_cmdline);
161 161
        }
162 162
    }
163 163
    env->pc = bootstrap_pc;
b/hw/loader.c
108 108
    return size;
109 109
}
110 110

  
111
void pstrcpy_targphys(target_phys_addr_t dest, int buf_size,
111
void pstrcpy_targphys(const char *name, target_phys_addr_t dest, int buf_size,
112 112
                      const char *source)
113 113
{
114
    static const uint8_t nul_byte = 0;
115 114
    const char *nulp;
115
    char *ptr;
116 116

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

  
......
672 672
    return 0;
673 673
}
674 674

  
675
static Rom *find_rom(target_phys_addr_t addr)
676
{
677
    Rom *rom;
678

  
679
    QTAILQ_FOREACH(rom, &roms, next) {
680
        if (rom->max)
681
            continue;
682
        if (rom->min > addr)
683
            continue;
684
        if (rom->min + rom->romsize < addr)
685
            continue;
686
        return rom;
687
    }
688
    return NULL;
689
}
690

  
691
void *rom_ptr(target_phys_addr_t addr)
692
{
693
    Rom *rom;
694

  
695
    rom = find_rom(addr);
696
    if (!rom || !rom->data)
697
        return NULL;
698
    return rom->data + (addr - rom->min);
699
}
700

  
675 701
void do_info_roms(Monitor *mon)
676 702
{
677 703
    Rom *rom;
b/hw/loader.h
15 15

  
16 16
int read_targphys(const char *name,
17 17
                  int fd, target_phys_addr_t dst_addr, size_t nbytes);
18
void pstrcpy_targphys(target_phys_addr_t dest, int buf_size,
18
void pstrcpy_targphys(const char *name,
19
                      target_phys_addr_t dest, int buf_size,
19 20
                      const char *source);
20 21

  
21 22
int rom_add_file(const char *file,
......
23 24
int rom_add_blob(const char *name, const void *blob, size_t len,
24 25
                 target_phys_addr_t min, target_phys_addr_t max, int align);
25 26
int rom_load_all(void);
27
void *rom_ptr(target_phys_addr_t addr);
26 28
void do_info_roms(Monitor *mon);
27 29

  
28 30
#define rom_add_file_fixed(_f, _a)              \
b/hw/mips_malta.c
679 679
    va_start(ap, string);
680 680
    vsnprintf(buf, ENVP_ENTRY_SIZE, string, ap);
681 681
    va_end(ap);
682
    pstrcpy_targphys(table_addr + VIRT_TO_PHYS_ADDEND, ENVP_ENTRY_SIZE, buf);
682
    pstrcpy_targphys("prom", table_addr + VIRT_TO_PHYS_ADDEND, ENVP_ENTRY_SIZE, buf);
683 683
}
684 684

  
685 685
/* Kernel */
b/hw/mips_r4k.c
130 130
    } else {
131 131
        ret = 0;
132 132
    }
133
    pstrcpy_targphys((16 << 20) - 256 + ret, 256,
133
    pstrcpy_targphys("cmdline", (16 << 20) - 256 + ret, 256,
134 134
                     loaderparams.kernel_cmdline);
135 135

  
136 136
    stl_phys((16 << 20) - 260, 0x12345678);
b/hw/pc.c
865 865
    	initrd_max = max_ram_size-ACPI_DATA_SIZE-1;
866 866

  
867 867
    /* kernel command line */
868
    rom_add_blob_fixed("linux-cmdline", kernel_cmdline,
868
    rom_add_blob_fixed("cmdline", kernel_cmdline,
869 869
                       strlen(kernel_cmdline)+1, cmdline_addr);
870 870

  
871 871
    if (protocol >= 0x202) {
b/hw/petalogix_s3adsp1800_mmu.c
176 176

  
177 177
        env->regs[5] = ddr_base + kernel_size;
178 178
        if (kernel_cmdline && (kcmdline_len = strlen(kernel_cmdline))) {
179
            pstrcpy_targphys(env->regs[5], 256, kernel_cmdline);
179
            pstrcpy_targphys("cmdline", env->regs[5], 256, kernel_cmdline);
180 180
        }
181 181
        env->regs[6] = 0;
182 182
        /* Provide a device-tree.  */
b/hw/ppc.c
1256 1256
    NVRAM_set_lword(nvram,  0x3C, kernel_size);
1257 1257
    if (cmdline) {
1258 1258
        /* XXX: put the cmdline in NVRAM too ? */
1259
        pstrcpy_targphys(CMDLINE_ADDR, RAM_size - CMDLINE_ADDR, cmdline);
1259
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, RAM_size - CMDLINE_ADDR, cmdline);
1260 1260
        NVRAM_set_lword(nvram,  0x40, CMDLINE_ADDR);
1261 1261
        NVRAM_set_lword(nvram,  0x44, strlen(cmdline));
1262 1262
    } else {
b/hw/ppc_newworld.c
364 364
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
365 365
    if (kernel_cmdline) {
366 366
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
367
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
367
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
368 368
    } else {
369 369
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
370 370
    }
b/hw/ppc_oldworld.c
384 384
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
385 385
    if (kernel_cmdline) {
386 386
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
387
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
387
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
388 388
    } else {
389 389
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
390 390
    }
b/hw/r2d.c
250 250
				   SDRAM_BASE + LINUX_LOAD_OFFSET,
251 251
				   SDRAM_SIZE - LINUX_LOAD_OFFSET);
252 252
          env->pc = (SDRAM_BASE + LINUX_LOAD_OFFSET) | 0xa0000000;
253
          pstrcpy_targphys(SDRAM_BASE + 0x10100, 256, kernel_cmdline);
253
          pstrcpy_targphys("cmdline", SDRAM_BASE + 0x10100, 256, kernel_cmdline);
254 254
      } else {
255 255
          kernel_size = load_image_targphys(kernel_filename, SDRAM_BASE, SDRAM_SIZE);
256 256
          env->pc = SDRAM_BASE | 0xa0000000; /* Start from P2 area */
b/hw/sun4m.c
299 299
    int linux_boot;
300 300
    unsigned int i;
301 301
    long initrd_size, kernel_size;
302
    uint8_t *ptr;
302 303

  
303 304
    linux_boot = (kernel_filename != NULL);
304 305

  
......
341 342
        }
342 343
        if (initrd_size > 0) {
343 344
            for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
344
                if (ldl_phys(KERNEL_LOAD_ADDR + i) == 0x48647253) { // HdrS
345
                    stl_phys(KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
346
                    stl_phys(KERNEL_LOAD_ADDR + i + 20, initrd_size);
345
                ptr = rom_ptr(KERNEL_LOAD_ADDR + i);
346
                if (ldl_p(ptr) == 0x48647253) { // HdrS
347
                    stl_p(ptr + 16, INITRD_LOAD_ADDR);
348
                    stl_p(ptr + 20, initrd_size);
347 349
                    break;
348 350
                }
349 351
            }
......
875 877
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
876 878
    if (kernel_cmdline) {
877 879
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
878
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
880
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
879 881
    } else {
880 882
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
881 883
    }
......
1457 1459
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
1458 1460
    if (kernel_cmdline) {
1459 1461
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
1460
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1462
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1461 1463
    } else {
1462 1464
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
1463 1465
    }
......
1645 1647
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
1646 1648
    if (kernel_cmdline) {
1647 1649
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
1648
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1650
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1649 1651
    } else {
1650 1652
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
1651 1653
    }
b/hw/sun4u.c
651 651
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
652 652
    if (kernel_cmdline) {
653 653
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
654
        pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
654
        pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
655 655
    } else {
656 656
        fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
657 657
    }

Also available in: Unified diff