Chameleon

Chameleon Svn Source Tree

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

Archive Download this file

Revision: 164