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