Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/boot2/mboot.c

Source at commit 1076 created 12 years 10 months ago.
By meklort, Removed disk code + fs code from libsaio. Moved modulesystem to within /modules/ folder
1/*␊
2 File added by David F. Elliott <dfe@cox.net> on 2007/06/26␊
3*/␊
4␊
5#include "libsaio.h"␊
6#include "boot.h"␊
7␊
8#include "mboot.h"␊
9␊
10int multiboot_timeout=0;␊
11int multiboot_timeout_set=0;␊
12int multiboot_partition=0;␊
13int multiboot_partition_set=0;␊
14␊
15// Global multiboot info, if using multiboot.␊
16struct multiboot_info *gMI;␊
17␊
18extern void continue_at_low_address(void);␊
19␊
20// prototype hi_multiboot and keep its implementation below multiboot_to_boot␊
21// to ensure that it doesn't get inlined by the compiler␊
22// We don't want it inlined because we specifically want the stack frame␊
23// pointer to be as high as possible and the hi_multiboot function␊
24// copies multiboot_info onto its stack.␊
25uint32_t hi_multiboot(int multiboot_magic, struct multiboot_info *mi_orig);␊
26// prototype dochainload for the same reason.␊
27void dochainload();␊
28␊
29#define OFFSET_1MEG 0x100000␊
30#define BAD_BOOT_DEVICE 0xffffffff␊
31␊
32// This assumes that the address of the first argument to the function will␊
33// be exactly 4 bytes above the address of the return address.␊
34// It is intended to be used as an lvalue with a statement like this -= OFFSET_1MEG;␊
35#define RETURN_ADDRESS_USING_FIRST_ARG(arg) \␊
36 (*(uint32_t*)((char*)&(arg) - 4))␊
37␊
38#define FIX_RETURN_ADDRESS_USING_FIRST_ARG(arg) \␊
39 RETURN_ADDRESS_USING_FIRST_ARG(arg) -= OFFSET_1MEG␊
40␊
41extern void jump_to_chainbooter();␊
42extern unsigned char chainbootdev;␊
43extern unsigned char chainbootflag;␊
44␊
45void chainLoad();␊
46void waitThenReload();␊
47␊
48/*␊
49 int multibootRamdiskReadBytes( int biosdev, unsigned int blkno,␊
50 unsigned int byteoff,␊
51 unsigned int byteCount, void * buffer );␊
52int multiboot_get_ramdisk_info(int biosdev, struct driveInfo *dip);␊
53static long multiboot_LoadExtraDrivers(FileLoadDrivers_t FileLoadDrivers_p);␊
54*/␊
55␊
56// Starts off in the multiboot context 1 MB high but eventually gets into low memory␊
57// and winds up with a bootdevice in eax which is all that boot() wants␊
58// This lets the stack pointer remain very high.␊
59// If we were to call boot directly from multiboot then the whole multiboot_info␊
60// would be on the stack which would possibly be using way too much stack.␊
61void multiboot_to_boot(int multiboot_magic, struct multiboot_info *mi_orig)␊
62{␊
63 uint32_t bootdevice = hi_multiboot(multiboot_magic, mi_orig);␊
64 if(bootdevice != BAD_BOOT_DEVICE)␊
65 {␊
66 // boot only returns to do a chain load.␊
67 for(;;)␊
68 { // NOTE: boot only uses the last byte (the drive number)␊
69 common_boot(bootdevice);␊
70 if(chainbootflag)␊
71 chainLoad();␊
72 else␊
73 waitThenReload();␊
74 }␊
75 }␊
76 // Avoid returning to high-memory address which isn't valid in the segment␊
77 // we are now in.␊
78 // Calling sleep() ensures the user ought to be able to use Ctrl+Alt+Del␊
79 // because the BIOS will have interrupts on.␊
80 for(;;)␊
81 sleep(10);␊
82 // NOTE: *IF* we needed to return we'd have to fix up our return address to␊
83 // be in low memory using the same trick as below.␊
84 // However, there doesn't seem to be any point in returning to assembly␊
85 // particularly when the remaining code merely halts the processor.␊
86}␊
87␊
88void chainLoad()␊
89{␊
90 /* TODO: We ought to load the appropriate partition table, for example␊
91 the MBR if booting a primary partition or the particular extended␊
92 partition table if booting a logical drive. For example, the␊
93 regular MS MBR booter will relocate itself (e.g. the MBR) from␊
94 0:7C00 to 0:0600 and will use SI as the offset when reading␊
95 the partition data from itself. Thus when it jumps to the partition␊
96 boot sector, SI will be 0x600 + 446 + i<<4 where i is the partition␊
97 table index.␊
98 ␊
99 On the other hand, our code for the non-Multiboot case doesn't do␊
100 this either, although GRUB does.␊
101 */␊
102␊
103 const unsigned char *bootcode = (const unsigned char*)0x7c00;␊
104 if(bootcode[0x1fe] == 0x55 && bootcode[0x1ff] == 0xaa)␊
105 {␊
106 printf("Calling chainbooter\n");␊
107 jump_to_chainbooter();␊
108 /* NORETURN */␊
109 }␊
110 else␊
111 {␊
112 printf("Bad chain boot sector magic: %02x%02x\n", bootcode[0x1fe], bootcode[0x1ff]);␊
113 }␊
114}␊
115␊
116void waitThenReload()␊
117{␊
118 /* FIXME: Ctrl+Alt+Del does not work under Boot Camp */␊
119 printf("Darwin booter exited for some reason.\n");␊
120 printf("Please reboot (Ctrl+Alt+Del) your machine.\n");␊
121 printf("Restarting Darwin booter in 5 seconds...");␊
122 sleep(1);␊
123 printf("4...");␊
124 sleep(1);␊
125 printf("3...");␊
126 sleep(1);␊
127 printf("2...");␊
128 sleep(1);␊
129 printf("1...");␊
130 sleep(1);␊
131 printf("0\n");␊
132}␊
133␊
134// Declare boot2_sym as an opaque struct so it can't be converted to a pointer␊
135// i.e. ensure the idiot programmer (me) makes sure to use address-of␊
136// Technically it's a function but it's real mode code and we sure don't␊
137// want to call it under any circumstances.␊
138extern struct {} boot2_sym asm("boot2");␊
139␊
140// prototype multiboot and keep its implementation below hi_multiboot to␊
141// ensure that it doesn't get inlined by the compiler␊
142static inline uint32_t multiboot(int multiboot_magic, struct multiboot_info *mi);␊
143␊
144␊
145/*!␊
146 Returns a pointer to the first safe address we can use for stowing the multiboot info.␊
147 This might actually be a bit pedantic because mboot.c32 and GRUB both stow the multiboot␊
148 info in low memory meaning that the >= 128 MB location we choose is plenty high enough.␊
149 */␊
150void *determine_safe_hi_addr(int multiboot_magic, struct multiboot_info *mi_orig)␊
151{␊
152 // hi_addr must be at least up in 128MB+ space so it doesn't get clobbered␊
153 void *hi_addr = (void*)PREBOOT_DATA;␊
154␊
155 // Fail if the magic isn't correct. We'll complain later.␊
156 if(multiboot_magic != MULTIBOOT_INFO_MAGIC)␊
157 return NULL;␊
158 // Make sure the command-line isn't in high memory.␊
159 if(mi_orig->mi_flags & MULTIBOOT_INFO_HAS_CMDLINE)␊
160 {␊
161 char *end = mi_orig->mi_cmdline;␊
162 if(end != NULL)␊
163 {␊
164 for(; *end != '\0'; ++end)␊
165 ;␊
166 ++end;␊
167 if( (void*)end > hi_addr)␊
168 hi_addr = end;␊
169 }␊
170 }␊
171 // Make sure the module information isn't in high memory␊
172 if(mi_orig->mi_flags & MULTIBOOT_INFO_HAS_MODS)␊
173 {␊
174 struct multiboot_module *modules = (void*)mi_orig->mi_mods_addr;␊
175 int i;␊
176 for(i=0; i < mi_orig->mi_mods_count; ++i)␊
177 {␊
178 // make sure the multiboot_module struct itself won't get clobbered␊
179 void *modinfo_end = modules+i+1;␊
180 if(modinfo_end > hi_addr)␊
181 hi_addr = modinfo_end;␊
182 // make sure the module itself won't get clobbered␊
183 modinfo_end = (void*)modules[i].mm_mod_end;␊
184 if(modinfo_end > hi_addr)␊
185 hi_addr = modinfo_end;␊
186 // make sure the module string doesn't get clobbered␊
187 char *end = modules[i].mm_string;␊
188 for(; *end != '\0'; ++end)␊
189 ;␊
190 ++end;␊
191 modinfo_end = end;␊
192 if(modinfo_end > hi_addr)␊
193 hi_addr = modinfo_end;␊
194 }␊
195 }␊
196 // TODO: Copy syms (never needed), mmap, drives, config table, loader name, apm table, VBE info␊
197␊
198 // Round up to page size␊
199 hi_addr = (void*)(((uint32_t)hi_addr + 0xfff) & ~(uint32_t)0xfff);␊
200 return hi_addr;␊
201}␊
202␊
203/*!␊
204 Like malloc but with a preceding input/output parameter which points to the next available␊
205 location for data. The original value of *hi_addr is returned and *hi_addr is incremented␊
206 by size bytes.␊
207 */␊
208void * _hi_malloc(void **hi_addr, size_t size)␊
209{␊
210 void *ret = *hi_addr;␊
211 *hi_addr += size;␊
212 return ret;␊
213}␊
214␊
215/*!␊
216 Like strdup but with a preceding input/output parameter. The original value of *hi_addr is␊
217 returned and *hi_addr is incremented by the number of bytes necessary to complete the string␊
218 copy including its NUL terminator.␊
219 */␊
220char * _hi_strdup(void **hi_addr, char *src)␊
221{␊
222 char *dstStart;␊
223 char *dst = dstStart = *hi_addr;␊
224 for(; *src != '\0'; ++src, ++dst, ++(*hi_addr))␊
225 *dst = *src;␊
226 *dst = '\0';␊
227 ++(*hi_addr);␊
228 return dstStart;␊
229}␊
230␊
231// Convenience macros␊
232#define hi_malloc(size) _hi_malloc(&hi_addr, (size))␊
233#define hi_strdup(src) _hi_strdup(&hi_addr, (src))␊
234␊
235/*!␊
236 Copies the Multiboot info and any associated data (e.g. various strings and any multiboot modules)␊
237 up to very high RAM (above 128 MB) to ensure it doesn't get clobbered by the booter.␊
238 */␊
239struct multiboot_info * copyMultibootInfo(int multiboot_magic, struct multiboot_info *mi_orig)␊
240{␊
241 void *hi_addr = determine_safe_hi_addr(multiboot_magic, mi_orig);␊
242 if(hi_addr == NULL)␊
243 return NULL;␊
244␊
245 struct multiboot_info *mi_copy = hi_malloc(sizeof(*mi_copy));␊
246 memcpy(mi_copy, mi_orig, sizeof(*mi_copy));␊
247 ␊
248 // Copy the command line␊
249 if(mi_orig->mi_flags & MULTIBOOT_INFO_HAS_CMDLINE)␊
250 {␊
251 mi_copy->mi_cmdline = hi_strdup(mi_orig->mi_cmdline);␊
252 }␊
253 // Copy the loader name␊
254 if(mi_orig->mi_flags & MULTIBOOT_INFO_HAS_LOADER_NAME)␊
255 {␊
256 mi_copy->mi_loader_name = hi_strdup(mi_orig->mi_loader_name);␊
257 }␊
258 // Copy the module info␊
259 if(mi_orig->mi_flags & MULTIBOOT_INFO_HAS_MODS)␊
260 {␊
261 struct multiboot_module *dst_modules = hi_malloc(sizeof(*dst_modules)*mi_orig->mi_mods_count);␊
262 struct multiboot_module *src_modules = (void*)mi_orig->mi_mods_addr;␊
263 mi_copy->mi_mods_addr = (uint32_t)dst_modules;␊
264␊
265 // Copy all of the module info plus the actual module into high memory␊
266 int i;␊
267 for(i=0; i < mi_orig->mi_mods_count; ++i)␊
268 {␊
269 // Assume mod_end is 1 past the actual end (i.e. it is start + size, not really end (i.e. start + size - 1))␊
270 // This is what GRUB and mboot.c32 do although the spec is unclear on this.␊
271 uint32_t mod_length = src_modules[i].mm_mod_end - src_modules[i].mm_mod_start;␊
272␊
273 dst_modules[i].mm_mod_start = (uint32_t)hi_malloc(mod_length);␊
274 dst_modules[i].mm_mod_end = (uint32_t)dst_modules[i].mm_mod_start + mod_length;␊
275 memcpy((char*)dst_modules[i].mm_mod_start, (char*)src_modules[i].mm_mod_start, mod_length);␊
276 ␊
277 dst_modules[i].mm_string = hi_strdup(src_modules[i].mm_string);␊
278 dst_modules[i].mm_reserved = src_modules[i].mm_reserved;␊
279 }␊
280 }␊
281 // Make sure that only stuff that didn't need to be copied or that we did deep copy is indicated in the copied struct.␊
282 mi_copy->mi_flags &= MULTIBOOT_INFO_HAS_MEMORY | MULTIBOOT_INFO_HAS_BOOT_DEVICE | MULTIBOOT_INFO_HAS_CMDLINE | MULTIBOOT_INFO_HAS_LOADER_NAME | MULTIBOOT_INFO_HAS_MODS;␊
283␊
284 return mi_copy;␊
285}␊
286␊
287// When we enter, we're actually 1 MB high.␊
288// Fortunately, memcpy is position independent, and it's all we need␊
289uint32_t hi_multiboot(int multiboot_magic, struct multiboot_info *mi_orig)␊
290{␊
291 // Copy the multiboot info out of the way.␊
292 // We can't bitch about the magic yet because printf won't work␊
293 // because it contains an absolute location of putchar which␊
294 // contains absolute locations to other things which eventually␊
295 // makes a BIOS call from real mode which of course won't work␊
296 // because we're stuck in extended memory at this point.␊
297 struct multiboot_info *mi_p = copyMultibootInfo(multiboot_magic, mi_orig);␊
298␊
299 // Get us in to low memory so we can run everything␊
300␊
301 // We cannot possibly be more than 447k and copying extra won't really hurt anything␊
302 // We use the address of the assembly entrypoint to get our starting location.␊
303 memcpy(&boot2_sym, (char*)&boot2_sym + OFFSET_1MEG, BOOT2_MAX_LENGTH /* 447k */);␊
304␊
305 // This is a little assembler routine that returns to us in the correct selector␊
306 // instead of the kernel selector we're running in now and at the correct␊
307 // instruction pointer ( current minus 1 MB ). It does not fix our return␊
308 // address nor does it fix the return address of our caller.␊
309 continue_at_low_address();␊
310␊
311 // Now fix our return address.␊
312 FIX_RETURN_ADDRESS_USING_FIRST_ARG(multiboot_magic);␊
313␊
314 // We can now do just about anything, including return to our caller correctly.␊
315 // However, our caller must fix his return address if he wishes to return to␊
316 // his caller and so on and so forth.␊
317␊
318 /* Zero the BSS and initialize malloc */␊
319 initialize_runtime();␊
320␊
321 gMI = mi_p;␊
322␊
323 /* Set up a temporary bootArgs so we can call console output routines␊
324 like printf that check the v_display. Note that we purposefully␊
325 do not initialize anything else at this early stage.␊
326␊
327 We are reasonably sure we're already in text mode if GRUB booted us.␊
328 This is the same assumption that initKernBootStruct makes.␊
329 We could check the multiboot info I guess, but why bother?␊
330 */␊
331 boot_args temporaryBootArgsData;␊
332 bzero(&temporaryBootArgsData, sizeof(boot_args));␊
333// bootArgs = &temporaryBootArgsData;␊
334 // bootArgs->Video.v_display = VGA_TEXT_MODE;␊
335␊
336 // Install ramdisk and extra driver hooks␊
337 //p_get_ramdisk_info = &multiboot_get_ramdisk_info;␊
338 //p_ramdiskReadBytes = &multibootRamdiskReadBytes;␊
339 //LoadExtraDrivers_p = &multiboot_LoadExtraDrivers;␊
340␊
341 // Since we call multiboot ourselves, its return address will be correct.␊
342 // That is unless it's inlined in which case it does not matter.␊
343 uint32_t bootdevice = multiboot(multiboot_magic, mi_p);␊
344 // We're about to exit and temporaryBootArgs will no longer be valid␊
345 //bootArgs = NULL;␊
346 return bootdevice;␊
347}␊
348␊
349// This is the meat of our implementation. It grabs the boot device from␊
350// the multiboot_info and returns it as is. If it fails it returns␊
351// BAD_BOOT_DEVICE. We can call an awful lot of libsa and libsaio but␊
352// we need to take care not to call anything that requires malloc because␊
353// it won't be initialized until boot() does it.␊
354static inline uint32_t multiboot(int multiboot_magic, struct multiboot_info *mi)␊
355{␊
356 if(multiboot_magic != MULTIBOOT_INFO_MAGIC)␊
357 {␊
358 printf("Wrong Multiboot magic\n");␊
359 sleep(2);␊
360 return BAD_BOOT_DEVICE;␊
361 }␊
362 printf("Multiboot info @0x%x\n", (uint32_t)mi);␊
363 if(mi->mi_flags & MULTIBOOT_INFO_HAS_LOADER_NAME)␊
364 printf("Loaded by %s\n", mi->mi_loader_name);␊
365␊
366 // Multiboot puts boot device in high byte␊
367 // Normal booter wants it in low byte␊
368 int bootdevice = mi->mi_boot_device_drive;␊
369␊
370 bool doSelectDevice = false;␊
371 if(mi->mi_flags & MULTIBOOT_INFO_HAS_BOOT_DEVICE)␊
372 {␊
373 printf("Boot device 0x%x\n", bootdevice);␊
374 }␊
375 else␊
376 {␊
377 printf("Multiboot info does not include chosen boot device\n");␊
378 doSelectDevice = true;␊
379 bootdevice = BAD_BOOT_DEVICE;␊
380 }␊
381␊
382 if(bootdevice == BAD_BOOT_DEVICE)␊
383 sleep(2); // pause for a second before halting␊
384 return bootdevice;␊
385}␊
386␊
387///////////////////////////////////////////////////////////////////////////␊
388// Ramdisk and extra drivers code␊
389#if 0␊
390int multibootRamdiskReadBytes( int biosdev, unsigned int blkno,␊
391 unsigned int byteoff,␊
392 unsigned int byteCount, void * buffer )␊
393{␊
394 int module_count = gMI->mi_mods_count;␊
395 struct multiboot_module *modules = (void*)gMI->mi_mods_addr;␊
396 if(biosdev < 0x100)␊
397 return -1;␊
398 if(biosdev >= (0x100 + module_count))␊
399 return -1;␊
400 struct multiboot_module *module = modules + (biosdev - 0x100);␊
401␊
402 void *p_initrd = (void*)module->mm_mod_start;␊
403 bcopy(p_initrd + blkno*512 + byteoff, buffer, byteCount);␊
404 return 0;␊
405}␊
406␊
407int multiboot_get_ramdisk_info(int biosdev, struct driveInfo *dip)␊
408{␊
409 int module_count = gMI->mi_mods_count;␊
410 struct multiboot_module *modules = (void*)gMI->mi_mods_addr;␊
411 if(biosdev < 0x100)␊
412 return -1;␊
413 if(biosdev >= (0x100 + module_count))␊
414 return -1;␊
415 struct multiboot_module *module = modules + (biosdev - 0x100);␊
416 dip->biosdev = biosdev;␊
417 dip->uses_ebios = true;␉// XXX aserebln uses_ebios isn't a boolean at all␊
418 dip->di.params.phys_sectors = (module->mm_mod_end - module->mm_mod_start + 511) / 512;␊
419 dip->valid = true;␊
420 return 0;␊
421}␊
422static long multiboot_LoadExtraDrivers(FileLoadDrivers_t FileLoadDrivers_p)␊
423{␊
424 char extensionsSpec[1024];␊
425 int ramdiskUnit;␊
426 for(ramdiskUnit = 0; ramdiskUnit < gMI->mi_mods_count; ++ramdiskUnit)␊
427 {␊
428 int partCount; // unused␊
429 BVRef ramdiskChain = diskScanBootVolumes(0x100 + ramdiskUnit, &partCount);␊
430 if(ramdiskChain == NULL)␊
431 {␊
432 verbose("Ramdisk contains no partitions\n");␊
433 continue;␊
434 }␊
435 for(; ramdiskChain != NULL; ramdiskChain = ramdiskChain->next)␊
436 {␊
437 sprintf(extensionsSpec, "rd(%d,%d)/Extra/", ramdiskUnit, ramdiskChain->part_no);␊
438 struct dirstuff *extradir = opendir(extensionsSpec);␊
439 closedir(extradir);␊
440 if(extradir != NULL)␊
441 {␊
442 int ret = FileLoadDrivers_p(extensionsSpec, 0 /* this is a kext root dir, not a kext with plugins */);␊
443 if(ret != 0)␊
444 {␊
445 verbose("FileLoadDrivers failed on a ramdisk\n");␊
446 return ret;␊
447 }␊
448 }␊
449 }␊
450 }␊
451 return 0;␊
452}␊
453#endif

Archive Download this file

Revision: 1076