]>
Commit | Line | Data |
---|---|---|
52001445 AL |
1 | /* |
2 | * QEMU PC System Emulator | |
3 | * | |
4 | * Copyright (c) 2003-2004 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 | ||
b6a0aa05 | 25 | #include "qemu/osdep.h" |
4771d756 PB |
26 | #include "qemu-common.h" |
27 | #include "cpu.h" | |
83c9f4ca | 28 | #include "hw/hw.h" |
0d09e41a | 29 | #include "hw/nvram/fw_cfg.h" |
47b43a1f | 30 | #include "multiboot.h" |
83c9f4ca | 31 | #include "hw/loader.h" |
52001445 | 32 | #include "elf.h" |
9c17d615 | 33 | #include "sysemu/sysemu.h" |
52001445 AL |
34 | |
35 | /* Show multiboot debug output */ | |
36 | //#define DEBUG_MULTIBOOT | |
37 | ||
38 | #ifdef DEBUG_MULTIBOOT | |
39 | #define mb_debug(a...) fprintf(stderr, ## a) | |
40 | #else | |
41 | #define mb_debug(a...) | |
42 | #endif | |
43 | ||
44 | #define MULTIBOOT_STRUCT_ADDR 0x9000 | |
45 | ||
46 | #if MULTIBOOT_STRUCT_ADDR > 0xf0000 | |
47 | #error multiboot struct needs to fit in 16 bit real mode | |
48 | #endif | |
49 | ||
50 | enum { | |
51 | /* Multiboot info */ | |
52 | MBI_FLAGS = 0, | |
53 | MBI_MEM_LOWER = 4, | |
54 | MBI_MEM_UPPER = 8, | |
55 | MBI_BOOT_DEVICE = 12, | |
56 | MBI_CMDLINE = 16, | |
57 | MBI_MODS_COUNT = 20, | |
58 | MBI_MODS_ADDR = 24, | |
59 | MBI_MMAP_ADDR = 48, | |
5eba5a66 | 60 | MBI_BOOTLOADER = 64, |
52001445 AL |
61 | |
62 | MBI_SIZE = 88, | |
63 | ||
64 | /* Multiboot modules */ | |
65 | MB_MOD_START = 0, | |
66 | MB_MOD_END = 4, | |
67 | MB_MOD_CMDLINE = 8, | |
68 | ||
69 | MB_MOD_SIZE = 16, | |
70 | ||
71 | /* Region offsets */ | |
72 | ADDR_E820_MAP = MULTIBOOT_STRUCT_ADDR + 0, | |
73 | ADDR_MBI = ADDR_E820_MAP + 0x500, | |
74 | ||
75 | /* Multiboot flags */ | |
76 | MULTIBOOT_FLAGS_MEMORY = 1 << 0, | |
77 | MULTIBOOT_FLAGS_BOOT_DEVICE = 1 << 1, | |
78 | MULTIBOOT_FLAGS_CMDLINE = 1 << 2, | |
79 | MULTIBOOT_FLAGS_MODULES = 1 << 3, | |
80 | MULTIBOOT_FLAGS_MMAP = 1 << 6, | |
5eba5a66 | 81 | MULTIBOOT_FLAGS_BOOTLOADER = 1 << 9, |
52001445 AL |
82 | }; |
83 | ||
84 | typedef struct { | |
85 | /* buffer holding kernel, cmdlines and mb_infos */ | |
86 | void *mb_buf; | |
87 | /* address in target */ | |
a8170e5e | 88 | hwaddr mb_buf_phys; |
52001445 AL |
89 | /* size of mb_buf in bytes */ |
90 | unsigned mb_buf_size; | |
91 | /* offset of mb-info's in bytes */ | |
a8170e5e | 92 | hwaddr offset_mbinfo; |
52001445 | 93 | /* offset in buffer for cmdlines in bytes */ |
a8170e5e | 94 | hwaddr offset_cmdlines; |
5eba5a66 DD |
95 | /* offset in buffer for bootloader name in bytes */ |
96 | hwaddr offset_bootloader; | |
52001445 | 97 | /* offset of modules in bytes */ |
a8170e5e | 98 | hwaddr offset_mods; |
52001445 AL |
99 | /* available slots for mb modules infos */ |
100 | int mb_mods_avail; | |
101 | /* currently used slots of mb modules */ | |
102 | int mb_mods_count; | |
103 | } MultibootState; | |
104 | ||
5eba5a66 DD |
105 | const char *bootloader_name = "qemu"; |
106 | ||
52001445 AL |
107 | static uint32_t mb_add_cmdline(MultibootState *s, const char *cmdline) |
108 | { | |
a8170e5e | 109 | hwaddr p = s->offset_cmdlines; |
49e40b66 | 110 | char *b = (char *)s->mb_buf + p; |
52001445 | 111 | |
49e40b66 AL |
112 | get_opt_value(b, strlen(cmdline) + 1, cmdline); |
113 | s->offset_cmdlines += strlen(b) + 1; | |
52001445 AL |
114 | return s->mb_buf_phys + p; |
115 | } | |
116 | ||
5eba5a66 DD |
117 | static uint32_t mb_add_bootloader(MultibootState *s, const char *bootloader) |
118 | { | |
119 | hwaddr p = s->offset_bootloader; | |
120 | char *b = (char *)s->mb_buf + p; | |
121 | ||
122 | memcpy(b, bootloader, strlen(bootloader) + 1); | |
123 | s->offset_bootloader += strlen(b) + 1; | |
124 | return s->mb_buf_phys + p; | |
125 | } | |
126 | ||
52001445 | 127 | static void mb_add_mod(MultibootState *s, |
a8170e5e AK |
128 | hwaddr start, hwaddr end, |
129 | hwaddr cmdline_phys) | |
52001445 AL |
130 | { |
131 | char *p; | |
132 | assert(s->mb_mods_count < s->mb_mods_avail); | |
133 | ||
134 | p = (char *)s->mb_buf + s->offset_mbinfo + MB_MOD_SIZE * s->mb_mods_count; | |
135 | ||
136 | stl_p(p + MB_MOD_START, start); | |
137 | stl_p(p + MB_MOD_END, end); | |
138 | stl_p(p + MB_MOD_CMDLINE, cmdline_phys); | |
139 | ||
bd418d90 IY |
140 | mb_debug("mod%02d: "TARGET_FMT_plx" - "TARGET_FMT_plx"\n", |
141 | s->mb_mods_count, start, end); | |
52001445 AL |
142 | |
143 | s->mb_mods_count++; | |
144 | } | |
145 | ||
a88b362c | 146 | int load_multiboot(FWCfgState *fw_cfg, |
52001445 AL |
147 | FILE *f, |
148 | const char *kernel_filename, | |
149 | const char *initrd_filename, | |
150 | const char *kernel_cmdline, | |
151 | int kernel_file_size, | |
152 | uint8_t *header) | |
153 | { | |
154 | int i, is_multiboot = 0; | |
155 | uint32_t flags = 0; | |
156 | uint32_t mh_entry_addr; | |
157 | uint32_t mh_load_addr; | |
158 | uint32_t mb_kernel_size; | |
159 | MultibootState mbs; | |
160 | uint8_t bootinfo[MBI_SIZE]; | |
161 | uint8_t *mb_bootinfo_data; | |
b4168498 | 162 | uint32_t cmdline_len; |
52001445 AL |
163 | |
164 | /* Ok, let's see if it is a multiboot image. | |
165 | The header is 12x32bit long, so the latest entry may be 8192 - 48. */ | |
166 | for (i = 0; i < (8192 - 48); i += 4) { | |
167 | if (ldl_p(header+i) == 0x1BADB002) { | |
168 | uint32_t checksum = ldl_p(header+i+8); | |
169 | flags = ldl_p(header+i+4); | |
170 | checksum += flags; | |
171 | checksum += (uint32_t)0x1BADB002; | |
172 | if (!checksum) { | |
173 | is_multiboot = 1; | |
174 | break; | |
175 | } | |
176 | } | |
177 | } | |
178 | ||
179 | if (!is_multiboot) | |
180 | return 0; /* no multiboot */ | |
181 | ||
182 | mb_debug("qemu: I believe we found a multiboot image!\n"); | |
183 | memset(bootinfo, 0, sizeof(bootinfo)); | |
184 | memset(&mbs, 0, sizeof(mbs)); | |
185 | ||
186 | if (flags & 0x00000004) { /* MULTIBOOT_HEADER_HAS_VBE */ | |
187 | fprintf(stderr, "qemu: multiboot knows VBE. we don't.\n"); | |
188 | } | |
189 | if (!(flags & 0x00010000)) { /* MULTIBOOT_HEADER_HAS_ADDR */ | |
190 | uint64_t elf_entry; | |
191 | uint64_t elf_low, elf_high; | |
192 | int kernel_size; | |
193 | fclose(f); | |
96968466 AL |
194 | |
195 | if (((struct elf64_hdr*)header)->e_machine == EM_X86_64) { | |
196 | fprintf(stderr, "Cannot load x86-64 image, give a 32bit one.\n"); | |
197 | exit(1); | |
198 | } | |
199 | ||
409dbce5 | 200 | kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry, |
7ef295ea PC |
201 | &elf_low, &elf_high, 0, I386_ELF_MACHINE, |
202 | 0, 0); | |
52001445 AL |
203 | if (kernel_size < 0) { |
204 | fprintf(stderr, "Error while loading elf kernel\n"); | |
205 | exit(1); | |
206 | } | |
207 | mh_load_addr = elf_low; | |
208 | mb_kernel_size = elf_high - elf_low; | |
209 | mh_entry_addr = elf_entry; | |
210 | ||
7267c094 | 211 | mbs.mb_buf = g_malloc(mb_kernel_size); |
52001445 AL |
212 | if (rom_copy(mbs.mb_buf, mh_load_addr, mb_kernel_size) != mb_kernel_size) { |
213 | fprintf(stderr, "Error while fetching elf kernel from rom\n"); | |
214 | exit(1); | |
215 | } | |
216 | ||
217 | mb_debug("qemu: loading multiboot-elf kernel (%#x bytes) with entry %#zx\n", | |
218 | mb_kernel_size, (size_t)mh_entry_addr); | |
219 | } else { | |
220 | /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */ | |
221 | uint32_t mh_header_addr = ldl_p(header+i+12); | |
6b8273a1 GW |
222 | uint32_t mh_load_end_addr = ldl_p(header+i+20); |
223 | uint32_t mh_bss_end_addr = ldl_p(header+i+24); | |
52001445 AL |
224 | mh_load_addr = ldl_p(header+i+16); |
225 | uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr); | |
9c3a596a | 226 | uint32_t mb_load_size = 0; |
52001445 | 227 | mh_entry_addr = ldl_p(header+i+28); |
9c3a596a SM |
228 | |
229 | if (mh_load_end_addr) { | |
230 | mb_kernel_size = mh_bss_end_addr - mh_load_addr; | |
231 | mb_load_size = mh_load_end_addr - mh_load_addr; | |
232 | } else { | |
233 | mb_kernel_size = kernel_file_size - mb_kernel_text_offset; | |
234 | mb_load_size = mb_kernel_size; | |
235 | } | |
52001445 AL |
236 | |
237 | /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_VBE. | |
238 | uint32_t mh_mode_type = ldl_p(header+i+32); | |
239 | uint32_t mh_width = ldl_p(header+i+36); | |
240 | uint32_t mh_height = ldl_p(header+i+40); | |
241 | uint32_t mh_depth = ldl_p(header+i+44); */ | |
242 | ||
243 | mb_debug("multiboot: mh_header_addr = %#x\n", mh_header_addr); | |
244 | mb_debug("multiboot: mh_load_addr = %#x\n", mh_load_addr); | |
6b8273a1 GW |
245 | mb_debug("multiboot: mh_load_end_addr = %#x\n", mh_load_end_addr); |
246 | mb_debug("multiboot: mh_bss_end_addr = %#x\n", mh_bss_end_addr); | |
52001445 | 247 | mb_debug("qemu: loading multiboot kernel (%#x bytes) at %#x\n", |
6b8273a1 | 248 | mb_load_size, mh_load_addr); |
52001445 | 249 | |
7267c094 | 250 | mbs.mb_buf = g_malloc(mb_kernel_size); |
52001445 | 251 | fseek(f, mb_kernel_text_offset, SEEK_SET); |
6b8273a1 | 252 | if (fread(mbs.mb_buf, 1, mb_load_size, f) != mb_load_size) { |
52001445 AL |
253 | fprintf(stderr, "fread() failed\n"); |
254 | exit(1); | |
255 | } | |
6b8273a1 | 256 | memset(mbs.mb_buf + mb_load_size, 0, mb_kernel_size - mb_load_size); |
52001445 AL |
257 | fclose(f); |
258 | } | |
259 | ||
260 | mbs.mb_buf_phys = mh_load_addr; | |
261 | ||
262 | mbs.mb_buf_size = TARGET_PAGE_ALIGN(mb_kernel_size); | |
263 | mbs.offset_mbinfo = mbs.mb_buf_size; | |
264 | ||
5eba5a66 | 265 | /* Calculate space for cmdlines, bootloader name, and mb_mods */ |
b4168498 KW |
266 | cmdline_len = strlen(kernel_filename) + 1; |
267 | cmdline_len += strlen(kernel_cmdline) + 1; | |
52001445 AL |
268 | if (initrd_filename) { |
269 | const char *r = initrd_filename; | |
b4168498 | 270 | cmdline_len += strlen(r) + 1; |
52001445 | 271 | mbs.mb_mods_avail = 1; |
49e40b66 | 272 | while (*(r = get_opt_value(NULL, 0, r))) { |
52001445 AL |
273 | mbs.mb_mods_avail++; |
274 | r++; | |
275 | } | |
52001445 AL |
276 | } |
277 | ||
b4168498 KW |
278 | mbs.mb_buf_size += cmdline_len; |
279 | mbs.mb_buf_size += MB_MOD_SIZE * mbs.mb_mods_avail; | |
280 | mbs.mb_buf_size += strlen(bootloader_name) + 1; | |
281 | ||
52001445 AL |
282 | mbs.mb_buf_size = TARGET_PAGE_ALIGN(mbs.mb_buf_size); |
283 | ||
5eba5a66 DD |
284 | /* enlarge mb_buf to hold cmdlines, bootloader, mb-info structs */ |
285 | mbs.mb_buf = g_realloc(mbs.mb_buf, mbs.mb_buf_size); | |
286 | mbs.offset_cmdlines = mbs.offset_mbinfo + mbs.mb_mods_avail * MB_MOD_SIZE; | |
b4168498 | 287 | mbs.offset_bootloader = mbs.offset_cmdlines + cmdline_len; |
52001445 AL |
288 | |
289 | if (initrd_filename) { | |
49e40b66 | 290 | char *next_initrd, not_last; |
52001445 AL |
291 | |
292 | mbs.offset_mods = mbs.mb_buf_size; | |
293 | ||
294 | do { | |
295 | char *next_space; | |
37a05af0 | 296 | int mb_mod_length; |
52001445 AL |
297 | uint32_t offs = mbs.mb_buf_size; |
298 | ||
49e40b66 AL |
299 | next_initrd = (char *)get_opt_value(NULL, 0, initrd_filename); |
300 | not_last = *next_initrd; | |
301 | *next_initrd = '\0'; | |
52001445 AL |
302 | /* if a space comes after the module filename, treat everything |
303 | after that as parameters */ | |
a8170e5e | 304 | hwaddr c = mb_add_cmdline(&mbs, initrd_filename); |
52001445 AL |
305 | if ((next_space = strchr(initrd_filename, ' '))) |
306 | *next_space = '\0'; | |
307 | mb_debug("multiboot loading module: %s\n", initrd_filename); | |
308 | mb_mod_length = get_image_size(initrd_filename); | |
309 | if (mb_mod_length < 0) { | |
f95857b3 | 310 | fprintf(stderr, "Failed to open file '%s'\n", initrd_filename); |
52001445 AL |
311 | exit(1); |
312 | } | |
313 | ||
314 | mbs.mb_buf_size = TARGET_PAGE_ALIGN(mb_mod_length + mbs.mb_buf_size); | |
7267c094 | 315 | mbs.mb_buf = g_realloc(mbs.mb_buf, mbs.mb_buf_size); |
52001445 AL |
316 | |
317 | load_image(initrd_filename, (unsigned char *)mbs.mb_buf + offs); | |
318 | mb_add_mod(&mbs, mbs.mb_buf_phys + offs, | |
319 | mbs.mb_buf_phys + offs + mb_mod_length, c); | |
320 | ||
bd418d90 | 321 | mb_debug("mod_start: %p\nmod_end: %p\n cmdline: "TARGET_FMT_plx"\n", |
52001445 AL |
322 | (char *)mbs.mb_buf + offs, |
323 | (char *)mbs.mb_buf + offs + mb_mod_length, c); | |
324 | initrd_filename = next_initrd+1; | |
49e40b66 | 325 | } while (not_last); |
52001445 AL |
326 | } |
327 | ||
328 | /* Commandline support */ | |
329 | char kcmdline[strlen(kernel_filename) + strlen(kernel_cmdline) + 2]; | |
330 | snprintf(kcmdline, sizeof(kcmdline), "%s %s", | |
331 | kernel_filename, kernel_cmdline); | |
332 | stl_p(bootinfo + MBI_CMDLINE, mb_add_cmdline(&mbs, kcmdline)); | |
333 | ||
5eba5a66 DD |
334 | stl_p(bootinfo + MBI_BOOTLOADER, mb_add_bootloader(&mbs, bootloader_name)); |
335 | ||
52001445 AL |
336 | stl_p(bootinfo + MBI_MODS_ADDR, mbs.mb_buf_phys + mbs.offset_mbinfo); |
337 | stl_p(bootinfo + MBI_MODS_COUNT, mbs.mb_mods_count); /* mods_count */ | |
338 | ||
339 | /* the kernel is where we want it to be now */ | |
340 | stl_p(bootinfo + MBI_FLAGS, MULTIBOOT_FLAGS_MEMORY | |
341 | | MULTIBOOT_FLAGS_BOOT_DEVICE | |
342 | | MULTIBOOT_FLAGS_CMDLINE | |
343 | | MULTIBOOT_FLAGS_MODULES | |
5eba5a66 DD |
344 | | MULTIBOOT_FLAGS_MMAP |
345 | | MULTIBOOT_FLAGS_BOOTLOADER); | |
c83066d4 | 346 | stl_p(bootinfo + MBI_BOOT_DEVICE, 0x8000ffff); /* XXX: use the -boot switch? */ |
52001445 AL |
347 | stl_p(bootinfo + MBI_MMAP_ADDR, ADDR_E820_MAP); |
348 | ||
349 | mb_debug("multiboot: mh_entry_addr = %#x\n", mh_entry_addr); | |
bd418d90 IY |
350 | mb_debug(" mb_buf_phys = "TARGET_FMT_plx"\n", mbs.mb_buf_phys); |
351 | mb_debug(" mod_start = "TARGET_FMT_plx"\n", mbs.mb_buf_phys + mbs.offset_mods); | |
52001445 AL |
352 | mb_debug(" mb_mods_count = %d\n", mbs.mb_mods_count); |
353 | ||
354 | /* save bootinfo off the stack */ | |
7267c094 | 355 | mb_bootinfo_data = g_malloc(sizeof(bootinfo)); |
52001445 AL |
356 | memcpy(mb_bootinfo_data, bootinfo, sizeof(bootinfo)); |
357 | ||
358 | /* Pass variables to option rom */ | |
359 | fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ENTRY, mh_entry_addr); | |
360 | fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, mh_load_addr); | |
361 | fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, mbs.mb_buf_size); | |
362 | fw_cfg_add_bytes(fw_cfg, FW_CFG_KERNEL_DATA, | |
363 | mbs.mb_buf, mbs.mb_buf_size); | |
364 | ||
365 | fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, ADDR_MBI); | |
366 | fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, sizeof(bootinfo)); | |
367 | fw_cfg_add_bytes(fw_cfg, FW_CFG_INITRD_DATA, mb_bootinfo_data, | |
368 | sizeof(bootinfo)); | |
369 | ||
2e55e842 GN |
370 | option_rom[nb_option_roms].name = "multiboot.bin"; |
371 | option_rom[nb_option_roms].bootindex = 0; | |
52001445 AL |
372 | nb_option_roms++; |
373 | ||
374 | return 1; /* yes, we are multiboot */ | |
375 | } |