Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/boot2/options.c

1/*␊
2 * Copyright (c) 1999-2004 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2004 Apple Computer, Inc. All Rights␊
7 * Reserved. This file contains Original Code and/or Modifications of␊
8 * Original Code as defined in and that are subject to the Apple Public␊
9 * Source License Version 2.0 (the "License"). You may not use this file␊
10 * except in compliance with the License. Please obtain a copy of the␊
11 * License at http://www.apple.com/publicsource and read it before using␊
12 * this file.␊
13 * ␊
14 * The Original Code and all software distributed under the License are␊
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 * ␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 */␊
24␊
25#include "boot.h"␊
26#include "bootstruct.h"␊
27#include "fdisk.h"␊
28#include "ramdisk.h"␊
29#include "gui.h"␊
30#include "term.h"␊
31#include "embedded.h"␊
32#include "pci.h"␊
33␊
34bool showBootBanner = true; //Azi:showinfo␊
35static bool shouldboot = false;␊
36␊
37extern int multiboot_timeout;␊
38extern int multiboot_timeout_set;␊
39␊
40extern BVRef bvChain;␊
41//extern int␉␉menucount;␊
42␊
43extern int␉␉gDeviceCount;␊
44␊
45int␉␉␉selectIndex = 0;␊
46MenuItem * menuItems = NULL;␊
47␊
48enum {␊
49 kMenuTopRow = 5,␊
50 kMenuMaxItems = 10,␊
51 kScreenLastRow = 24␊
52};␊
53␊
54//==========================================================================␊
55␊
56typedef struct {␊
57 int x;␊
58 int y;␊
59 int type;␊
60} CursorState;␊
61␊
62static void changeCursor( int col, int row, int type, CursorState * cs )␊
63{␊
64 if (cs) getCursorPositionAndType( &cs->x, &cs->y, &cs->type );␊
65 setCursorType( type );␊
66 setCursorPosition( col, row, 0 );␊
67}␊
68␊
69static void moveCursor( int col, int row )␊
70{␊
71 setCursorPosition( col, row, 0 );␊
72}␊
73␊
74static void restoreCursor( const CursorState * cs )␊
75{␊
76 setCursorPosition( cs->x, cs->y, 0 );␊
77 setCursorType( cs->type );␊
78}␊
79␊
80//==========================================================================␊
81␊
82/* Flush keyboard buffer; returns TRUE if any of the flushed␊
83 * characters was F8.␊
84 */␊
85␊
86static bool flushKeyboardBuffer(void)␊
87{␊
88 bool status = false;␊
89␊
90 while ( readKeyboardStatus() ) {␊
91 if (bgetc() == 0x4200) status = true;␊
92 }␊
93 return status;␊
94}␊
95␊
96//==========================================================================␊
97␊
98static int countdown( const char * msg, int row, int timeout )␊
99{␊
100 unsigned long time;␊
101 int ch = 0;␊
102 int col = strlen(msg) + 1;␊
103␉␊
104 flushKeyboardBuffer();␊
105␊
106␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
107␉{␊
108␉␉moveCursor( 0, row );␊
109␉␉printf(msg);␊
110␊
111␉} else {␊
112␊
113␉␉position_t p = pos( gui.screen.width / 2 + 1 , ( gui.devicelist.pos.y + 3 ) + ( ( gui.devicelist.height - gui.devicelist.iconspacing ) / 2 ) );␊
114␉␊
115␉␉char dummy[80];␊
116␉␉getBootVolumeDescription( gBootVolume, dummy, sizeof(dummy) - 1, true );␊
117␉␉drawDeviceIcon( gBootVolume, gui.screen.pixmap, p, true );␊
118␉␉drawStrCenteredAt( (char *) msg, &font_small, gui.screen.pixmap, gui.countdown.pos );␊
119␉␉␊
120␉␉// make this screen the new background␊
121␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
122␉␉␊
123␉}␊
124␊
125␉int multi_buff = 18 * (timeout);␊
126 int multi = ++multi_buff;␊
127␊
128 int lasttime=0;␊
129␊
130 for ( time = time18(), timeout++; timeout > 0; )␊
131 {␊
132␉␉if( time18() > lasttime)␊
133␉␉{␊
134␉␉␉multi--; ␊
135␉␉␉lasttime=time18();␊
136␉␉}␉␉␊
137 ␊
138 if ( (ch = readKeyboardStatus()) )␊
139 break;␊
140␊
141 // Count can be interrupted by holding down shift,␊
142 // control or alt key␊
143 if ( ( readKeyboardShiftFlags() & 0x0F ) != 0 )␊
144␉␉{␊
145 ch = 1;␊
146 break;␊
147 }␊
148␊
149 if ( time18() >= time )␊
150 {␊
151 time += 18;␊
152 timeout--;␊
153␊
154␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
155␉␉␉{␊
156␉␉␉␉moveCursor( col, row );␊
157␉␉␉␉printf("(%d) ", timeout);␊
158␉␉␉}␊
159 }␊
160␉␊
161␉␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
162␉␉{␊
163␉␉␉drawProgressBar( gui.screen.pixmap, 100, gui.progressbar.pos , ( multi * 100 / multi_buff ) );␊
164␉␉␉gui.redraw = true;␊
165␉␉␉updateVRAM();␊
166␉␉}␊
167␊
168 }␊
169␊
170 flushKeyboardBuffer();␊
171␊
172 return ch;␊
173}␊
174␊
175//==========================================================================␊
176␊
177char gBootArgs[BOOT_STRING_LEN];␊
178static char * gBootArgsPtr = gBootArgs;␊
179static char * gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
180static char booterCommand[BOOT_STRING_LEN];␊
181static char booterParam[BOOT_STRING_LEN];␊
182␊
183static void clearBootArgs(void)␊
184{␊
185␉gBootArgsPtr = gBootArgs;␊
186␉memset(gBootArgs, '\0', BOOT_STRING_LEN);␊
187␊
188␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
189␉␉clearGraphicBootPrompt();␊
190␉}␊
191}␊
192␊
193static void addBootArg(const char * argStr)␊
194{␊
195␉if ( (gBootArgsPtr + strlen(argStr) + 1) < gBootArgsEnd)␊
196␉{␊
197␉␉*gBootArgsPtr++ = ' ';␊
198␉␉strcat(gBootArgs, argStr);␊
199␉␉gBootArgsPtr += strlen(argStr);␊
200␉}␊
201}␊
202␊
203//==========================================================================␊
204␊
205static void showBootPrompt(int row, bool visible)␊
206{␊
207␉extern char bootPrompt[];␊
208␉extern char bootRescanPrompt[];␊
209␊
210␉if( bootArgs->Video.v_display == VGA_TEXT_MODE ) {␊
211␉␉changeCursor( 0, row, kCursorTypeUnderline, 0 ); ␊
212␉␉clearScreenRows( row, kScreenLastRow );␊
213␉}␊
214␊
215 clearBootArgs();␊
216␊
217␉if (visible) {␊
218␉␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
219␉␉␉if (gEnableCDROMRescan) {␊
220␉␉␉␉printf( bootRescanPrompt );␊
221␉␉␉} else {␊
222␉␉␉␉printf( bootPrompt );␊
223 printf( gBootArgs );␊
224␉␉␉}␊
225␉␉}␊
226␉} else {␊
227␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
228 clearGraphicBootPrompt();␊
229␉␉} else {␊
230␉␉␉printf("Press Enter to start up the foreign OS. ");␊
231␉␉}␊
232␉}␊
233}␊
234␊
235//==========================================================================␊
236␊
237static void updateBootArgs( int key )␊
238{␊
239 key = ASCII_KEY(key);␊
240␊
241 switch ( key )␊
242 {␊
243 case KEY_BKSP:␊
244 if ( gBootArgsPtr > gBootArgs )␊
245 {␊
246 *--gBootArgsPtr = '\0';␊
247␊
248 int x, y, t;␊
249 getCursorPositionAndType( &x, &y, &t );␊
250 if ( x == 0 && y )␊
251 {␊
252 x = 80; y--;␊
253 }␊
254 if (x) x--;␊
255 ␊
256␉␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
257␉␉␉␉{␊
258␉␉␉␉␉setCursorPosition( x, y, 0 );␊
259␉␉␉␉␉putca(' ', 0x07, 1);␊
260␉␉␉␉}␊
261 else␊
262 {␊
263 updateGraphicBootPrompt();␊
264 }␊
265 } ␊
266␉␉␉break;␊
267␊
268 default:␊
269 if ( key >= ' ' && gBootArgsPtr < gBootArgsEnd)␊
270 {␊
271 *gBootArgsPtr++ = key;␊
272 ␊
273 if( bootArgs->Video.v_display != VGA_TEXT_MODE ) updateGraphicBootPrompt();␊
274 else if ( key >= ' ' && key < 0x7f) putchar(key);␊
275␉␉␉}␊
276 ␊
277␉␉␉break;␊
278 }␊
279}␊
280␊
281//==========================================================================␊
282␊
283static const MenuItem * gMenuItems = NULL;␊
284␊
285static int gMenuItemCount;␊
286static int gMenuRow;␊
287static int gMenuHeight;␊
288static int gMenuTop;␊
289static int gMenuBottom;␊
290static int gMenuSelection;␊
291␊
292static int␉ gMenuStart;␊
293static int␉ gMenuEnd;␊
294␊
295static void printMenuItem( const MenuItem * item, int highlight )␊
296{␊
297 printf(" ");␊
298␊
299 if ( highlight )␊
300 putca(' ', 0x70, strlen(item->name) + 4);␊
301 else␊
302 putca(' ', 0x07, 40);␊
303␊
304 printf(" %40s\n", item->name);␊
305}␊
306␊
307//==========================================================================␊
308␊
309static void showMenu( const MenuItem * items, int count,␊
310 int selection, int row, int height )␊
311{␊
312 int i;␊
313 CursorState cursorState;␊
314␊
315 if ( items == NULL || count == 0 ) ␊
316␉␉return;␊
317␊
318 // head and tail points to the start and the end of the list.␊
319 // top and bottom points to the first and last visible items␊
320 // in the menu window.␊
321␊
322 gMenuItems␉␉= items;␊
323 gMenuRow␉␉= row;␊
324 gMenuHeight␉␉= height;␊
325 gMenuItemCount␉= count;␊
326 gMenuTop␉␉= 0;␊
327 gMenuBottom␉␉= MIN( count, height ) - 1;␊
328 gMenuSelection␉= selection;␊
329␊
330 gMenuStart␉␉= 0;␊
331 gMenuEnd␉ = MIN( count, gui.maxdevices ) - 1;␊
332␉␊
333␉// If the selected item is not visible, shift the list down.␊
334␊
335 if ( gMenuSelection > gMenuBottom )␊
336 {␊
337 gMenuTop += ( gMenuSelection - gMenuBottom );␊
338 gMenuBottom = gMenuSelection;␊
339 }␊
340␊
341␉if ( gMenuSelection > gMenuEnd )␊
342 {␊
343␉␉gMenuStart += ( gMenuSelection - gMenuEnd );␊
344 gMenuEnd = gMenuSelection;␊
345 }␊
346␉␊
347␉// Draw the visible items.␊
348␊
349␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
350␉␊
351␉␉drawDeviceList(gMenuStart, gMenuEnd, gMenuSelection);␊
352␊
353␉else {␊
354␉␉␊
355␉␉changeCursor( 0, row, kCursorTypeHidden, &cursorState );␊
356␊
357␉␉for ( i = gMenuTop; i <= gMenuBottom; i++ )␊
358␉␉{␊
359␉␉␉printMenuItem( &items[i], (i == gMenuSelection) );␊
360␉␉}␊
361␊
362␉␉restoreCursor( &cursorState );␊
363 }␊
364}␊
365␊
366//==========================================================================␊
367␊
368static int updateMenu( int key, void ** paramPtr )␊
369{␊
370 int moved = 0;␊
371␊
372 union {␊
373 struct {␊
374 unsigned int␊
375 selectionUp : 1,␊
376 selectionDown : 1,␊
377 scrollUp : 1,␊
378 scrollDown : 1;␊
379 } f;␊
380 unsigned int w;␊
381 } draw = {{0}};␊
382␊
383 if ( gMenuItems == NULL )␊
384␉␉return 0;␊
385␊
386␉if( bootArgs->Video.v_display != VGA_TEXT_MODE )␊
387␉{␊
388␉␉int res;␊
389␉␉␊
390␉␉// set navigation keys for horizontal layout as defaults␊
391␉␉int previous␉= 0x4B00;␉␉// left arrow␊
392␉␉int subsequent␉= 0x4D00;␉␉// right arrow␊
393␉␉int menu␉␉= 0x5000;␉␉// down arrow␊
394␉␉␊
395␉␉if ( gui.layout == VerticalLayout )␊
396␉␉{␊
397␉␉␉// set navigation keys for vertical layout␊
398␉␉␉previous␉= 0x4800;␉␉// up arrow␊
399␉␉␉subsequent␉= 0x5000;␉␉// down arrow␊
400␉␉␉menu␉␉= 0x4B00;␉␉// right arrow␊
401␉␉} ␊
402␊
403␉␉if ( key == previous )␊
404␉␉{␊
405␉␉␉if ( gMenuSelection > gMenuTop )␊
406␉␉␉␉draw.f.selectionUp = 1;␊
407␉␉␉else if ( gMenuTop > 0 )␊
408␉␉␉␉draw.f.scrollDown = 1;␊
409␉␉␉␊
410␉␉}␊
411␉␉␊
412␉␉else if ( key == subsequent )␊
413␉␉{␊
414␉␉␉if ( gMenuSelection != gMenuBottom)␊
415␉␉␉␉draw.f.selectionDown = 1;␊
416␉␉␉else if ( gMenuBottom < ( gMenuItemCount - 1 ) )␊
417␉␉␉␉draw.f.scrollUp = 1;␊
418␉␉}␊
419␉␉␊
420␉␉else if ( key == menu )␊
421␉␉{␊
422␉␉␉if ( gui.menu.draw )␊
423␉␉␉␉updateInfoMenu(key);␊
424␉␉␉else␊
425␉␉␉␉drawInfoMenu();␊
426␉␉}␊
427␊
428␉␉else if ( gui.menu.draw )␊
429␉␉{␊
430␉␉␉res = updateInfoMenu(key);␊
431␊
432␉␉␉if ( res == CLOSE_INFO_MENU )␊
433␉␉␉␉gui.menu.draw = false;␊
434␉␉␉else␊
435␉␉␉{␊
436␉␉␉␉shouldboot = ( res != DO_NOT_BOOT );␊
437␉␉␉␉␊
438␉␉␉␉if ( shouldboot )␊
439␉␉␉␉␉gui.menu.draw = false;␊
440␊
441␉␉␉␉switch (res)␊
442␉␉␉␉{␊
443␉␉␉␉␉case BOOT_NORMAL:␊
444␉␉␉␉␉␉gVerboseMode = false;␊
445␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
446␉␉␉␉␉␉break;␊
447␉␉␉␉␉␉␊
448␉␉␉␉␉case BOOT_VERBOSE:␊
449␉␉␉␉␉␉gVerboseMode = true;␊
450␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
451␉␉␉␉␉␉addBootArg(kVerboseModeFlag);␊
452␉␉␉␉␉␉break;␊
453␉␉␉␉␉␉␊
454␉␉␉␉␉case BOOT_IGNORECACHE:␊
455␉␉␉␉␉␉gVerboseMode = false;␊
456␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
457␉␉␉␉␉␉addBootArg(kIgnoreCachesFlag);␊
458␉␉␉␉␉␉break;␊
459␉␉␉␉␉␉␊
460␉␉␉␉␉case BOOT_SINGLEUSER:␊
461␉␉␉␉␉␉gVerboseMode = true;␊
462␉␉␉␉␉␉gBootMode = kBootModeNormal;␊
463␉␉␉␉␉␉addBootArg(kSingleUserModeFlag);␊
464␉␉␉␉␉␉break;␊
465␉␉␉␉}␊
466␉␉␉␉␊
467␉␉␉}␊
468␉␉␉␊
469␉␉}␉␊
470␉␉␉␊
471␉} else {␊
472␉␉switch ( key )␊
473␉␉{␊
474 ␉case 0x4800: // Up Arrow␊
475␉␉␉␉if ( gMenuSelection != gMenuTop )␊
476␉␉␉␉␉draw.f.selectionUp = 1;␊
477␉␉␉␉else if ( gMenuTop > 0 )␊
478␉␉␉␉␉draw.f.scrollDown = 1;␊
479␉␉␉␉break;␊
480␊
481␉␉␉case 0x5000: // Down Arrow␊
482␉␉␉␉if ( gMenuSelection != gMenuBottom )␊
483␉␉␉␉␉draw.f.selectionDown = 1;␊
484␉␉␉␉else if ( gMenuBottom < (gMenuItemCount - 1) ) ␊
485␉␉␉␉␉draw.f.scrollUp = 1;␊
486␉␉␉␉break;␊
487␉␉}␊
488␉}␊
489␊
490 if ( draw.w )␊
491 {␊
492 if ( draw.f.scrollUp )␊
493 {␊
494 scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);␊
495 gMenuTop++; gMenuBottom++;␊
496␉␉␉gMenuStart++; gMenuEnd++;␊
497 draw.f.selectionDown = 1;␊
498 }␊
499␊
500 if ( draw.f.scrollDown )␊
501 {␊
502 scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);␊
503 gMenuTop--; gMenuBottom--;␊
504 gMenuStart--; gMenuEnd--;␊
505 draw.f.selectionUp = 1;␊
506 }␊
507␊
508 if ( draw.f.selectionUp || draw.f.selectionDown )␊
509 {␊
510␊
511␉␉␉CursorState cursorState;␊
512␊
513␉␉␉// Set cursor at current position, and clear inverse video.␊
514␉␊
515␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
516␉␉␉{␊
517␉␉␉␉changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop, kCursorTypeHidden, &cursorState );␊
518␉␉␉␉printMenuItem( &gMenuItems[gMenuSelection], 0 );␊
519␉␉␉}␊
520␊
521␉␉␉if ( draw.f.selectionUp )␊
522␉␉␉{␊
523␉␉␉␉gMenuSelection--;␊
524␉␉␉␉if(( gMenuSelection - gMenuStart) == -1 )␊
525␉␉␉␉{␊
526␉␉␉␉␉gMenuStart--;␊
527␉␉␉␉␉gMenuEnd--;␊
528␉␉␉␉}␊
529␉␉␉␉␊
530␉␉␉} else {␊
531␉␉␉gMenuSelection++;␊
532␉␉␉if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )␊
533␉␉␉{␊
534␉␉␉␉gMenuStart++;␊
535␉␉␉␉gMenuEnd++;␊
536␉␉␉}␊
537␉ }␊
538␊
539␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
540␉ {␊
541␉␉␉moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );␊
542␉␉␉printMenuItem( &gMenuItems[gMenuSelection], 1 );␊
543␉␉␉restoreCursor( &cursorState );␊
544␊
545␉ } else␊
546␊
547␉␉␉drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);␊
548␊
549␉}␊
550␊
551 *paramPtr = gMenuItems[gMenuSelection].param; ␊
552 moved = 1;␊
553 }␊
554␊
555␉return moved;␊
556}␊
557␊
558//==========================================================================␊
559␊
560static void skipblanks( const char ** cpp ) ␊
561{␊
562 while ( **(cpp) == ' ' || **(cpp) == '\t' ) ++(*cpp);␊
563}␊
564␊
565//==========================================================================␊
566␊
567static const char * extractKernelName( char ** cpp )␊
568{␊
569 char * kn = *cpp;␊
570 char * cp = *cpp;␊
571 char c;␊
572␊
573 // Convert char to lower case.␊
574␊
575 c = *cp | 0x20;␊
576␊
577 // Must start with a letter or a '/'.␊
578␊
579 if ( (c < 'a' || c > 'z') && ( c != '/' ) )␊
580 return 0;␊
581␊
582 // Keep consuming characters until we hit a separator.␊
583␊
584 while ( *cp && (*cp != '=') && (*cp != ' ') && (*cp != '\t') )␊
585 cp++;␊
586␊
587 // Only SPACE or TAB separator is accepted.␊
588 // Reject everything else.␊
589␊
590 if (*cp == '=')␊
591 return 0;␊
592␊
593 // Overwrite the separator, and move the pointer past␊
594 // the kernel name.␊
595␊
596 if (*cp != '\0') *cp++ = '\0';␊
597 *cpp = cp;␊
598␊
599 return kn;␊
600}␊
601␊
602//==========================================================================␊
603␊
604static void␊
605printMemoryInfo(void)␊
606{␊
607 int line;␊
608 int i;␊
609 MemoryRange *mp = bootInfo->memoryMap;␊
610␊
611 // Activate and clear page 1␊
612 setActiveDisplayPage(1);␊
613 clearScreenRows(0, 24);␊
614 setCursorPosition( 0, 0, 1 );␊
615␊
616 printf("BIOS reported memory ranges:\n");␊
617 line = 1;␊
618 for (i=0; i<bootInfo->memoryMapCount; i++) {␊
619 printf("Base 0x%08x%08x, ",␊
620 (unsigned long)(mp->base >> 32),␊
621 (unsigned long)(mp->base));␊
622 printf("length 0x%08x%08x, type %d\n",␊
623 (unsigned long)(mp->length >> 32),␊
624 (unsigned long)(mp->length),␊
625 mp->type);␊
626 if (line++ > 20) {␊
627 pause();␊
628 line = 0;␊
629 }␊
630 mp++;␊
631 }␊
632 if (line > 0) {␊
633 pause();␊
634 }␊
635 ␊
636 setActiveDisplayPage(0);␊
637}␊
638␊
639char *getMemoryInfoString()␊
640{␊
641 int i;␊
642 MemoryRange *mp = bootInfo->memoryMap;␊
643␉char *buff = malloc(sizeof(char)*1024);␊
644␉if(!buff) return 0;␊
645␉␊
646␉char info[] = "BIOS reported memory ranges:\n";␊
647␉sprintf(buff, "%s", info);␊
648 for (i=0; i<bootInfo->memoryMapCount; i++) {␊
649 sprintf( buff+strlen(buff), "Base 0x%08x%08x, ",␊
650 (unsigned long)(mp->base >> 32),␊
651 (unsigned long)(mp->base));␊
652 sprintf( buff+strlen(buff), "length 0x%08x%08x, type %d\n",␊
653 (unsigned long)(mp->length >> 32),␊
654 (unsigned long)(mp->length),␊
655 mp->type);␊
656 mp++;␊
657 }␊
658␉return buff;␊
659}␊
660␊
661//==========================================================================␊
662␊
663void lspci(void)␊
664{␊
665␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) { ␊
666␉␉setActiveDisplayPage(1);␊
667␉␉clearScreenRows(0, 24);␊
668␉␉setCursorPosition(0, 0, 1);␊
669␉}␊
670␊
671␉dump_pci_dt(root_pci_dev->children);␊
672␊
673␉pause();␊
674␊
675␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
676␉␉setActiveDisplayPage(0);␊
677␉}␊
678}␊
679␊
680//==========================================================================␊
681␊
682int getBootOptions(bool firstRun)␊
683{␊
684␉int i;␊
685␉int key;␊
686␉int nextRow;␊
687␉int timeout;␊
688␉int bvCount;␊
689␉BVRef bvr;␊
690␉BVRef menuBVR;␊
691␉bool showPrompt, newShowPrompt, isCDROM;␊
692␊
693␉// Initialize default menu selection entry.␊
694␉gBootVolume = menuBVR = selectBootVolume(bvChain);␊
695␊
696␉if (biosDevIsCDROM(gBIOSDev)) {␊
697␉␉isCDROM = true;␊
698␉} else {␊
699␉␉isCDROM = false;␊
700␉}␊
701␊
702␉// ensure we're in graphics mode if gui is setup␊
703␉if (firstRun && gui.initialised && bootArgs->Video.v_display == VGA_TEXT_MODE)␊
704␉{␊
705␉␉setVideoMode(GRAPHICS_MODE, 0);␊
706␉}␊
707␊
708␉// Clear command line boot arguments␊
709␉clearBootArgs();␊
710␊
711␉// Allow user to override default timeout.␊
712␉if (multiboot_timeout_set) {␊
713␉␉timeout = multiboot_timeout;␊
714␉} else if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->chameleonConfig)) {␊
715␉␉/* If there is no timeout key in the file use the default timeout␊
716␉␉ which is different for CDs vs. hard disks. However, if not booting␊
717␉␉ a CD and no config file could be loaded set the timeout␊
718␉␉ to zero which causes the menu to display immediately.␊
719␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
720␉␉ or simply cannot be read) then an empty menu is displayed.␊
721␉␉ If some partitions are found, for example a Windows partition, then␊
722␉␉ these will be displayed in the menu as foreign partitions.␊
723␉␉ */␊
724␉␉if (isCDROM) {␊
725␉␉␉timeout = kCDBootTimeout;␊
726␉␉} else {␊
727␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
728␉␉}␊
729␉}␊
730␊
731␉if (timeout < 0) {␊
732␉␉gBootMode |= kBootModeQuiet;␊
733␉}␊
734␊
735␉// If the user is holding down a modifier key, enter safe mode.␊
736␉if ((readKeyboardShiftFlags() & 0x0F) != 0) {␊
737␉␉gBootMode |= kBootModeSafe;␊
738␉}␊
739␊
740␉// Checking user pressed keys␊
741␉bool f8press = false, spress = false, vpress = false;␊
742␉while (readKeyboardStatus()) {␊
743␉␉key = bgetc ();␊
744␉␉if (key == 0x4200) f8press = true;␊
745␉␉if ((key & 0xff) == 's' || (key & 0xff) == 'S') spress = true;␊
746␉␉if ((key & 0xff) == 'v' || (key & 0xff) == 'V') vpress = true;␊
747␉}␊
748␉// If user typed F8, abort quiet mode, and display the menu.␊
749␉if (f8press) {␊
750␉␉gBootMode &= ~kBootModeQuiet;␊
751␉␉timeout = 0;␊
752␉}␊
753␉// If user typed 'v' or 'V', boot in verbose mode.␊
754␉if ((gBootMode & kBootModeQuiet) && firstRun && vpress) {␊
755␉␉addBootArg(kVerboseModeFlag);␊
756␉}␊
757␉// If user typed 's' or 'S', boot in single user mode.␊
758␉if ((gBootMode & kBootModeQuiet) && firstRun && spress) {␊
759␉␉addBootArg(kSingleUserModeFlag);␊
760␉}␊
761␊
762␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
763␉␉setCursorPosition(0, 0, 0);␊
764␉␉clearScreenRows(0, kScreenLastRow);␊
765␉␉if (!(gBootMode & kBootModeQuiet)) {␊
766␉␉␉// Display banner and show hardware info.␊
767␉␉␉printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
768␉␉␉printf(getVBEInfoString());␊
769␉␉}␊
770␉␉changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);␊
771␉␉verbose("Scanning device %x...", gBIOSDev);␊
772␉}␊
773␊
774␉// When booting from CD, default to hard drive boot when possible. ␊
775␉if (isCDROM && firstRun) {␊
776␉␉const char *val;␊
777␉␉char *prompt = NULL;␊
778␉␉char *name = NULL;␊
779␉␉int cnt;␊
780␉␉int optionKey;␊
781␊
782␉␉if (getValueForKey(kCDROMPromptKey, &val, &cnt, &bootInfo->chameleonConfig)) {␊
783␉␉␉prompt = malloc(cnt + 1);␊
784␉␉␉strncat(prompt, val, cnt);␊
785␉␉} else {␊
786␉␉␉name = malloc(80);␊
787␉␉␉getBootVolumeDescription(gBootVolume, name, 79, false);␊
788␉␉␉prompt = malloc(256);␊
789␉␉␉sprintf(prompt, "Press any key to start up from %s, or press F8 to enter startup options.", name);␊
790␉␉␉free(name);␊
791␉␉}␊
792␊
793␉␉if (getIntForKey( kCDROMOptionKey, &optionKey, &bootInfo->chameleonConfig )) {␊
794␉␉␉// The key specified is a special key.␊
795␉␉} else {␊
796␉␉␉// Default to F8.␊
797␉␉␉optionKey = 0x4200;␊
798␉␉}␊
799␊
800␉␉// If the timeout is zero then it must have been set above due to the␊
801␉␉// early catch of F8 which means the user wants to set boot options␊
802␉␉// which we ought to interpret as meaning he wants to boot the CD.␊
803␉␉if (timeout != 0) {␊
804␉␉␉key = countdown(prompt, kMenuTopRow, timeout);␊
805␉␉} else {␊
806␉␉␉key = optionKey;␊
807␉␉}␊
808␊
809␉␉if (prompt != NULL) {␊
810␉␉␉free(prompt);␊
811␉␉}␊
812␊
813␉␉clearScreenRows( kMenuTopRow, kMenuTopRow + 2 );␊
814␊
815␉␉// Hit the option key ?␊
816␉␉if (key == optionKey) {␊
817␉␉␉gBootMode &= ~kBootModeQuiet;␊
818␉␉␉timeout = 0;␊
819␉␉} else {␊
820␉␉␉key = key & 0xFF;␊
821␊
822␉␉␉// Try booting hard disk if user pressed 'h'␊
823␉␉␉if (biosDevIsCDROM(gBIOSDev) && key == 'h') {␊
824␉␉␉␉BVRef bvr;␊
825␊
826␉␉␉␉// Look at partitions hosting OS X other than the CD-ROM␊
827␉␉␉␉for (bvr = bvChain; bvr; bvr=bvr->next) {␊
828␉␉␉␉␉if ((bvr->flags & kBVFlagSystemVolume) && bvr->biosdev != gBIOSDev) {␊
829␉␉␉␉␉␉gBootVolume = bvr;␊
830␉␉␉␉␉}␊
831␉␉␉␉}␊
832␉␉␉}␊
833␉␉␉goto done;␊
834␉␉}␊
835␉}␊
836␊
837␉if (gBootMode & kBootModeQuiet) {␊
838␉␉// No input allowed from user.␊
839␉␉goto done;␊
840␉}␊
841␊
842␉if (firstRun && timeout > 0 && countdown("Press any key to enter startup options.", kMenuTopRow, timeout) == 0) {␊
843␉␉// If the user is holding down a modifier key,␊
844␉␉// enter safe mode.␊
845␉␉if ((readKeyboardShiftFlags() & 0x0F) != 0) {␊
846␉␉␉gBootMode |= kBootModeSafe;␊
847␉␉}␊
848␉␉goto done;␊
849␉}␊
850␊
851␉if (gDeviceCount) {␊
852␉␉// Allocate memory for an array of menu items.␊
853␉␉menuItems = malloc(sizeof(MenuItem) * gDeviceCount);␊
854␉␉if (menuItems == NULL) {␊
855␉␉␉goto done;␊
856␉␉}␊
857␊
858␉␉// Associate a menu item for each BVRef.␊
859␉␉for (bvr=bvChain, i=gDeviceCount-1, selectIndex=0; bvr; bvr=bvr->next) {␊
860␉␉␉if (bvr->visible) {␊
861␉␉␉␉getBootVolumeDescription(bvr, menuItems[i].name, sizeof(menuItems[i].name) - 1, true);␊
862␉␉␉␉menuItems[i].param = (void *) bvr;␊
863␉␉␉␉if (bvr == menuBVR) {␊
864␉␉␉␉␉selectIndex = i;␊
865␉␉␉␉}␊
866␉␉␉␉i--;␊
867␉␉␉}␊
868␉␉}␊
869␉}␊
870␊
871␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
872␉␉// redraw the background buffer␊
873␉␉gui.logo.draw = true;␊
874␉␉drawBackground();␊
875␉␉gui.devicelist.draw = true;␊
876␉␉gui.redraw = true;␊
877␉␉if (!(gBootMode & kBootModeQuiet)) {␊
878 ␊
879␉␉␉// Check if "Boot Banner"=N switch is present in config file.␊
880␉␉␉getBoolForKey(kBootBannerKey, &showBootBanner, &bootInfo->chameleonConfig); ␊
881␉␉␉if (showBootBanner) {␊
882␉␉␉␉// Display banner and show hardware info.␊
883␉␉␉␉gprintf(&gui.screen, bootBanner + 1, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
884␉␉␉}␊
885␊
886␉␉␉// redraw background␊
887␉␉␉memcpy(gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4);␊
888␉␉}␊
889␉} else {␊
890␉␉// Clear screen and hide the blinking cursor.␊
891␉␉clearScreenRows(kMenuTopRow, kMenuTopRow + 2);␊
892␉␉changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);␊
893␉}␊
894␊
895␉nextRow = kMenuTopRow;␊
896␉showPrompt = true;␊
897␊
898␉if (gDeviceCount) {␊
899␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE ) {␊
900␉␉␉printf("Use \30\31 keys to select the startup volume.");␊
901␉␉}␊
902␉␉showMenu( menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems );␊
903␉␉nextRow += MIN( gDeviceCount, kMenuMaxItems ) + 3;␊
904␉}␊
905␊
906␉// Show the boot prompt.␊
907␉showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
908␉showBootPrompt( nextRow, showPrompt );␊
909␉␊
910␉do {␊
911␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
912␉␉␉// redraw background␊
913␉␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
914␉␉␉// reset cursor co-ords␊
915␉␉␉gui.debug.cursor = pos( gui.screen.width - 160 , 10 );␊
916␉␉}␊
917␉␉key = getchar();␊
918␉␉updateMenu( key, (void **) &menuBVR );␊
919␉␉newShowPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
920␊
921␉␉if (newShowPrompt != showPrompt) {␊
922␉␉␉showPrompt = newShowPrompt;␊
923␉␉␉showBootPrompt( nextRow, showPrompt );␊
924␉␉}␊
925␊
926␉␉if (showPrompt) {␊
927␉␉␉updateBootArgs(key);␊
928␉␉}␊
929␊
930␉␉switch (key) {␊
931␉␉case KEY_ENTER:␊
932␉␉␉if (gui.menu.draw) { ␊
933␉␉␉␉key=0;␊
934␉␉␉␉break;␊
935␉␉␉}␊
936␉␉␉if (*gBootArgs == '?') {␊
937␉␉␉␉char * argPtr = gBootArgs;␊
938␊
939␉␉␉␉// Skip the leading "?" character.␊
940␉␉␉␉argPtr++;␊
941␉␉␉␉getNextArg(&argPtr, booterCommand);␊
942␉␉␉␉getNextArg(&argPtr, booterParam);␊
943␊
944␉␉␉␉/*␊
945␉␉␉␉* TODO: this needs to be refactored.␊
946␉␉␉␉*/␊
947␉␉␉␉if (strcmp( booterCommand, "video" ) == 0) {␊
948␉␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
949␉␉␉␉␉␉showInfoBox(getVBEInfoString(), getVBEModeInfoString());␊
950␉␉␉␉␉} else {␊
951␉␉␉␉␉␉printVBEModeInfo();␊
952␉␉␉␉␉}␊
953␉␉␉␉} else if ( strcmp( booterCommand, "memory" ) == 0) {␊
954␉␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE ) {␊
955␉␉␉␉␉␉showInfoBox("Memory Map", getMemoryInfoString());␊
956␉␉␉␉␉} else {␊
957␉␉␉␉␉␉printMemoryInfo();␊
958␉␉␉␉␉}␊
959␉␉␉␉} else if (strcmp(booterCommand, "lspci") == 0) {␊
960␉␉␉␉␉lspci();␊
961␉␉␉␉} else if (strcmp(booterCommand, "more") == 0) {␊
962␉␉␉␉␉showTextFile(booterParam);␊
963␉␉␉␉} else if (strcmp(booterCommand, "rd") == 0) {␊
964␉␉␉␉␉processRAMDiskCommand(&argPtr, booterParam);␊
965␉␉␉␉} else if (strcmp(booterCommand, "norescan") == 0) {␊
966␉␉␉␉␉if (gEnableCDROMRescan) {␊
967␉␉␉␉␉␉gEnableCDROMRescan = false;␊
968␉␉␉␉␉␉break;␊
969␉␉␉␉␉}␊
970␉␉␉␉} else {␊
971␉␉␉␉␉showHelp();␊
972␉␉␉␉}␊
973␉␉␉␉key = 0;␊
974␉␉␉␉showBootPrompt(nextRow, showPrompt);␊
975␉␉␉␉break;␊
976␉␉␉}␊
977␉␉␉gBootVolume = menuBVR;␊
978␉␉␉setRootVolume(menuBVR);␊
979␉␉␉gBIOSDev = menuBVR->biosdev;␊
980␉␉␉break;␊
981␊
982␉␉case KEY_ESC:␊
983␉␉␉clearBootArgs();␊
984␉␉␉break;␊
985␊
986␉␉case KEY_F5:␊
987␉␉␉// New behavior:␊
988␉␉␉// Clear gBootVolume to restart the loop␊
989␉␉␉// if the user enabled rescanning the optical drive.␊
990␉␉␉// Otherwise boot the default boot volume.␊
991␉␉␉if (gEnableCDROMRescan) {␊
992␉␉␉␉gBootVolume = NULL;␊
993␉␉␉␉clearBootArgs();␊
994␉␉␉}␊
995␉␉␉break;␊
996␊
997␉␉case KEY_F10:␊
998␉␉␉gScanSingleDrive = false;␊
999␉␉␉scanDisks(gBIOSDev, &bvCount);␊
1000␉␉␉gBootVolume = NULL;␊
1001␉␉␉clearBootArgs();␊
1002␉␉␉break;␊
1003␊
1004␉␉case KEY_TAB:␊
1005␉␉␉// New behavior:␊
1006␉␉␉// Switch between text & graphic interfaces␊
1007␉␉␉// Only Permitted if started in graphics interface␊
1008␉␉␉if (useGUI) {␊
1009␉␉␉␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1010␉␉␉␉␉setVideoMode(VGA_TEXT_MODE, 0);␊
1011␊
1012␉␉␉␉␉setCursorPosition(0, 0, 0);␊
1013␉␉␉␉␉clearScreenRows(0, kScreenLastRow);␊
1014␊
1015␉␉␉␉␉// Display banner and show hardware info.␊
1016␉␉␉␉␉printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);␊
1017␉␉␉␉␉printf(getVBEInfoString());␊
1018␊
1019␉␉␉␉␉clearScreenRows(kMenuTopRow, kMenuTopRow + 2);␊
1020␉␉␉␉␉changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);␊
1021␊
1022␉␉␉␉␉nextRow = kMenuTopRow;␊
1023␉␉␉␉␉showPrompt = true;␊
1024␊
1025␉␉␉␉␉if (gDeviceCount) {␊
1026␉␉␉␉␉␉printf("Use \30\31 keys to select the startup volume.");␊
1027␉␉␉␉␉␉showMenu(menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems);␊
1028␉␉␉␉␉␉nextRow += MIN(gDeviceCount, kMenuMaxItems) + 3;␊
1029␉␉␉␉␉}␊
1030␊
1031␉␉␉␉␉showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);␊
1032␉␉␉␉␉showBootPrompt(nextRow, showPrompt);␊
1033␉␉␉␉␉//changeCursor( 0, kMenuTopRow, kCursorTypeUnderline, 0 );␊
1034␉␉␉␉} else {␊
1035␉␉␉␉␉gui.redraw = true;␊
1036␉␉␉␉␉setVideoMode(GRAPHICS_MODE, 0);␊
1037␉␉␉␉␉updateVRAM();␊
1038 updateGraphicBootPrompt();␊
1039␉␉␉␉}␊
1040␉␉␉}␊
1041␉␉␉key = 0;␊
1042␉␉␉break;␊
1043␊
1044␉␉default:␊
1045␉␉␉key = 0;␊
1046␉␉␉break;␊
1047␉␉}␊
1048␉} while (0 == key);␊
1049␊
1050done:␊
1051␉if (bootArgs->Video.v_display == VGA_TEXT_MODE) {␊
1052␉␉clearScreenRows(kMenuTopRow, kScreenLastRow);␊
1053␉␉changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);␊
1054␉}␊
1055␉shouldboot = false;␊
1056␉gui.menu.draw = false;␊
1057␉if (menuItems) {␊
1058␉␉free(menuItems);␊
1059␉␉menuItems = NULL;␊
1060␉}␊
1061 execute_hook("BootOptions", NULL, NULL, NULL, NULL);␊
1062␉return 0;␊
1063}␊
1064␊
1065//==========================================================================␊
1066␊
1067char gBootUUIDString[32+4+1] = ""; // UUID of the boot volume e.g. 5EB1869F-C4FA-3502-BDEB-3B8ED5D87292␊
1068extern unsigned char chainbootdev;␊
1069extern unsigned char chainbootflag;␊
1070␊
1071bool copyArgument(const char *argName, const char *val, int cnt, char **argP, int *cntRemainingP)␊
1072{␊
1073 int argLen = argName ? strlen(argName) : 0;␊
1074 int len = argLen + cnt + 1; // +1 to account for space␊
1075␊
1076␉if (argName)␊
1077␉␉len++; // +1 to account for '='␊
1078␊
1079 if (len > *cntRemainingP) {␊
1080 error("Warning: boot arguments too long, truncating\n");␊
1081 return false;␊
1082 }␊
1083␊
1084 if (argName) {␊
1085 strncpy( *argP, argName, argLen );␊
1086 *argP += argLen;␊
1087 *argP[0] = '=';␊
1088 (*argP)++;␊
1089 }␊
1090␊
1091 strncpy( *argP, val, cnt );␊
1092 *argP += cnt;␊
1093 *argP[0] = ' ';␊
1094 (*argP)++;␊
1095␊
1096 *cntRemainingP -= len;␊
1097 return true;␊
1098}␊
1099␊
1100// ␊
1101// Returns TRUE if an argument was copied, FALSE otherwise␊
1102bool␊
1103processBootArgument(␊
1104 const char *argName, // The argument to search for␊
1105 const char *userString, // Typed-in boot arguments␊
1106 const char *kernelFlags, // Kernel flags from config table␊
1107 const char *configTable,␊
1108 char **argP, // Output value␊
1109 int *cntRemainingP, // Output count␊
1110 char *foundVal, // found value␊
1111 int foundValSize // max found value size␊
1112 )␊
1113{␊
1114 const char *val;␊
1115 int cnt;␊
1116 bool found = false;␊
1117␊
1118 if (getValueForBootKey(userString, argName, &val, &cnt)) {␊
1119 // Don't copy; these values will be copied at the end of argument processing.␊
1120 found = true;␊
1121 } else if (getValueForBootKey(kernelFlags, argName, &val, &cnt)) {␊
1122 // Don't copy; these values will be copied at the end of argument processing.␊
1123 found = true;␊
1124 } else if (getValueForKey(argName, &val, &cnt, &bootInfo->chameleonConfig)) {␊
1125 copyArgument(argName, val, cnt, argP, cntRemainingP);␊
1126 found = true;␊
1127 }␊
1128 if (found && foundVal)␊
1129 strlcpy(foundVal, val, foundValSize);␊
1130 return found;␊
1131}␊
1132␊
1133// Maximum config table value size␊
1134#define VALUE_SIZE 2048␊
1135␊
1136int␊
1137processBootOptions()␊
1138{␊
1139 const char *cp = gBootArgs;␊
1140 const char *val = 0;␊
1141 const char *kernel;␊
1142 int cnt;␊
1143 int userCnt;␊
1144 int cntRemaining;␊
1145 char *argP;␊
1146 char *configKernelFlags;␊
1147 char *valueBuffer;␊
1148␊
1149 valueBuffer = malloc(VALUE_SIZE);␊
1150 ␊
1151 skipblanks( &cp );␊
1152␊
1153 // Update the unit and partition number.␊
1154␊
1155 if ( gBootVolume )␊
1156 {␊
1157 if (!( gBootVolume->flags & kBVFlagNativeBoot ))␊
1158 {␊
1159 readBootSector( gBootVolume->biosdev, gBootVolume->part_boff,␊
1160 (void *) 0x7c00 );␊
1161␊
1162 //␊
1163 // Setup edx, and signal intention to chain load the␊
1164 // foreign booter.␊
1165 //␊
1166␊
1167 chainbootdev = gBootVolume->biosdev;␊
1168 chainbootflag = 1;␊
1169␊
1170 return 1;␊
1171 }␊
1172␊
1173 setRootVolume(gBootVolume);␊
1174␊
1175 }␊
1176 // If no boot volume fail immediately because we're just going to fail␊
1177 // trying to load the config file anyway.␊
1178 else␊
1179 return -1;␊
1180␊
1181 // Load config table specified by the user, or use the default.␊
1182␊
1183 if (!getValueForBootKey(cp, "config", &val, &cnt)) {␊
1184 val = 0;␊
1185 cnt = 0;␊
1186 }␊
1187␊
1188 // Load com.apple.Boot.plist from the selected volume␊
1189 // and use its contents to override default bootConfig.␊
1190␊
1191 loadSystemConfig(&bootInfo->bootConfig); ␊
1192 loadChameleonConfig(&bootInfo->chameleonConfig);␊
1193␊
1194 // Use the kernel name specified by the user, or fetch the name␊
1195 // in the config table, or use the default if not specified.␊
1196 // Specifying a kernel name on the command line, or specifying␊
1197 // a non-default kernel name in the config file counts as␊
1198 // overriding the kernel, which causes the kernelcache not␊
1199 // to be used.␊
1200␊
1201 gOverrideKernel = false;␊
1202 if (( kernel = extractKernelName((char **)&cp) )) {␊
1203 strlcpy( bootInfo->bootFile, kernel, sizeof(bootInfo->bootFile) );␊
1204 } else {␊
1205 if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) ) {␊
1206 strlcpy( bootInfo->bootFile, val, cnt+1 );␊
1207 } else {␊
1208 strlcpy( bootInfo->bootFile, kDefaultKernel, sizeof(bootInfo->bootFile) );␊
1209 }␊
1210 }␊
1211␉if (strcmp( bootInfo->bootFile, kDefaultKernel ) != 0) {␊
1212␉␉gOverrideKernel = true;␊
1213␉}␊
1214␊
1215 cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space␊
1216 argP = bootArgs->CommandLine;␊
1217␊
1218␉// Get config kernel flags, if not ignored.␊
1219 if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) ||␊
1220 !getValueForKey( kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig )) {␊
1221 val = "";␊
1222 cnt = 0;␊
1223 }␊
1224 configKernelFlags = malloc(cnt + 1);␊
1225 strlcpy(configKernelFlags, val, cnt + 1);␊
1226␊
1227 // boot-uuid can be set either on the command-line or in the config file␊
1228␉if (!processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config,␊
1229 &argP, &cntRemaining, gBootUUIDString, sizeof(gBootUUIDString))) {␊
1230 //␊
1231 // Try an alternate method for getting the root UUID on boot helper partitions.␊
1232 //␊
1233 if (gBootVolume->flags & kBVFlagBooter)␊
1234␉␉{␊
1235␉␉␉// Load the configuration store in the boot helper partition␊
1236␉␉␉if (loadHelperConfig(&bootInfo->helperConfig) == 0)␊
1237 ␉{␊
1238␉␉␉␉val = getStringForKey(kHelperRootUUIDKey, &bootInfo->helperConfig);␊
1239␉␉␉␉if (val != NULL)␊
1240␉␉␉␉␉strlcpy(gBootUUIDString, val, sizeof(gBootUUIDString));␊
1241␉␉␉}␊
1242 }␊
1243 ␊
1244 // Try to get the volume uuid string␊
1245␉␉if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)␊
1246␉␉␉gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);␊
1247 ␊
1248␉␉// If we have the volume uuid add it to the commandline arguments␊
1249␉␉if (strlen(gBootUUIDString))␊
1250␉␉␉copyArgument(kBootUUIDKey, gBootUUIDString, strlen(gBootUUIDString), &argP, &cntRemaining);␊
1251␉}␊
1252␊
1253 if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config,␊
1254 &argP, &cntRemaining, gRootDevice, ROOT_DEVICE_SIZE)) {␊
1255 cnt = 0;␊
1256 if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->chameleonConfig)) {␊
1257 valueBuffer[0] = '*';␊
1258 cnt++;␊
1259 strlcpy(valueBuffer + 1, val, cnt);␊
1260 val = valueBuffer;␊
1261 } else {␊
1262 if (strlen(gBootUUIDString)) {␊
1263 val = "*uuid";␊
1264 cnt = 5;␊
1265 } else {␊
1266 // Don't set "rd=.." if there is no boot device key␊
1267 // and no UUID.␊
1268 val = "";␊
1269 cnt = 0;␊
1270 }␊
1271 } ␊
1272 if (cnt > 0) {␊
1273 copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);␊
1274 }␊
1275 strlcpy( gRootDevice, val, (cnt + 1));␊
1276 }␊
1277␊
1278 /*␊
1279 * Removed. We don't need this anymore.␊
1280 *␊
1281 if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config,␊
1282␉␉␉␉␉␉␉ &argP, &cntRemaining, gPlatformName, sizeof(gCacheNameAdler))) {␊
1283 getPlatformName(gPlatformName);␊
1284 copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);␊
1285 }␊
1286 */␊
1287␊
1288 if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
1289 !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {␊
1290 if (gBootMode & kBootModeSafe) {␊
1291 copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);␊
1292 }␊
1293 }␊
1294␊
1295 // Store the merged kernel flags and boot args.␊
1296␊
1297 cnt = strlen(configKernelFlags);␊
1298 if (cnt) {␊
1299 if (cnt > cntRemaining) {␊
1300 error("Warning: boot arguments too long, truncating\n");␊
1301 cnt = cntRemaining;␊
1302 }␊
1303 strncpy(argP, configKernelFlags, cnt);␊
1304 argP[cnt++] = ' ';␊
1305 cntRemaining -= cnt;␊
1306 }␊
1307 userCnt = strlen(cp);␊
1308 if (userCnt > cntRemaining) {␊
1309 error("Warning: boot arguments too long, truncating\n");␊
1310 userCnt = cntRemaining;␊
1311 }␊
1312 strncpy(&argP[cnt], cp, userCnt);␊
1313 argP[cnt+userCnt] = '\0';␊
1314␊
1315␉if(!shouldboot)␊
1316␉{␊
1317␉␉gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ||␊
1318␉␉␉getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->chameleonConfig );␊
1319␉␉␊
1320␉␉gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) ?␊
1321␉␉␉kBootModeSafe : kBootModeNormal;␊
1322␊
1323 if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) {␊
1324 gBootMode = kBootModeSafe;␊
1325 }␊
1326␉}␊
1327␊
1328␉if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )␊
1329␉␉strlcpy(gMKextName, val, cnt + 1);␊
1330␉else␊
1331␉␉gMKextName[0]=0;␊
1332␊
1333 free(configKernelFlags);␊
1334 free(valueBuffer);␊
1335␊
1336 return 0;␊
1337}␊
1338␊
1339␊
1340//==========================================================================␊
1341// Load the help file and display the file contents on the screen.␊
1342␊
1343void showTextBuffer(char *buf_orig, int size)␊
1344{␊
1345␉char␉*bp;␊
1346␉char* buf;␊
1347␉int␉line;␊
1348␉int␉line_offset;␊
1349␉int␉c;␊
1350␊
1351␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1352␉␉showInfoBox( "Press q to continue, space for next page.\n",buf_orig );␊
1353␉␉return;␊
1354␉}␊
1355␉␊
1356␉␉// Create a copy so that we don't mangle the original␊
1357␉␉buf = malloc(size + 1);␊
1358␉␉memcpy(buf, buf_orig, size);␊
1359␉␊
1360␊
1361 bp = buf;␊
1362 while (size-- > 0) {␊
1363␉␉if (*bp == '\n') {␊
1364␉␉␉*bp = '\0';␊
1365␉␉}␊
1366␉␉bp++;␊
1367 }␊
1368 *bp = '\1';␊
1369 line_offset = 0;␊
1370␊
1371 setActiveDisplayPage(1);␊
1372␊
1373 while (1) {␊
1374␉␉clearScreenRows(0, 24);␊
1375␉␉setCursorPosition(0, 0, 1);␊
1376␉␉bp = buf;␊
1377␉␉for (line = 0; *bp != '\1' && line < line_offset; line++) {␊
1378␉␉␉while (*bp != '\0') {␊
1379␉␉␉␉bp++;␊
1380␉␉␉}␊
1381␉␉␉bp++;␊
1382␉␉}␊
1383␉␉for (line = 0; *bp != '\1' && line < 23; line++) {␊
1384␉␉␉setCursorPosition(0, line, 1);␊
1385␉␉␉printf("%s\n", bp);␊
1386␉␉␉while (*bp != '\0') {␊
1387␉␉␉␉bp++;␊
1388␉␉␉}␊
1389␉␉␉bp++;␊
1390␉␉}␊
1391␊
1392␉␉setCursorPosition(0, 23, 1);␊
1393␉␉if (*bp == '\1') {␊
1394␉␉␉printf("[Type %sq or space to quit viewer]", (line_offset > 0) ? "p for previous page, " : "");␊
1395␉␉} else {␊
1396␉␉␉printf("[Type %s%sq to quit viewer]", (line_offset > 0) ? "p for previous page, " : "", (*bp != '\1') ? "space for next page, " : "");␊
1397␉␉}␊
1398␊
1399␉␉c = getchar();␊
1400␉␉if (c == 'q' || c == 'Q') {␊
1401␉␉␉break;␊
1402␉␉}␊
1403␉␉if ((c == 'p' || c == 'P') && line_offset > 0) {␊
1404␉␉␉line_offset -= 23;␊
1405␉␉}␊
1406␉␉if (c == ' ') {␊
1407␉␉␉if (*bp == '\1') {␊
1408␉␉␉␉break;␊
1409␉␉␉} else {␊
1410␉␉␉␉line_offset += 23;␊
1411␉␉␉}␊
1412␉␉}␊
1413 }␊
1414 setActiveDisplayPage(0);␊
1415}␊
1416␊
1417void showHelp(void)␊
1418{␊
1419␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1420␉␉showInfoBox("Help. Press q to quit.\n", (char *)BootHelp_txt);␊
1421␉} else {␊
1422␉␉showTextBuffer((char *)BootHelp_txt, BootHelp_txt_len);␊
1423␉}␊
1424}␊
1425␊
1426void showTextFile(const char * filename)␊
1427{␊
1428#define MAX_TEXT_FILE_SIZE 65536␊
1429␉char␉*buf;␊
1430␉int␉fd;␊
1431␉int␉size;␊
1432 ␊
1433␉if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0) {␊
1434␉␉printf("\nFile not found: %s\n", filename);␊
1435␉␉sleep(2);␊
1436␉␉return;␊
1437␉}␊
1438␊
1439 size = file_size(fd);␊
1440 if (size > MAX_TEXT_FILE_SIZE) {␊
1441␉␉size = MAX_TEXT_FILE_SIZE;␊
1442␉}␊
1443 buf = malloc(size);␊
1444 read(fd, buf, size);␊
1445 close(fd);␊
1446␉showTextBuffer(buf, size);␊
1447␉free(buf);␊
1448}␊
1449␊
1450// This is a very simplistic prompting scheme that just grabs two hex characters␊
1451// Eventually we need to do something more user-friendly like display a menu␊
1452// based off of the Multiboot device list␊
1453␊
1454int selectAlternateBootDevice(int bootdevice)␊
1455{␊
1456␉int key;␊
1457␉int newbootdevice;␊
1458␉int digitsI = 0;␊
1459␉char *end;␊
1460␉char digits[3] = {0,0,0};␊
1461␊
1462␉// We've already printed the current boot device so user knows what it is␊
1463␉printf("Typical boot devices are 80 (First HD), 81 (Second HD)\n");␊
1464␉printf("Enter two-digit hexadecimal boot device [%02x]: ", bootdevice);␊
1465␉do {␊
1466␉␉key = getchar();␊
1467␉␉switch (ASCII_KEY(key)) {␊
1468␉␉case KEY_BKSP:␊
1469␉␉␉if (digitsI > 0) {␊
1470␉␉␉␉int x, y, t;␊
1471␉␉␉␉getCursorPositionAndType(&x, &y, &t);␊
1472␉␉␉␉// Assume x is not 0;␊
1473␉␉␉␉x--;␊
1474␉␉␉␉setCursorPosition(x,y,0); // back up one char␊
1475␉␉␉␉// Overwrite with space without moving cursor position␊
1476␉␉␉␉putca(' ', 0x07, 1);␊
1477␉␉␉␉digitsI--;␊
1478␉␉␉} else {␊
1479␉␉␉␉// TODO: Beep or something␊
1480␉␉␉}␊
1481␉␉␉break;␊
1482␊
1483␉␉case KEY_ENTER:␊
1484␉␉␉digits[digitsI] = '\0';␊
1485␉␉␉newbootdevice = strtol(digits, &end, 16);␊
1486␉␉␉if (end == digits && *end == '\0') {␊
1487␉␉␉␉// User entered empty string␊
1488␉␉␉␉printf("\nUsing default boot device %x\n", bootdevice);␊
1489␉␉␉␉key = 0;␊
1490␉␉␉} else if(end != digits && *end == '\0') {␊
1491␉␉␉␉bootdevice = newbootdevice;␊
1492␉␉␉␉printf("\n");␊
1493␉␉␉␉key = 0; // We gots da boot device␊
1494␉␉␉} else {␊
1495␉␉␉␉printf("\nCouldn't parse. try again: ");␊
1496␉␉␉␉digitsI = 0;␊
1497␉␉␉}␊
1498␉␉␉break;␊
1499␊
1500␉␉default:␊
1501␉␉␉if (isxdigit(ASCII_KEY(key)) && digitsI < 2) {␊
1502␉␉␉␉putchar(ASCII_KEY(key));␊
1503␉␉␉␉digits[digitsI++] = ASCII_KEY(key);␊
1504␉␉␉} else {␊
1505␉␉␉␉// TODO: Beep or something␊
1506␉␉␉}␊
1507␉␉␉break;␊
1508␉␉};␊
1509␉} while (key != 0);␊
1510␊
1511␉return bootdevice;␊
1512}␊
1513␊
1514bool promptForRescanOption(void)␊
1515{␊
1516␉printf("\nWould you like to enable media rescan option?\nPress ENTER to enable or any key to skip.\n");␊
1517␉if (getchar() == KEY_ENTER) {␊
1518␉␉return true;␊
1519␉} else {␊
1520␉␉return false;␊
1521␉}␊
1522}␊
1523

Archive Download this file

Revision: 2166