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␉return 0;␊
1062}␊
1063␊
1064//==========================================================================␊
1065␊
1066char gBootUUIDString[32+4+1] = ""; // UUID of the boot volume e.g. 5EB1869F-C4FA-3502-BDEB-3B8ED5D87292␊
1067extern unsigned char chainbootdev;␊
1068extern unsigned char chainbootflag;␊
1069␊
1070bool copyArgument(const char *argName, const char *val, int cnt, char **argP, int *cntRemainingP)␊
1071{␊
1072 int argLen = argName ? strlen(argName) : 0;␊
1073 int len = argLen + cnt + 1; // +1 to account for space␊
1074␊
1075␉if (argName)␊
1076␉␉len++; // +1 to account for '='␊
1077␊
1078 if (len > *cntRemainingP) {␊
1079 error("Warning: boot arguments too long, truncating\n");␊
1080 return false;␊
1081 }␊
1082␊
1083 if (argName) {␊
1084 strncpy( *argP, argName, argLen );␊
1085 *argP += argLen;␊
1086 *argP[0] = '=';␊
1087 (*argP)++;␊
1088 }␊
1089␊
1090 strncpy( *argP, val, cnt );␊
1091 *argP += cnt;␊
1092 *argP[0] = ' ';␊
1093 (*argP)++;␊
1094␊
1095 *cntRemainingP -= len;␊
1096 return true;␊
1097}␊
1098␊
1099// ␊
1100// Returns TRUE if an argument was copied, FALSE otherwise␊
1101bool␊
1102processBootArgument(␊
1103 const char *argName, // The argument to search for␊
1104 const char *userString, // Typed-in boot arguments␊
1105 const char *kernelFlags, // Kernel flags from config table␊
1106 const char *configTable,␊
1107 char **argP, // Output value␊
1108 int *cntRemainingP, // Output count␊
1109 char *foundVal, // found value␊
1110 int foundValSize // max found value size␊
1111 )␊
1112{␊
1113 const char *val;␊
1114 int cnt;␊
1115 bool found = false;␊
1116␊
1117 if (getValueForBootKey(userString, argName, &val, &cnt)) {␊
1118 // Don't copy; these values will be copied at the end of argument processing.␊
1119 found = true;␊
1120 } else if (getValueForBootKey(kernelFlags, argName, &val, &cnt)) {␊
1121 // Don't copy; these values will be copied at the end of argument processing.␊
1122 found = true;␊
1123 } else if (getValueForKey(argName, &val, &cnt, &bootInfo->chameleonConfig)) {␊
1124 copyArgument(argName, val, cnt, argP, cntRemainingP);␊
1125 found = true;␊
1126 }␊
1127 if (found && foundVal)␊
1128 strlcpy(foundVal, val, foundValSize);␊
1129 return found;␊
1130}␊
1131␊
1132// Maximum config table value size␊
1133#define VALUE_SIZE 2048␊
1134␊
1135int␊
1136processBootOptions()␊
1137{␊
1138 const char *cp = gBootArgs;␊
1139 const char *val = 0;␊
1140 const char *kernel;␊
1141 int cnt;␊
1142 int userCnt;␊
1143 int cntRemaining;␊
1144 char *argP;␊
1145 char *configKernelFlags;␊
1146 char *valueBuffer;␊
1147␊
1148 valueBuffer = malloc(VALUE_SIZE);␊
1149 ␊
1150 skipblanks( &cp );␊
1151␊
1152 // Update the unit and partition number.␊
1153␊
1154 if ( gBootVolume )␊
1155 {␊
1156 if (!( gBootVolume->flags & kBVFlagNativeBoot ))␊
1157 {␊
1158 readBootSector( gBootVolume->biosdev, gBootVolume->part_boff,␊
1159 (void *) 0x7c00 );␊
1160␊
1161 //␊
1162 // Setup edx, and signal intention to chain load the␊
1163 // foreign booter.␊
1164 //␊
1165␊
1166 chainbootdev = gBootVolume->biosdev;␊
1167 chainbootflag = 1;␊
1168␊
1169 return 1;␊
1170 }␊
1171␊
1172 setRootVolume(gBootVolume);␊
1173␊
1174 }␊
1175 // If no boot volume fail immediately because we're just going to fail␊
1176 // trying to load the config file anyway.␊
1177 else␊
1178 return -1;␊
1179␊
1180 // Load config table specified by the user, or use the default.␊
1181␊
1182 if (!getValueForBootKey(cp, "config", &val, &cnt)) {␊
1183 val = 0;␊
1184 cnt = 0;␊
1185 }␊
1186␊
1187 // Load com.apple.Boot.plist from the selected volume␊
1188 // and use its contents to override default bootConfig.␊
1189␊
1190 loadSystemConfig(&bootInfo->bootConfig); ␊
1191 loadChameleonConfig(&bootInfo->chameleonConfig);␊
1192␊
1193 // Use the kernel name specified by the user, or fetch the name␊
1194 // in the config table, or use the default if not specified.␊
1195 // Specifying a kernel name on the command line, or specifying␊
1196 // a non-default kernel name in the config file counts as␊
1197 // overriding the kernel, which causes the kernelcache not␊
1198 // to be used.␊
1199␊
1200 gOverrideKernel = false;␊
1201 if (( kernel = extractKernelName((char **)&cp) )) {␊
1202 strlcpy( bootInfo->bootFile, kernel, sizeof(bootInfo->bootFile) );␊
1203 } else {␊
1204 if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) ) {␊
1205 strlcpy( bootInfo->bootFile, val, cnt+1 );␊
1206 } else {␊
1207 strlcpy( bootInfo->bootFile, kDefaultKernel, sizeof(bootInfo->bootFile) );␊
1208 }␊
1209 }␊
1210␉if (strcmp( bootInfo->bootFile, kDefaultKernel ) != 0) {␊
1211␉␉gOverrideKernel = true;␊
1212␉}␊
1213␊
1214 cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space␊
1215 argP = bootArgs->CommandLine;␊
1216␊
1217␉// Get config kernel flags, if not ignored.␊
1218 if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) ||␊
1219 !getValueForKey( kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig )) {␊
1220 val = "";␊
1221 cnt = 0;␊
1222 }␊
1223 configKernelFlags = malloc(cnt + 1);␊
1224 strlcpy(configKernelFlags, val, cnt + 1);␊
1225␊
1226 // boot-uuid can be set either on the command-line or in the config file␊
1227␉if (!processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config,␊
1228 &argP, &cntRemaining, gBootUUIDString, sizeof(gBootUUIDString))) {␊
1229 //␊
1230 // Try an alternate method for getting the root UUID on boot helper partitions.␊
1231 //␊
1232 if (gBootVolume->flags & kBVFlagBooter)␊
1233␉␉{␊
1234␉␉␉// Load the configuration store in the boot helper partition␊
1235␉␉␉if (loadHelperConfig(&bootInfo->helperConfig) == 0)␊
1236 ␉{␊
1237␉␉␉␉val = getStringForKey(kHelperRootUUIDKey, &bootInfo->helperConfig);␊
1238␉␉␉␉if (val != NULL)␊
1239␉␉␉␉␉strlcpy(gBootUUIDString, val, sizeof(gBootUUIDString));␊
1240␉␉␉}␊
1241 }␊
1242 ␊
1243 // Try to get the volume uuid string␊
1244␉␉if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)␊
1245␉␉␉gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);␊
1246 ␊
1247␉␉// If we have the volume uuid add it to the commandline arguments␊
1248␉␉if (strlen(gBootUUIDString))␊
1249␉␉␉copyArgument(kBootUUIDKey, gBootUUIDString, strlen(gBootUUIDString), &argP, &cntRemaining);␊
1250␉}␊
1251␊
1252 if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config,␊
1253 &argP, &cntRemaining, gRootDevice, ROOT_DEVICE_SIZE)) {␊
1254 cnt = 0;␊
1255 if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->chameleonConfig)) {␊
1256 valueBuffer[0] = '*';␊
1257 cnt++;␊
1258 strlcpy(valueBuffer + 1, val, cnt);␊
1259 val = valueBuffer;␊
1260 } else {␊
1261 if (strlen(gBootUUIDString)) {␊
1262 val = "*uuid";␊
1263 cnt = 5;␊
1264 } else {␊
1265 // Don't set "rd=.." if there is no boot device key␊
1266 // and no UUID.␊
1267 val = "";␊
1268 cnt = 0;␊
1269 }␊
1270 } ␊
1271 if (cnt > 0) {␊
1272 copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);␊
1273 }␊
1274 strlcpy( gRootDevice, val, (cnt + 1));␊
1275 }␊
1276␊
1277 /*␊
1278 * Removed. We don't need this anymore.␊
1279 *␊
1280 if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config,␊
1281␉␉␉␉␉␉␉ &argP, &cntRemaining, gPlatformName, sizeof(gCacheNameAdler))) {␊
1282 getPlatformName(gPlatformName);␊
1283 copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);␊
1284 }␊
1285 */␊
1286␊
1287 if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
1288 !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {␊
1289 if (gBootMode & kBootModeSafe) {␊
1290 copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);␊
1291 }␊
1292 }␊
1293␊
1294 // Store the merged kernel flags and boot args.␊
1295␊
1296 cnt = strlen(configKernelFlags);␊
1297 if (cnt) {␊
1298 if (cnt > cntRemaining) {␊
1299 error("Warning: boot arguments too long, truncating\n");␊
1300 cnt = cntRemaining;␊
1301 }␊
1302 strncpy(argP, configKernelFlags, cnt);␊
1303 argP[cnt++] = ' ';␊
1304 cntRemaining -= cnt;␊
1305 }␊
1306 userCnt = strlen(cp);␊
1307 if (userCnt > cntRemaining) {␊
1308 error("Warning: boot arguments too long, truncating\n");␊
1309 userCnt = cntRemaining;␊
1310 }␊
1311 strncpy(&argP[cnt], cp, userCnt);␊
1312 argP[cnt+userCnt] = '\0';␊
1313␊
1314␉if(!shouldboot)␊
1315␉{␊
1316␉␉gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ||␊
1317␉␉␉getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->chameleonConfig );␊
1318␉␉␊
1319␉␉gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) ?␊
1320␉␉␉kBootModeSafe : kBootModeNormal;␊
1321␊
1322 if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) {␊
1323 gBootMode = kBootModeSafe;␊
1324 }␊
1325␉}␊
1326␊
1327␉if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )␊
1328␉␉strlcpy(gMKextName, val, cnt + 1);␊
1329␉else␊
1330␉␉gMKextName[0]=0;␊
1331␊
1332 free(configKernelFlags);␊
1333 free(valueBuffer);␊
1334␊
1335 return 0;␊
1336}␊
1337␊
1338␊
1339//==========================================================================␊
1340// Load the help file and display the file contents on the screen.␊
1341␊
1342void showTextBuffer(char *buf_orig, int size)␊
1343{␊
1344␉char␉*bp;␊
1345␉char* buf;␊
1346␉int␉line;␊
1347␉int␉line_offset;␊
1348␉int␉c;␊
1349␊
1350␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1351␉␉showInfoBox( "Press q to continue, space for next page.\n",buf_orig );␊
1352␉␉return;␊
1353␉}␊
1354␉␊
1355␉␉// Create a copy so that we don't mangle the original␊
1356␉␉buf = malloc(size + 1);␊
1357␉␉memcpy(buf, buf_orig, size);␊
1358␉␊
1359␊
1360 bp = buf;␊
1361 while (size-- > 0) {␊
1362␉␉if (*bp == '\n') {␊
1363␉␉␉*bp = '\0';␊
1364␉␉}␊
1365␉␉bp++;␊
1366 }␊
1367 *bp = '\1';␊
1368 line_offset = 0;␊
1369␊
1370 setActiveDisplayPage(1);␊
1371␊
1372 while (1) {␊
1373␉␉clearScreenRows(0, 24);␊
1374␉␉setCursorPosition(0, 0, 1);␊
1375␉␉bp = buf;␊
1376␉␉for (line = 0; *bp != '\1' && line < line_offset; line++) {␊
1377␉␉␉while (*bp != '\0') {␊
1378␉␉␉␉bp++;␊
1379␉␉␉}␊
1380␉␉␉bp++;␊
1381␉␉}␊
1382␉␉for (line = 0; *bp != '\1' && line < 23; line++) {␊
1383␉␉␉setCursorPosition(0, line, 1);␊
1384␉␉␉printf("%s\n", bp);␊
1385␉␉␉while (*bp != '\0') {␊
1386␉␉␉␉bp++;␊
1387␉␉␉}␊
1388␉␉␉bp++;␊
1389␉␉}␊
1390␊
1391␉␉setCursorPosition(0, 23, 1);␊
1392␉␉if (*bp == '\1') {␊
1393␉␉␉printf("[Type %sq or space to quit viewer]", (line_offset > 0) ? "p for previous page, " : "");␊
1394␉␉} else {␊
1395␉␉␉printf("[Type %s%sq to quit viewer]", (line_offset > 0) ? "p for previous page, " : "", (*bp != '\1') ? "space for next page, " : "");␊
1396␉␉}␊
1397␊
1398␉␉c = getchar();␊
1399␉␉if (c == 'q' || c == 'Q') {␊
1400␉␉␉break;␊
1401␉␉}␊
1402␉␉if ((c == 'p' || c == 'P') && line_offset > 0) {␊
1403␉␉␉line_offset -= 23;␊
1404␉␉}␊
1405␉␉if (c == ' ') {␊
1406␉␉␉if (*bp == '\1') {␊
1407␉␉␉␉break;␊
1408␉␉␉} else {␊
1409␉␉␉␉line_offset += 23;␊
1410␉␉␉}␊
1411␉␉}␊
1412 }␊
1413 setActiveDisplayPage(0);␊
1414}␊
1415␊
1416void showHelp(void)␊
1417{␊
1418␉if (bootArgs->Video.v_display != VGA_TEXT_MODE) {␊
1419␉␉showInfoBox("Help. Press q to quit.\n", (char *)BootHelp_txt);␊
1420␉} else {␊
1421␉␉showTextBuffer((char *)BootHelp_txt, BootHelp_txt_len);␊
1422␉}␊
1423}␊
1424␊
1425void showTextFile(const char * filename)␊
1426{␊
1427#define MAX_TEXT_FILE_SIZE 65536␊
1428␉char␉*buf;␊
1429␉int␉fd;␊
1430␉int␉size;␊
1431 ␊
1432␉if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0) {␊
1433␉␉printf("\nFile not found: %s\n", filename);␊
1434␉␉sleep(2);␊
1435␉␉return;␊
1436␉}␊
1437␊
1438 size = file_size(fd);␊
1439 if (size > MAX_TEXT_FILE_SIZE) {␊
1440␉␉size = MAX_TEXT_FILE_SIZE;␊
1441␉}␊
1442 buf = malloc(size);␊
1443 read(fd, buf, size);␊
1444 close(fd);␊
1445␉showTextBuffer(buf, size);␊
1446␉free(buf);␊
1447}␊
1448␊
1449// This is a very simplistic prompting scheme that just grabs two hex characters␊
1450// Eventually we need to do something more user-friendly like display a menu␊
1451// based off of the Multiboot device list␊
1452␊
1453int selectAlternateBootDevice(int bootdevice)␊
1454{␊
1455␉int key;␊
1456␉int newbootdevice;␊
1457␉int digitsI = 0;␊
1458␉char *end;␊
1459␉char digits[3] = {0,0,0};␊
1460␊
1461␉// We've already printed the current boot device so user knows what it is␊
1462␉printf("Typical boot devices are 80 (First HD), 81 (Second HD)\n");␊
1463␉printf("Enter two-digit hexadecimal boot device [%02x]: ", bootdevice);␊
1464␉do {␊
1465␉␉key = getchar();␊
1466␉␉switch (ASCII_KEY(key)) {␊
1467␉␉case KEY_BKSP:␊
1468␉␉␉if (digitsI > 0) {␊
1469␉␉␉␉int x, y, t;␊
1470␉␉␉␉getCursorPositionAndType(&x, &y, &t);␊
1471␉␉␉␉// Assume x is not 0;␊
1472␉␉␉␉x--;␊
1473␉␉␉␉setCursorPosition(x,y,0); // back up one char␊
1474␉␉␉␉// Overwrite with space without moving cursor position␊
1475␉␉␉␉putca(' ', 0x07, 1);␊
1476␉␉␉␉digitsI--;␊
1477␉␉␉} else {␊
1478␉␉␉␉// TODO: Beep or something␊
1479␉␉␉}␊
1480␉␉␉break;␊
1481␊
1482␉␉case KEY_ENTER:␊
1483␉␉␉digits[digitsI] = '\0';␊
1484␉␉␉newbootdevice = strtol(digits, &end, 16);␊
1485␉␉␉if (end == digits && *end == '\0') {␊
1486␉␉␉␉// User entered empty string␊
1487␉␉␉␉printf("\nUsing default boot device %x\n", bootdevice);␊
1488␉␉␉␉key = 0;␊
1489␉␉␉} else if(end != digits && *end == '\0') {␊
1490␉␉␉␉bootdevice = newbootdevice;␊
1491␉␉␉␉printf("\n");␊
1492␉␉␉␉key = 0; // We gots da boot device␊
1493␉␉␉} else {␊
1494␉␉␉␉printf("\nCouldn't parse. try again: ");␊
1495␉␉␉␉digitsI = 0;␊
1496␉␉␉}␊
1497␉␉␉break;␊
1498␊
1499␉␉default:␊
1500␉␉␉if (isxdigit(ASCII_KEY(key)) && digitsI < 2) {␊
1501␉␉␉␉putchar(ASCII_KEY(key));␊
1502␉␉␉␉digits[digitsI++] = ASCII_KEY(key);␊
1503␉␉␉} else {␊
1504␉␉␉␉// TODO: Beep or something␊
1505␉␉␉}␊
1506␉␉␉break;␊
1507␉␉};␊
1508␉} while (key != 0);␊
1509␊
1510␉return bootdevice;␊
1511}␊
1512␊
1513bool promptForRescanOption(void)␊
1514{␊
1515␉printf("\nWould you like to enable media rescan option?\nPress ENTER to enable or any key to skip.\n");␊
1516␉if (getchar() == KEY_ENTER) {␊
1517␉␉return true;␊
1518␉} else {␊
1519␉␉return false;␊
1520␉}␊
1521}␊
1522

Archive Download this file

Revision: 1742