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