Chameleon

Chameleon Svn Source Tree

Root/branches/azimutz/Cleancut/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, sizeof(dummy) - 1, true );
115drawDeviceIcon( gBootVolume, gui.screen.pixmap, p, true );
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
175char 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
191static void addBootArg(const char * argStr)
192{
193if ( (gBootArgsPtr + strlen(argStr) + 1) < gBootArgsEnd)
194{
195*gBootArgsPtr++ = ' ';
196strcat(gBootArgs, argStr);
197gBootArgsPtr += strlen(argStr);
198}
199}
200
201//==========================================================================
202
203static void showBootPrompt(int row, bool visible)
204{
205extern char bootPrompt[];
206extern char bootRescanPrompt[];
207
208if( bootArgs->Video.v_display == VGA_TEXT_MODE ) {
209changeCursor( strlen(gBootArgs), row, kCursorTypeUnderline, 0 );
210//clearScreenRows( row, kScreenLastRow );
211}
212
213//clearBootArgs();
214
215if (visible) {
216if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
217if (gEnableCDROMRescan) {
218printf( bootRescanPrompt );
219} else {
220printf( bootPrompt );
221 printf( gBootArgs );
222}
223}
224} else {
225if (bootArgs->Video.v_display == GRAPHICS_MODE) {
226//clearGraphicBootPrompt();
227} else {
228printf("Press Enter to start up the foreign OS. ");
229}
230}
231}
232
233//==========================================================================
234
235static void updateBootArgs( int key )
236{
237 key &= kASCIIKeyMask;
238
239 switch ( key )
240 {
241 case kBackspaceKey:
242 if ( gBootArgsPtr > gBootArgs )
243 {
244 int x, y, t;
245 getCursorPositionAndType( &x, &y, &t );
246 if ( x == 0 && y )
247 {
248 x = 80; y--;
249 }
250 if (x)
251x--;
252if( bootArgs->Video.v_display == VGA_TEXT_MODE )
253{
254setCursorPosition( x, y, 0 );
255putca(' ', 0x07, 1);
256}
257
258 *gBootArgsPtr-- = '\0';
259 updateGraphicBootPrompt(kBackspaceKey);
260 }
261 else
262 {
263 *gBootArgsPtr = '\0';
264 if( bootArgs->Video.v_display == VGA_TEXT_MODE ) putca(' ', 0x07, 1);
265 updateGraphicBootPrompt(kBackspaceKey);
266 }
267
268break;
269
270 default:
271 if ( key >= ' ' && gBootArgsPtr < gBootArgsEnd)
272 {
273 *gBootArgsPtr++ = key;
274 updateGraphicBootPrompt(key);
275}
276
277break;
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 )
316return;
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
341if ( gMenuSelection > gMenuEnd )
342 {
343gMenuStart += ( gMenuSelection - gMenuEnd );
344 gMenuEnd = gMenuSelection;
345 }
346
347// Draw the visible items.
348
349if( bootArgs->Video.v_display == GRAPHICS_MODE )
350
351drawDeviceList(gMenuStart, gMenuEnd, gMenuSelection);
352
353else {
354
355changeCursor( 0, row, kCursorTypeHidden, &cursorState );
356
357for ( i = gMenuTop; i <= gMenuBottom; i++ )
358{
359printMenuItem( &items[i], (i == gMenuSelection) );
360}
361
362restoreCursor( &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 )
384return 0;
385
386if( bootArgs->Video.v_display == GRAPHICS_MODE )
387{
388int res;
389
390// set navigation keys for horizontal layout as defaults
391int previous= 0x4B00;// left arrow
392int subsequent= 0x4D00;// right arrow
393int menu= 0x5000;// down arrow
394
395if ( gui.layout == VerticalLayout )
396{
397// set navigation keys for vertical layout
398previous= 0x4800;// up arrow
399subsequent= 0x5000;// down arrow
400menu= 0x4B00;// right arrow
401}
402
403if ( key == previous )
404{
405if ( gMenuSelection > gMenuTop )
406draw.f.selectionUp = 1;
407else if ( gMenuTop > 0 )
408draw.f.scrollDown = 1;
409
410}
411
412else if ( key == subsequent )
413{
414if ( gMenuSelection != gMenuBottom)
415draw.f.selectionDown = 1;
416else if ( gMenuBottom < ( gMenuItemCount - 1 ) )
417draw.f.scrollUp = 1;
418}
419
420else if ( key == menu )
421{
422if ( gui.menu.draw )
423updateInfoMenu(key);
424else
425drawInfoMenu();
426}
427
428else if ( gui.menu.draw )
429{
430res = updateInfoMenu(key);
431
432if ( res == CLOSE_INFO_MENU )
433gui.menu.draw = false;
434else
435{
436shouldboot = ( res != DO_NOT_BOOT );
437
438if ( shouldboot )
439gui.menu.draw = false;
440
441switch (res)
442{
443case BOOT_NORMAL:
444gVerboseMode = false;
445gBootMode = kBootModeNormal;
446break;
447
448case BOOT_VERBOSE:
449gVerboseMode = true;
450gBootMode = kBootModeNormal;
451addBootArg(kVerboseModeFlag);
452break;
453
454case BOOT_IGNORECACHE:
455gVerboseMode = false;
456gBootMode = kBootModeNormal;
457addBootArg(kIgnoreCachesFlag);
458break;
459
460case BOOT_SINGLEUSER:
461gVerboseMode = true;
462gBootMode = kBootModeNormal;
463addBootArg(kSingleUserModeFlag);
464break;
465}
466
467}
468
469}
470
471} else {
472switch ( key )
473{
474 case 0x4800: // Up Arrow
475if ( gMenuSelection != gMenuTop )
476draw.f.selectionUp = 1;
477else if ( gMenuTop > 0 )
478draw.f.scrollDown = 1;
479break;
480
481case 0x5000: // Down Arrow
482if ( gMenuSelection != gMenuBottom )
483draw.f.selectionDown = 1;
484else if ( gMenuBottom < (gMenuItemCount - 1) )
485draw.f.scrollUp = 1;
486break;
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++;
496gMenuStart++; 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
511CursorState cursorState;
512
513// Set cursor at current position, and clear inverse video.
514
515if( bootArgs->Video.v_display == VGA_TEXT_MODE )
516{
517changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop, kCursorTypeHidden, &cursorState );
518printMenuItem( &gMenuItems[gMenuSelection], 0 );
519}
520
521if ( draw.f.selectionUp )
522{
523gMenuSelection--;
524if(( gMenuSelection - gMenuStart) == -1 )
525{
526gMenuStart--;
527gMenuEnd--;
528}
529
530} else {
531gMenuSelection++;
532if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )
533{
534gMenuStart++;
535gMenuEnd++;
536}
537 }
538
539if( bootArgs->Video.v_display == VGA_TEXT_MODE )
540 {
541moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );
542printMenuItem( &gMenuItems[gMenuSelection], 1 );
543restoreCursor( &cursorState );
544
545 } else
546
547drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);
548
549}
550
551 *paramPtr = gMenuItems[gMenuSelection].param;
552 moved = 1;
553 }
554
555return 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;
643char *buff = malloc(sizeof(char)*1024);
644if(!buff) return 0;
645
646char info[] = "BIOS reported memory ranges:\n";
647sprintf(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 }
658return buff;
659}
660
661//==========================================================================
662
663void lspci(void)
664{
665if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
666setActiveDisplayPage(1);
667clearScreenRows(0, 24);
668setCursorPosition(0, 0, 1);
669}
670
671dump_pci_dt(root_pci_dev->children);
672
673pause();
674
675if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
676setActiveDisplayPage(0);
677}
678}
679
680//==========================================================================
681
682int getBootOptions(bool firstRun)
683{
684int i;
685int key;
686int nextRow;
687int timeout;
688int bvCount;
689BVRef bvr;
690BVRef menuBVR;
691bool showPrompt, newShowPrompt, isCDROM;
692
693// Initialize default menu selection entry.
694gBootVolume = menuBVR = selectBootVolume(bvChain);
695
696if (biosDevIsCDROM(gBIOSDev)) {
697isCDROM = true;
698} else {
699isCDROM = false;
700}
701
702// ensure we're in graphics mode if gui is setup
703if (gui.initialised && bootArgs->Video.v_display == VGA_TEXT_MODE)
704{
705setVideoMode(GRAPHICS_MODE, 0);
706}
707
708// Clear command line boot arguments
709clearBootArgs();
710
711// Allow user to override default timeout.
712if (multiboot_timeout_set) {
713timeout = multiboot_timeout;
714} else if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->bootConfig)) {
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 */
724if (isCDROM) {
725timeout = kCDBootTimeout;
726} else {
727timeout = sysConfigValid ? kBootTimeout : 0;
728}
729}
730
731if (timeout < 0) {
732gBootMode |= kBootModeQuiet;
733}
734
735// If the user is holding down a modifier key, enter safe mode.
736if ((readKeyboardShiftFlags() & 0x0F) != 0) {
737gBootMode |= kBootModeSafe;
738}
739
740// Checking user pressed keys
741bool f8press = false, spress = false, vpress = false;
742while (readKeyboardStatus()) {
743key = bgetc ();
744if (key == 0x4200) f8press = true;
745if ((key & 0xff) == 's' || (key & 0xff) == 'S') spress = true;
746if ((key & 0xff) == 'v' || (key & 0xff) == 'V') vpress = true;
747}
748// If user typed F8, abort quiet mode, and display the menu.
749if (f8press) {
750gBootMode &= ~kBootModeQuiet;
751timeout = 0;
752}
753// If user typed 'v' or 'V', boot in verbose mode.
754if ((gBootMode & kBootModeQuiet) && firstRun && vpress) {
755addBootArg(kVerboseModeFlag);
756}
757// If user typed 's' or 'S', boot in single user mode.
758if ((gBootMode & kBootModeQuiet) && firstRun && spress) {
759addBootArg(kSingleUserModeFlag);
760}
761
762if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
763setCursorPosition(0, 0, 0);
764clearScreenRows(0, kScreenLastRow);
765if (!(gBootMode & kBootModeQuiet)) {
766// Display banner and show hardware info.
767printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);
768printf(getVBEInfoString());
769}
770changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);
771verbose("Scanning device %x...", gBIOSDev);
772}
773
774// When booting from CD, default to hard drive boot when possible.
775if (isCDROM && firstRun) {
776const char *val;
777char *prompt = NULL;
778char *name = NULL;
779int cnt;
780int optionKey;
781
782if (getValueForKey(kCDROMPromptKey, &val, &cnt, &bootInfo->bootConfig)) {
783prompt = malloc(cnt + 1);
784strncat(prompt, val, cnt);
785} else {
786name = malloc(80);
787getBootVolumeDescription(gBootVolume, name, 79, false);
788prompt = malloc(256);
789sprintf(prompt, "Press any key to start up from %s, or press F8 to enter startup options.", name);
790free(name);
791}
792
793if (getIntForKey( kCDROMOptionKey, &optionKey, &bootInfo->bootConfig )) {
794// The key specified is a special key.
795} else {
796// Default to F8.
797optionKey = 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.
803if (timeout != 0) {
804key = countdown(prompt, kMenuTopRow, timeout);
805} else {
806key = optionKey;
807}
808
809if (prompt != NULL) {
810free(prompt);
811}
812
813clearScreenRows( kMenuTopRow, kMenuTopRow + 2 );
814
815// Hit the option key ?
816if (key == optionKey) {
817gBootMode &= ~kBootModeQuiet;
818timeout = 0;
819} else {
820key = key & 0xFF;
821
822// Try booting hard disk if user pressed 'h'
823if (biosDevIsCDROM(gBIOSDev) && key == 'h') {
824BVRef bvr;
825
826// Look at partitions hosting OS X other than the CD-ROM
827for (bvr = bvChain; bvr; bvr=bvr->next) {
828if ((bvr->flags & kBVFlagSystemVolume) && bvr->biosdev != gBIOSDev) {
829gBootVolume = bvr;
830}
831}
832}
833goto done;
834}
835}
836
837if (gBootMode & kBootModeQuiet) {
838// No input allowed from user.
839goto done;
840}
841
842if (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.
845if ((readKeyboardShiftFlags() & 0x0F) != 0) {
846gBootMode |= kBootModeSafe;
847}
848goto done;
849}
850
851if (gDeviceCount) {
852// Allocate memory for an array of menu items.
853menuItems = malloc(sizeof(MenuItem) * gDeviceCount);
854if (menuItems == NULL) {
855goto done;
856}
857
858// Associate a menu item for each BVRef.
859for (bvr=bvChain, i=gDeviceCount-1, selectIndex=0; bvr; bvr=bvr->next) {
860if (bvr->visible) {
861getBootVolumeDescription(bvr, menuItems[i].name, sizeof(menuItems[i].name) - 1, true);
862menuItems[i].param = (void *) bvr;
863if (bvr == menuBVR) {
864selectIndex = i;
865}
866i--;
867}
868}
869}
870
871if (bootArgs->Video.v_display == GRAPHICS_MODE) {
872// redraw the background buffer
873gui.logo.draw = true;
874drawBackground();
875gui.devicelist.draw = true;
876gui.redraw = true;
877if (!(gBootMode & kBootModeQuiet)) {
878bool showBootBanner = true;
879
880// Check if "Boot Banner"=N switch is present in config file.
881getBoolForKey(kBootBannerKey, &showBootBanner, &bootInfo->bootConfig);
882if (showBootBanner) {
883// Display banner and show hardware info.
884gprintf(&gui.screen, bootBanner + 1, (bootInfo->convmem + bootInfo->extmem) / 1024);
885}
886
887// redraw background
888memcpy(gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4);
889}
890} else {
891// Clear screen and hide the blinking cursor.
892clearScreenRows(kMenuTopRow, kMenuTopRow + 2);
893changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);
894}
895
896nextRow = kMenuTopRow;
897showPrompt = true;
898
899if (gDeviceCount) {
900if( bootArgs->Video.v_display == VGA_TEXT_MODE ) {
901printf("Use \30\31 keys to select the startup volume.");
902}
903showMenu( menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems );
904nextRow += min( gDeviceCount, kMenuMaxItems ) + 3;
905}
906
907// Show the boot prompt.
908showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);
909showBootPrompt( nextRow, showPrompt );
910
911do {
912if (bootArgs->Video.v_display == GRAPHICS_MODE) {
913// redraw background
914memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );
915// reset cursor co-ords
916gui.debug.cursor = pos( gui.screen.width - 160 , 10 );
917}
918key = getchar();
919updateMenu( key, (void **) &menuBVR );
920newShowPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);
921
922if (newShowPrompt != showPrompt) {
923showPrompt = newShowPrompt;
924showBootPrompt( nextRow, showPrompt );
925}
926
927if (showPrompt) {
928updateBootArgs(key);
929}
930
931switch (key) {
932case kReturnKey:
933if (gui.menu.draw) {
934key=0;
935break;
936}
937if (*gBootArgs == '?') {
938char * argPtr = gBootArgs;
939
940// Skip the leading "?" character.
941argPtr++;
942getNextArg(&argPtr, booterCommand);
943getNextArg(&argPtr, booterParam);
944
945/*
946* TODO: this needs to be refactored.
947*/
948if (strcmp( booterCommand, "video" ) == 0) {
949if (bootArgs->Video.v_display == GRAPHICS_MODE) {
950showInfoBox(getVBEInfoString(), getVBEModeInfoString());
951} else {
952printVBEModeInfo();
953}
954} else if ( strcmp( booterCommand, "memory" ) == 0) {
955if (bootArgs->Video.v_display == GRAPHICS_MODE ) {
956showInfoBox("Memory Map", getMemoryInfoString());
957} else {
958printMemoryInfo();
959}
960} else if (strcmp(booterCommand, "lspci") == 0) {
961lspci();
962} else if (strcmp(booterCommand, "more") == 0) {
963showTextFile(booterParam);
964} else if (strcmp(booterCommand, "rd") == 0) {
965processRAMDiskCommand(&argPtr, booterParam);
966} else if (strcmp(booterCommand, "norescan") == 0) {
967if (gEnableCDROMRescan) {
968gEnableCDROMRescan = false;
969break;
970}
971} else {
972showHelp();
973}
974key = 0;
975showBootPrompt(nextRow, showPrompt);
976break;
977}
978gBootVolume = menuBVR;
979setRootVolume(menuBVR);
980gBIOSDev = menuBVR->biosdev;
981break;
982
983case kEscapeKey:
984clearBootArgs();
985break;
986
987case kF5Key:
988// New behavior:
989// Clear gBootVolume to restart the loop
990// if the user enabled rescanning the optical drive.
991// Otherwise boot the default boot volume.
992if (gEnableCDROMRescan) {
993gBootVolume = NULL;
994clearBootArgs();
995}
996break;
997
998case kF10Key:
999gScanSingleDrive = false;
1000scanDisks(gBIOSDev, &bvCount);
1001gBootVolume = NULL;
1002clearBootArgs();
1003break;
1004
1005case kTabKey:
1006// New behavior:
1007// Switch between text & graphic interfaces
1008// Only Permitted if started in graphics interface
1009if (useGUI) {
1010if (bootArgs->Video.v_display == GRAPHICS_MODE) {
1011setVideoMode(VGA_TEXT_MODE, 0);
1012
1013setCursorPosition(0, 0, 0);
1014clearScreenRows(0, kScreenLastRow);
1015
1016// Display banner and show hardware info.
1017printf(bootBanner, (bootInfo->convmem + bootInfo->extmem) / 1024);
1018printf(getVBEInfoString());
1019
1020clearScreenRows(kMenuTopRow, kMenuTopRow + 2);
1021changeCursor(0, kMenuTopRow, kCursorTypeHidden, 0);
1022
1023nextRow = kMenuTopRow;
1024showPrompt = true;
1025
1026if (gDeviceCount) {
1027printf("Use \30\31 keys to select the startup volume.");
1028showMenu(menuItems, gDeviceCount, selectIndex, kMenuTopRow + 2, kMenuMaxItems);
1029nextRow += min(gDeviceCount, kMenuMaxItems) + 3;
1030}
1031
1032showPrompt = (gDeviceCount == 0) || (menuBVR->flags & kBVFlagNativeBoot);
1033showBootPrompt(nextRow, showPrompt);
1034//changeCursor( 0, kMenuTopRow, kCursorTypeUnderline, 0 );
1035} else {
1036gui.redraw = true;
1037setVideoMode(GRAPHICS_MODE, 0);
1038updateVRAM();
1039}
1040}
1041key = 0;
1042break;
1043
1044default:
1045key = 0;
1046break;
1047}
1048} while (0 == key);
1049
1050done:
1051if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
1052clearScreenRows(kMenuTopRow, kScreenLastRow);
1053changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);
1054}
1055shouldboot = false;
1056gui.menu.draw = false;
1057if (menuItems) {
1058free(menuItems);
1059menuItems = NULL;
1060}
1061return 0;
1062}
1063
1064//==========================================================================
1065
1066extern unsigned char chainbootdev;
1067extern unsigned char chainbootflag;
1068
1069bool copyArgument(const char *argName, const char *val, int cnt, char **argP, int *cntRemainingP)
1070{
1071 int argLen = argName ? strlen(argName) : 0;
1072 int len = argLen + cnt + 1; // +1 to account for space
1073
1074 if (len > *cntRemainingP) {
1075 error("Warning: boot arguments too long, truncating\n");
1076 return false;
1077 }
1078
1079 if (argName) {
1080 strncpy( *argP, argName, argLen );
1081 *argP += argLen;
1082 *argP[0] = '=';
1083 (*argP)++;
1084 len++; // +1 to account for '='
1085 }
1086 strncpy( *argP, val, cnt );
1087 *argP += cnt;
1088 *argP[0] = ' ';
1089 (*argP)++;
1090
1091 *cntRemainingP -= len;
1092 return true;
1093}
1094
1095//
1096// Returns TRUE if an argument was copied, FALSE otherwise
1097bool
1098processBootArgument(
1099 const char *argName, // The argument to search for
1100 const char *userString, // Typed-in boot arguments
1101 const char *kernelFlags, // Kernel flags from config table
1102 const char *configTable,
1103 char **argP, // Output value
1104 int *cntRemainingP, // Output count
1105 char *foundVal // found value
1106 )
1107{
1108 const char *val;
1109 int cnt;
1110 bool found = false;
1111
1112 if (getValueForBootKey(userString, argName, &val, &cnt)) {
1113 // Don't copy; these values will be copied at the end of argument processing.
1114 found = true;
1115 } else if (getValueForBootKey(kernelFlags, argName, &val, &cnt)) {
1116 // Don't copy; these values will be copied at the end of argument processing.
1117 found = true;
1118 } else if (getValueForKey(argName, &val, &cnt, &bootInfo->bootConfig)) {
1119 copyArgument(argName, val, cnt, argP, cntRemainingP);
1120 found = true;
1121 }
1122 if (found && foundVal) {
1123 strlcpy(foundVal, val, cnt+1);
1124 }
1125 return found;
1126}
1127
1128// Maximum config table value size
1129#define VALUE_SIZE 2048
1130
1131int
1132processBootOptions()
1133{
1134 const char * cp = gBootArgs;
1135 const char * val = 0;
1136 const char * kernel;
1137 int cnt;
1138 int userCnt;
1139 int cntRemaining;
1140 char * argP;
1141 char uuidStr[64];
1142 bool uuidSet = false;
1143 char * configKernelFlags;
1144 char * valueBuffer;
1145
1146 valueBuffer = malloc(VALUE_SIZE);
1147
1148 skipblanks( &cp );
1149
1150 // Update the unit and partition number.
1151
1152 if ( gBootVolume )
1153 {
1154 if (!( gBootVolume->flags & kBVFlagNativeBoot ))
1155 {
1156 readBootSector( gBootVolume->biosdev, gBootVolume->part_boff,
1157 (void *) 0x7c00 );
1158
1159 //
1160 // Setup edx, and signal intention to chain load the
1161 // foreign booter.
1162 //
1163
1164 chainbootdev = gBootVolume->biosdev;
1165 chainbootflag = 1;
1166
1167 return 1;
1168 }
1169
1170 setRootVolume(gBootVolume);
1171
1172 }
1173 // If no boot volume fail immediately because we're just going to fail
1174 // trying to load the config file anyway.
1175 else
1176 return -1;
1177
1178 // Load config table specified by the user, or use the default.
1179
1180 if (!getValueForBootKey(cp, "config", &val, &cnt)) {
1181 val = 0;
1182 cnt = 0;
1183 }
1184
1185 // Load com.apple.Boot.plist from the selected volume
1186 // and use its contents to override default bootConfig.
1187 // This is not a mandatory opeartion anymore.
1188
1189 loadOverrideConfig(&bootInfo->overrideConfig);
1190
1191 // Use the kernel name specified by the user, or fetch the name
1192 // in the config table, or use the default if not specified.
1193 // Specifying a kernel name on the command line, or specifying
1194 // a non-default kernel name in the config file counts as
1195 // overriding the kernel, which causes the kernelcache not
1196 // to be used.
1197
1198 gOverrideKernel = false;
1199 if (( kernel = extractKernelName((char **)&cp) )) {
1200 strcpy( bootInfo->bootFile, kernel );
1201 gOverrideKernel = true;
1202 } else {
1203 if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) ) {
1204 strlcpy( bootInfo->bootFile, val, cnt+1 );
1205 if (strcmp( bootInfo->bootFile, kDefaultKernel ) != 0) {
1206 gOverrideKernel = true;
1207 }
1208 } else {
1209 strcpy( bootInfo->bootFile, kDefaultKernel );
1210 }
1211 }
1212
1213 cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space
1214 argP = bootArgs->CommandLine;
1215
1216 // Get config table kernel flags, if not ignored.
1217 if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) ||
1218 !getValueForKey( kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig )) {
1219 val = "";
1220 cnt = 0;
1221 }
1222 configKernelFlags = malloc(cnt + 1);
1223 strlcpy(configKernelFlags, val, cnt + 1);
1224
1225 if (processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, 0)) {
1226 // boot-uuid was set either on the command-line
1227 // or in the config file.
1228 uuidSet = true;
1229 } else {
1230
1231 //
1232 // Try an alternate method for getting the root UUID on boot helper partitions.
1233 //
1234 if (gBootVolume->flags & kBVFlagBooter)
1235 {
1236 if((loadHelperConfig(&bootInfo->helperConfig) == 0)
1237 && getValueForKey(kHelperRootUUIDKey, &val, &cnt, &bootInfo->helperConfig) )
1238 {
1239 getValueForKey(kHelperRootUUIDKey, &val, &cnt, &bootInfo->helperConfig);
1240 copyArgument(kBootUUIDKey, val, cnt, &argP, &cntRemaining);
1241 uuidSet = true;
1242 }
1243 }
1244
1245 if (!uuidSet && gBootVolume->fs_getuuid && gBootVolume->fs_getuuid (gBootVolume, uuidStr) == 0) {
1246 verbose("Setting boot-uuid to: %s\n", uuidStr);
1247 copyArgument(kBootUUIDKey, uuidStr, strlen(uuidStr), &argP, &cntRemaining);
1248 uuidSet = true;
1249 }
1250 }
1251
1252 if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, gRootDevice)) {
1253 cnt = 0;
1254 if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->bootConfig)) {
1255 valueBuffer[0] = '*';
1256 cnt++;
1257 strlcpy(valueBuffer + 1, val, cnt);
1258 val = valueBuffer;
1259 } else {
1260 if (uuidSet) {
1261 val = "*uuid";
1262 cnt = 5;
1263 } else {
1264 // Don't set "rd=.." if there is no boot device key
1265 // and no UUID.
1266 val = "";
1267 cnt = 0;
1268 }
1269 }
1270 if (cnt > 0) {
1271 copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);
1272 }
1273 strlcpy( gRootDevice, val, (cnt + 1));
1274 }
1275
1276 /*
1277 * Removed. We don't need this anymore.
1278 *
1279 if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, gPlatformName)) {
1280 getPlatformName(gPlatformName);
1281 copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);
1282 }
1283 */
1284
1285 if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&
1286 !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {
1287 if (gBootMode & kBootModeSafe) {
1288 copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);
1289 }
1290 }
1291
1292 // Store the merged kernel flags and boot args.
1293
1294 cnt = strlen(configKernelFlags);
1295 if (cnt) {
1296 if (cnt > cntRemaining) {
1297 error("Warning: boot arguments too long, truncating\n");
1298 cnt = cntRemaining;
1299 }
1300 strncpy(argP, configKernelFlags, cnt);
1301 argP[cnt++] = ' ';
1302 cntRemaining -= cnt;
1303 }
1304 userCnt = strlen(cp);
1305 if (userCnt > cntRemaining) {
1306 error("Warning: boot arguments too long, truncating\n");
1307 userCnt = cntRemaining;
1308 }
1309 strncpy(&argP[cnt], cp, userCnt);
1310 argP[cnt+userCnt] = '\0';
1311
1312if(!shouldboot)
1313{
1314gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->bootConfig ) ||
1315getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->bootConfig );
1316
1317gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->bootConfig ) ) ?
1318kBootModeSafe : kBootModeNormal;
1319
1320 if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->bootConfig ) ) {
1321 gBootMode = kBootModeSafe;
1322 }
1323}
1324
1325if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )
1326{
1327strlcpy(gMKextName, val, cnt + 1);
1328}
1329
1330 free(configKernelFlags);
1331 free(valueBuffer);
1332
1333 return 0;
1334}
1335
1336
1337//==========================================================================
1338// Load the help file and display the file contents on the screen.
1339
1340static void showTextBuffer(char *buf, int size)
1341{
1342char*bp;
1343intline;
1344intline_offset;
1345intc;
1346
1347if (bootArgs->Video.v_display == GRAPHICS_MODE) {
1348showInfoBox( "Press q to quit\n",buf );
1349return;
1350}
1351
1352 bp = buf;
1353 while (size-- > 0) {
1354if (*bp == '\n') {
1355*bp = '\0';
1356}
1357bp++;
1358 }
1359 *bp = '\1';
1360 line_offset = 0;
1361
1362 setActiveDisplayPage(1);
1363
1364 while (1) {
1365clearScreenRows(0, 24);
1366setCursorPosition(0, 0, 1);
1367bp = buf;
1368for (line = 0; *bp != '\1' && line < line_offset; line++) {
1369while (*bp != '\0') {
1370bp++;
1371}
1372bp++;
1373}
1374for (line = 0; *bp != '\1' && line < 23; line++) {
1375setCursorPosition(0, line, 1);
1376printf("%s\n", bp);
1377while (*bp != '\0') {
1378bp++;
1379}
1380bp++;
1381}
1382
1383setCursorPosition(0, 23, 1);
1384if (*bp == '\1') {
1385printf("[Type %sq or space to quit viewer]", (line_offset > 0) ? "p for previous page, " : "");
1386} else {
1387printf("[Type %s%sq to quit viewer]", (line_offset > 0) ? "p for previous page, " : "", (*bp != '\1') ? "space for next page, " : "");
1388}
1389
1390c = getchar();
1391if (c == 'q' || c == 'Q') {
1392break;
1393}
1394if ((c == 'p' || c == 'P') && line_offset > 0) {
1395line_offset -= 23;
1396}
1397if (c == ' ') {
1398if (*bp == '\1') {
1399break;
1400} else {
1401line_offset += 23;
1402}
1403}
1404 }
1405 setActiveDisplayPage(0);
1406}
1407
1408void showHelp(void)
1409{
1410if (bootArgs->Video.v_display == GRAPHICS_MODE) {
1411showInfoBox("Help. Press q to quit.\n", (char *)BootHelp_txt);
1412} else {
1413showTextBuffer((char *)BootHelp_txt, BootHelp_txt_len);
1414}
1415}
1416
1417void showTextFile(const char * filename)
1418{
1419#define MAX_TEXT_FILE_SIZE 65536
1420char*buf;
1421intfd;
1422intsize;
1423
1424if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0) {
1425printf("\nFile not found: %s\n", filename);
1426sleep(2);
1427return;
1428}
1429
1430 size = file_size(fd);
1431 if (size > MAX_TEXT_FILE_SIZE) {
1432size = MAX_TEXT_FILE_SIZE;
1433}
1434 buf = malloc(size);
1435 read(fd, buf, size);
1436 close(fd);
1437showTextBuffer(buf, size);
1438free(buf);
1439}
1440
1441// This is a very simplistic prompting scheme that just grabs two hex characters
1442// Eventually we need to do something more user-friendly like display a menu
1443// based off of the Multiboot device list
1444
1445int selectAlternateBootDevice(int bootdevice)
1446{
1447int key;
1448int newbootdevice;
1449int digitsI = 0;
1450char *end;
1451char digits[3] = {0,0,0};
1452
1453// We've already printed the current boot device so user knows what it is
1454printf("Typical boot devices are 80 (First HD), 81 (Second HD)\n");
1455printf("Enter two-digit hexadecimal boot device [%02x]: ", bootdevice);
1456do {
1457key = getchar();
1458switch (key & kASCIIKeyMask) {
1459case kBackspaceKey:
1460if (digitsI > 0) {
1461int x, y, t;
1462getCursorPositionAndType(&x, &y, &t);
1463// Assume x is not 0;
1464x--;
1465setCursorPosition(x,y,0); // back up one char
1466// Overwrite with space without moving cursor position
1467putca(' ', 0x07, 1);
1468digitsI--;
1469} else {
1470// TODO: Beep or something
1471}
1472break;
1473
1474case kReturnKey:
1475digits[digitsI] = '\0';
1476newbootdevice = strtol(digits, &end, 16);
1477if (end == digits && *end == '\0') {
1478// User entered empty string
1479printf("\nUsing default boot device %x\n", bootdevice);
1480key = 0;
1481} else if(end != digits && *end == '\0') {
1482bootdevice = newbootdevice;
1483printf("\n");
1484key = 0; // We gots da boot device
1485} else {
1486printf("\nCouldn't parse. try again: ");
1487digitsI = 0;
1488}
1489break;
1490
1491default:
1492if (isxdigit(key & kASCIIKeyMask) && digitsI < 2) {
1493putchar(key & kASCIIKeyMask);
1494digits[digitsI++] = key & kASCIIKeyMask;
1495} else {
1496// TODO: Beep or something
1497}
1498break;
1499};
1500} while (key != 0);
1501
1502return bootdevice;
1503}
1504
1505bool promptForRescanOption(void)
1506{
1507printf("\nWould you like to enable media rescan option?\nPress ENTER to enable or any key to skip.\n");
1508if (getchar() == kReturnKey) {
1509return true;
1510} else {
1511return false;
1512}
1513}
1514

Archive Download this file

Revision: 962