![[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 / roms / ipxe / src / arch / i386 / image|
Return to multiboot.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / arch / i386 / image |
1.1 root 1: /*
2: * Copyright (C) 2007 Michael Brown <[email protected]>.
3: *
4: * This program is free software; you can redistribute it and/or
5: * modify it under the terms of the GNU General Public License as
6: * published by the Free Software Foundation; either version 2 of the
7: * License, or any later version.
8: *
9: * This program is distributed in the hope that it will be useful, but
10: * WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: * General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: /**
22: * @file
23: *
24: * Multiboot image format
25: *
26: */
27:
28: #include <stdio.h>
29: #include <errno.h>
30: #include <assert.h>
31: #include <realmode.h>
32: #include <multiboot.h>
33: #include <ipxe/uaccess.h>
34: #include <ipxe/image.h>
35: #include <ipxe/segment.h>
36: #include <ipxe/io.h>
37: #include <ipxe/elf.h>
38: #include <ipxe/init.h>
39: #include <ipxe/features.h>
40:
41: FEATURE ( FEATURE_IMAGE, "MBOOT", DHCP_EB_FEATURE_MULTIBOOT, 1 );
42:
43: /**
44: * Maximum number of modules we will allow for
45: *
46: * If this has bitten you: sorry. I did have a perfect scheme with a
47: * dynamically allocated list of modules on the protected-mode stack,
48: * but it was incompatible with some broken OSes that can only access
49: * low memory at boot time (even though we kindly set up 4GB flat
50: * physical addressing as per the multiboot specification.
51: *
52: */
53: #define MAX_MODULES 8
54:
55: /**
56: * Maximum combined length of command lines
57: *
58: * Again; sorry. Some broken OSes zero out any non-base memory that
59: * isn't part of the loaded module set, so we can't just use
60: * virt_to_phys(cmdline) to point to the command lines, even though
61: * this would comply with the Multiboot spec.
62: */
63: #define MB_MAX_CMDLINE 512
64:
65: /** Multiboot flags that we support */
66: #define MB_SUPPORTED_FLAGS ( MB_FLAG_PGALIGN | MB_FLAG_MEMMAP | \
67: MB_FLAG_VIDMODE | MB_FLAG_RAW )
68:
69: /** Compulsory feature multiboot flags */
70: #define MB_COMPULSORY_FLAGS 0x0000ffff
71:
72: /** Optional feature multiboot flags */
73: #define MB_OPTIONAL_FLAGS 0xffff0000
74:
75: /**
76: * Multiboot flags that we don't support
77: *
78: * We only care about the compulsory feature flags (bits 0-15); we are
79: * allowed to ignore the optional feature flags.
80: */
81: #define MB_UNSUPPORTED_FLAGS ( MB_COMPULSORY_FLAGS & ~MB_SUPPORTED_FLAGS )
82:
83: /** A multiboot header descriptor */
84: struct multiboot_header_info {
85: /** The actual multiboot header */
86: struct multiboot_header mb;
87: /** Offset of header within the multiboot image */
88: size_t offset;
89: };
90:
91: /** Multiboot module command lines */
92: static char __bss16_array ( mb_cmdlines, [MB_MAX_CMDLINE] );
93: #define mb_cmdlines __use_data16 ( mb_cmdlines )
94:
95: /** Offset within module command lines */
96: static unsigned int mb_cmdline_offset;
97:
98: /**
99: * Build multiboot memory map
100: *
101: * @v image Multiboot image
102: * @v mbinfo Multiboot information structure
103: * @v mbmemmap Multiboot memory map
104: * @v limit Maxmimum number of memory map entries
105: */
106: static void multiboot_build_memmap ( struct image *image,
107: struct multiboot_info *mbinfo,
108: struct multiboot_memory_map *mbmemmap,
109: unsigned int limit ) {
110: struct memory_map memmap;
111: unsigned int i;
112:
113: /* Get memory map */
114: get_memmap ( &memmap );
115:
116: /* Translate into multiboot format */
117: memset ( mbmemmap, 0, sizeof ( *mbmemmap ) );
118: for ( i = 0 ; i < memmap.count ; i++ ) {
119: if ( i >= limit ) {
120: DBGC ( image, "MULTIBOOT %p limit of %d memmap "
121: "entries reached\n", image, limit );
122: break;
123: }
124: mbmemmap[i].size = ( sizeof ( mbmemmap[i] ) -
125: sizeof ( mbmemmap[i].size ) );
126: mbmemmap[i].base_addr = memmap.regions[i].start;
127: mbmemmap[i].length = ( memmap.regions[i].end -
128: memmap.regions[i].start );
129: mbmemmap[i].type = MBMEM_RAM;
130: mbinfo->mmap_length += sizeof ( mbmemmap[i] );
131: if ( memmap.regions[i].start == 0 )
132: mbinfo->mem_lower = ( memmap.regions[i].end / 1024 );
133: if ( memmap.regions[i].start == 0x100000 )
134: mbinfo->mem_upper = ( ( memmap.regions[i].end -
135: 0x100000 ) / 1024 );
136: }
137: }
138:
139: /**
140: * Add command line in base memory
141: *
142: * @v imgname Image name
143: * @v cmdline Command line
144: * @ret physaddr Physical address of command line
145: */
146: physaddr_t multiboot_add_cmdline ( const char *imgname, const char *cmdline ) {
147: char *mb_cmdline;
148:
149: if ( ! cmdline )
150: cmdline = "";
151:
152: /* Copy command line to base memory buffer */
153: mb_cmdline = ( mb_cmdlines + mb_cmdline_offset );
154: mb_cmdline_offset +=
155: ( snprintf ( mb_cmdline,
156: ( sizeof ( mb_cmdlines ) - mb_cmdline_offset ),
157: "%s %s", imgname, cmdline ) + 1 );
158:
159: /* Truncate to terminating NUL in buffer if necessary */
160: if ( mb_cmdline_offset > sizeof ( mb_cmdlines ) )
161: mb_cmdline_offset = ( sizeof ( mb_cmdlines ) - 1 );
162:
163: return virt_to_phys ( mb_cmdline );
164: }
165:
166: /**
167: * Build multiboot module list
168: *
169: * @v image Multiboot image
170: * @v modules Module list to fill, or NULL
171: * @ret count Number of modules
172: */
173: static unsigned int
174: multiboot_build_module_list ( struct image *image,
175: struct multiboot_module *modules,
176: unsigned int limit ) {
177: struct image *module_image;
178: struct multiboot_module *module;
179: unsigned int count = 0;
180: unsigned int insert;
181: physaddr_t start;
182: physaddr_t end;
183: unsigned int i;
184:
185: /* Add each image as a multiboot module */
186: for_each_image ( module_image ) {
187:
188: if ( count >= limit ) {
189: DBGC ( image, "MULTIBOOT %p limit of %d modules "
190: "reached\n", image, limit );
191: break;
192: }
193:
194: /* Do not include kernel image itself as a module */
195: if ( module_image == image )
196: continue;
197:
198: /* At least some OSes expect the multiboot modules to
199: * be in ascending order, so we have to support it.
200: */
201: start = user_to_phys ( module_image->data, 0 );
202: end = user_to_phys ( module_image->data, module_image->len );
203: for ( insert = 0 ; insert < count ; insert++ ) {
204: if ( start < modules[insert].mod_start )
205: break;
206: }
207: module = &modules[insert];
208: memmove ( ( module + 1 ), module,
209: ( ( count - insert ) * sizeof ( *module ) ) );
210: module->mod_start = start;
211: module->mod_end = end;
212: module->string = multiboot_add_cmdline ( module_image->name,
213: module_image->cmdline );
214: module->reserved = 0;
215:
216: /* We promise to page-align modules */
217: assert ( ( module->mod_start & 0xfff ) == 0 );
218:
219: count++;
220: }
221:
222: /* Dump module configuration */
223: for ( i = 0 ; i < count ; i++ ) {
224: DBGC ( image, "MULTIBOOT %p module %d is [%x,%x)\n",
225: image, i, modules[i].mod_start,
226: modules[i].mod_end );
227: }
228:
229: return count;
230: }
231:
232: /**
233: * The multiboot information structure
234: *
235: * Kept in base memory because some OSes won't find it elsewhere,
236: * along with the other structures belonging to the Multiboot
237: * information table.
238: */
239: static struct multiboot_info __bss16 ( mbinfo );
240: #define mbinfo __use_data16 ( mbinfo )
241:
242: /** The multiboot bootloader name */
243: static char __data16_array ( mb_bootloader_name, [] ) = "iPXE " VERSION;
244: #define mb_bootloader_name __use_data16 ( mb_bootloader_name )
245:
246: /** The multiboot memory map */
247: static struct multiboot_memory_map
248: __bss16_array ( mbmemmap, [MAX_MEMORY_REGIONS] );
249: #define mbmemmap __use_data16 ( mbmemmap )
250:
251: /** The multiboot module list */
252: static struct multiboot_module __bss16_array ( mbmodules, [MAX_MODULES] );
253: #define mbmodules __use_data16 ( mbmodules )
254:
255: /**
256: * Find multiboot header
257: *
258: * @v image Multiboot file
259: * @v hdr Multiboot header descriptor to fill in
260: * @ret rc Return status code
261: */
262: static int multiboot_find_header ( struct image *image,
263: struct multiboot_header_info *hdr ) {
264: uint32_t buf[64];
265: size_t offset;
266: unsigned int buf_idx;
267: uint32_t checksum;
268:
269: /* Scan through first 8kB of image file 256 bytes at a time.
270: * (Use the buffering to avoid the overhead of a
271: * copy_from_user() for every dword.)
272: */
273: for ( offset = 0 ; offset < 8192 ; offset += sizeof ( buf[0] ) ) {
274: /* Check for end of image */
275: if ( offset > image->len )
276: break;
277: /* Refill buffer if applicable */
278: buf_idx = ( ( offset % sizeof ( buf ) ) / sizeof ( buf[0] ) );
279: if ( buf_idx == 0 ) {
280: copy_from_user ( buf, image->data, offset,
281: sizeof ( buf ) );
282: }
283: /* Check signature */
284: if ( buf[buf_idx] != MULTIBOOT_HEADER_MAGIC )
285: continue;
286: /* Copy header and verify checksum */
287: copy_from_user ( &hdr->mb, image->data, offset,
288: sizeof ( hdr->mb ) );
289: checksum = ( hdr->mb.magic + hdr->mb.flags +
290: hdr->mb.checksum );
291: if ( checksum != 0 )
292: continue;
293: /* Record offset of multiboot header and return */
294: hdr->offset = offset;
295: return 0;
296: }
297:
298: /* No multiboot header found */
299: return -ENOEXEC;
300: }
301:
302: /**
303: * Load raw multiboot image into memory
304: *
305: * @v image Multiboot file
306: * @v hdr Multiboot header descriptor
307: * @ret entry Entry point
308: * @ret rc Return status code
309: */
310: static int multiboot_load_raw ( struct image *image,
311: struct multiboot_header_info *hdr,
312: physaddr_t *entry ) {
313: size_t offset;
314: size_t filesz;
315: size_t memsz;
316: userptr_t buffer;
317: int rc;
318:
319: /* Sanity check */
320: if ( ! ( hdr->mb.flags & MB_FLAG_RAW ) ) {
321: DBGC ( image, "MULTIBOOT %p is not flagged as a raw image\n",
322: image );
323: return -EINVAL;
324: }
325:
326: /* Verify and prepare segment */
327: offset = ( hdr->offset - hdr->mb.header_addr + hdr->mb.load_addr );
328: filesz = ( hdr->mb.load_end_addr ?
329: ( hdr->mb.load_end_addr - hdr->mb.load_addr ) :
330: ( image->len - offset ) );
331: memsz = ( hdr->mb.bss_end_addr ?
332: ( hdr->mb.bss_end_addr - hdr->mb.load_addr ) : filesz );
333: buffer = phys_to_user ( hdr->mb.load_addr );
334: if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
335: DBGC ( image, "MULTIBOOT %p could not prepare segment: %s\n",
336: image, strerror ( rc ) );
337: return rc;
338: }
339:
340: /* Copy image to segment */
341: memcpy_user ( buffer, 0, image->data, offset, filesz );
342:
343: /* Record execution entry point */
344: *entry = hdr->mb.entry_addr;
345:
346: return 0;
347: }
348:
349: /**
350: * Load ELF multiboot image into memory
351: *
352: * @v image Multiboot file
353: * @ret entry Entry point
354: * @ret rc Return status code
355: */
356: static int multiboot_load_elf ( struct image *image, physaddr_t *entry ) {
357: int rc;
358:
359: /* Load ELF image*/
360: if ( ( rc = elf_load ( image, entry ) ) != 0 ) {
361: DBGC ( image, "MULTIBOOT %p ELF image failed to load: %s\n",
362: image, strerror ( rc ) );
363: return rc;
364: }
365:
366: return 0;
367: }
368:
369: /**
370: * Execute multiboot image
371: *
372: * @v image Multiboot image
373: * @ret rc Return status code
374: */
375: static int multiboot_exec ( struct image *image ) {
376: struct multiboot_header_info hdr;
377: physaddr_t entry;
378: int rc;
379:
380: /* Locate multiboot header, if present */
381: if ( ( rc = multiboot_find_header ( image, &hdr ) ) != 0 ) {
382: DBGC ( image, "MULTIBOOT %p has no multiboot header\n",
383: image );
384: return rc;
385: }
386:
387: /* Abort if we detect flags that we cannot support */
388: if ( hdr.mb.flags & MB_UNSUPPORTED_FLAGS ) {
389: DBGC ( image, "MULTIBOOT %p flags %08x not supported\n",
390: image, ( hdr.mb.flags & MB_UNSUPPORTED_FLAGS ) );
391: return -ENOTSUP;
392: }
393:
394: /* There is technically a bit MB_FLAG_RAW to indicate whether
395: * this is an ELF or a raw image. In practice, grub will use
396: * the ELF header if present, and Solaris relies on this
397: * behaviour.
398: */
399: if ( ( ( rc = multiboot_load_elf ( image, &entry ) ) != 0 ) &&
400: ( ( rc = multiboot_load_raw ( image, &hdr, &entry ) ) != 0 ) )
401: return rc;
402:
403: /* Populate multiboot information structure */
404: memset ( &mbinfo, 0, sizeof ( mbinfo ) );
405: mbinfo.flags = ( MBI_FLAG_LOADER | MBI_FLAG_MEM | MBI_FLAG_MMAP |
406: MBI_FLAG_CMDLINE | MBI_FLAG_MODS );
407: mb_cmdline_offset = 0;
408: mbinfo.cmdline = multiboot_add_cmdline ( image->name, image->cmdline );
409: mbinfo.mods_count = multiboot_build_module_list ( image, mbmodules,
410: ( sizeof(mbmodules) / sizeof(mbmodules[0]) ) );
411: mbinfo.mods_addr = virt_to_phys ( mbmodules );
412: mbinfo.mmap_addr = virt_to_phys ( mbmemmap );
413: mbinfo.boot_loader_name = virt_to_phys ( mb_bootloader_name );
414:
415: /* Multiboot images may not return and have no callback
416: * interface, so shut everything down prior to booting the OS.
417: */
418: shutdown_boot();
419:
420: /* Build memory map after unhiding bootloader memory regions as part of
421: * shutting everything down.
422: */
423: multiboot_build_memmap ( image, &mbinfo, mbmemmap,
424: ( sizeof(mbmemmap) / sizeof(mbmemmap[0]) ) );
425:
426: /* Jump to OS with flat physical addressing */
427: DBGC ( image, "MULTIBOOT %p starting execution at %lx\n",
428: image, entry );
429: __asm__ __volatile__ ( PHYS_CODE ( "pushl %%ebp\n\t"
430: "call *%%edi\n\t"
431: "popl %%ebp\n\t" )
432: : : "a" ( MULTIBOOT_BOOTLOADER_MAGIC ),
433: "b" ( virt_to_phys ( &mbinfo ) ),
434: "D" ( entry )
435: : "ecx", "edx", "esi", "memory" );
436:
437: DBGC ( image, "MULTIBOOT %p returned\n", image );
438:
439: /* It isn't safe to continue after calling shutdown() */
440: while ( 1 ) {}
441:
442: return -ECANCELED; /* -EIMPOSSIBLE, anyone? */
443: }
444:
445: /**
446: * Probe multiboot image
447: *
448: * @v image Multiboot file
449: * @ret rc Return status code
450: */
451: static int multiboot_probe ( struct image *image ) {
452: struct multiboot_header_info hdr;
453: int rc;
454:
455: /* Locate multiboot header, if present */
456: if ( ( rc = multiboot_find_header ( image, &hdr ) ) != 0 ) {
457: DBGC ( image, "MULTIBOOT %p has no multiboot header\n",
458: image );
459: return rc;
460: }
461: DBGC ( image, "MULTIBOOT %p found header with flags %08x\n",
462: image, hdr.mb.flags );
463:
464: return 0;
465: }
466:
467: /** Multiboot image type */
468: struct image_type multiboot_image_type __image_type ( PROBE_MULTIBOOT ) = {
469: .name = "Multiboot",
470: .probe = multiboot_probe,
471: .exec = multiboot_exec,
472: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.