src/boot.c

   1 // Code to load disk image and start system boot.
   2 //
   3 // Copyright (C) 2008-2010  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2002  MandrakeSoft S.A.
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "util.h" // dprintf
   9 #include "biosvar.h" // GET_EBDA
  10 #include "config.h" // CONFIG_*
  11 #include "disk.h" // cdrom_boot
  12 #include "bregs.h" // struct bregs
  13 #include "boot.h" // struct ipl_s
  14 #include "cmos.h" // inb_cmos
  15 #include "paravirt.h"
  16
  17 struct ipl_s IPL;
  18
  19
  20 /****************************************************************
  21  * IPL and BCV handlers
  22  ****************************************************************/
  23
  24 void
  25 boot_setup(void)
  26 {
  27     if (! CONFIG_BOOT)
  28         return;
  29     dprintf(3, "init boot device ordering\n");
  30
  31     memset(&IPL, 0, sizeof(IPL));
  32     struct ipl_entry_s *ie = &IPL.bev[0];
  33
  34     // Floppy drive
  35     ie->type = IPL_TYPE_FLOPPY;
  36     ie->description = "Floppy";
  37     ie++;
  38
  39     // First HDD
  40     ie->type = IPL_TYPE_HARDDISK;
  41     ie->description = "Hard Disk";
  42     ie++;
  43
  44     // CDROM
  45     if (CONFIG_CDROM_BOOT) {
  46         ie->type = IPL_TYPE_CDROM;
  47         ie->description = "DVD/CD";
  48         ie++;
  49     }
  50
  51     if (CONFIG_COREBOOT && CONFIG_COREBOOT_FLASH) {
  52         ie->type = IPL_TYPE_CBFS;
  53         ie->description = "CBFS";
  54         ie++;
  55     }
  56
  57     IPL.bevcount = ie - IPL.bev;
  58     SET_EBDA(boot_sequence, 0xffff);
  59     if (CONFIG_COREBOOT) {
  60         // XXX - hardcode defaults for coreboot.
  61         IPL.bootorder = 0x87654231;
  62         IPL.checkfloppysig = 1;
  63     } else {
  64         // On emulators, get boot order from nvram.
  65         IPL.bootorder = (inb_cmos(CMOS_BIOS_BOOTFLAG2)
  66                          | ((inb_cmos(CMOS_BIOS_BOOTFLAG1) & 0xf0) << 4));
  67         if (!(inb_cmos(CMOS_BIOS_BOOTFLAG1) & 1))
  68             IPL.checkfloppysig = 1;
  69     }
  70
  71     char *f = romfile_loadfile("bootorder", NULL);
  72     if (!f)
  73         return;
  74
  75     int i;
  76     IPL.fw_bootorder_count = 1;
  77     while(f[i]) {
  78         if (f[i] == '\n')
  79             IPL.fw_bootorder_count++;
  80         i++;
  81     }
  82     IPL.fw_bootorder = malloc_tmphigh(IPL.fw_bootorder_count*sizeof(char*));
  83     if (!IPL.fw_bootorder) {
  84         warn_noalloc();
  85         free(f);
  86         return;
  87     }
  88
  89     dprintf(3, "boot order:\n");
  90     i = 0;
  91     do {
  92         IPL.fw_bootorder[i] = f;
  93         f = strchr(f, '\n');
  94         if (f) {
  95             *f = '\0';
  96             f++;
  97             dprintf(3, "%d: %s\n", i, IPL.fw_bootorder[i]);
  98             i++;
  99         }
 100     } while(f);
 101 }
 102
 103 // Add a BEV vector for a given pnp compatible option rom.
 104 void
 105 add_bev(u16 seg, u16 bev, u16 desc)
 106 {
 107     if (! CONFIG_BOOT)
 108         return;
 109     if (IPL.bevcount >= ARRAY_SIZE(IPL.bev))
 110         return;
 111
 112     struct ipl_entry_s *ie = &IPL.bev[IPL.bevcount++];
 113     ie->type = IPL_TYPE_BEV;
 114     ie->vector = (seg << 16) | bev;
 115     const char *d = "Unknown";
 116     if (desc)
 117         d = MAKE_FLATPTR(seg, desc);
 118     ie->description = d;
 119 }
 120
 121 // Add a IPL entry for BAID cdrom.
 122 void
 123 add_baid_cdrom(struct drive_s *drive_g)
 124 {
 125     if (! CONFIG_CDROM_BOOT)
 126         return;
 127
 128     /* put first cdrom into ipl 3 for compatability with qemu */
 129     struct ipl_entry_s *ie = &IPL.bev[2];
 130     if (IPL.bevcount >= ARRAY_SIZE(IPL.bev) && ie->vector)
 131         return;
 132
 133     if (ie->vector)
 134         ie = &IPL.bev[IPL.bevcount++];
 135     ie->type = IPL_TYPE_CDROM;
 136     ie->vector = (u32)drive_g;
 137     ie->description = "DVD/CD";
 138 }
 139
 140 // Add a bcv entry for an expansion card harddrive or legacy option rom
 141 void
 142 add_bcv(u16 seg, u16 ip, u16 desc)
 143 {
 144     if (! CONFIG_BOOT)
 145         return;
 146     if (IPL.bcvcount >= ARRAY_SIZE(IPL.bcv))
 147         return;
 148
 149     struct ipl_entry_s *ie = &IPL.bcv[IPL.bcvcount++];
 150     ie->type = BCV_TYPE_EXTERNAL;
 151     ie->vector = (seg << 16) | ip;
 152     const char *d = "Legacy option rom";
 153     if (desc)
 154         d = MAKE_FLATPTR(seg, desc);
 155     ie->description = d;
 156 }
 157
 158 // Add a bcv entry for an internal harddrive
 159 void
 160 add_bcv_internal(struct drive_s *drive_g)
 161 {
 162     if (! CONFIG_BOOT)
 163         return;
 164     if (IPL.bcvcount >= ARRAY_SIZE(IPL.bcv))
 165         return;
 166
 167     struct ipl_entry_s *ie = &IPL.bcv[IPL.bcvcount++];
 168     if (CONFIG_THREADS) {
 169         // Add to bcv list with assured drive order.
 170         struct ipl_entry_s *end = ie;
 171         for (;;) {
 172             struct ipl_entry_s *prev = ie - 1;
 173             if (prev < IPL.bcv || prev->type != BCV_TYPE_INTERNAL)
 174                 break;
 175             struct drive_s *prevdrive = (void*)prev->vector;
 176             if (prevdrive->type < drive_g->type
 177                 || (prevdrive->type == drive_g->type
 178                     && prevdrive->cntl_id < drive_g->cntl_id))
 179                 break;
 180             ie--;
 181         }
 182         if (ie != end)
 183             memmove(ie+1, ie, (void*)end-(void*)ie);
 184     }
 185     ie->type = BCV_TYPE_INTERNAL;
 186     ie->vector = (u32)drive_g;
 187     ie->description = "";
 188 }
 189
 190
 191 /****************************************************************
 192  * Boot menu and BCV execution
 193  ****************************************************************/
 194
 195 // Show a generic menu item
 196 static int
 197 menu_show_default(struct ipl_entry_s *ie, int menupos)
 198 {
 199     char desc[33];
 200     printf("%d. %s\n", menupos
 201            , strtcpy(desc, ie->description, ARRAY_SIZE(desc)));
 202     return 1;
 203 }
 204
 205 // Show floppy menu item - but only if there exists a floppy drive.
 206 static int
 207 menu_show_floppy(struct ipl_entry_s *ie, int menupos)
 208 {
 209     int i;
 210     for (i = 0; i < Drives.floppycount; i++) {
 211         struct drive_s *drive_g = getDrive(EXTTYPE_FLOPPY, i);
 212         printf("%d. Floppy [%s]\n", menupos + i, drive_g->desc);
 213     }
 214     return Drives.floppycount;
 215 }
 216
 217 // Show menu items from BCV list.
 218 static int
 219 menu_show_harddisk(struct ipl_entry_s *ie, int menupos)
 220 {
 221     int i;
 222     for (i = 0; i < IPL.bcvcount; i++) {
 223         struct ipl_entry_s *ie = &IPL.bcv[i];
 224         struct drive_s *drive_g = (void*)ie->vector;
 225         switch (ie->type) {
 226         case BCV_TYPE_INTERNAL:
 227             printf("%d. %s\n", menupos + i, drive_g->desc);
 228             break;
 229         default:
 230             menu_show_default(ie, menupos+i);
 231             break;
 232         }
 233     }
 234     return IPL.bcvcount;
 235 }
 236
 237 // Show cdrom menu item - but only if there exists a cdrom drive.
 238 static int
 239 menu_show_cdrom(struct ipl_entry_s *ie, int menupos)
 240 {
 241     struct drive_s *drive_g = (void*)ie->vector;
 242     if (!ie->vector)
 243         return 0;
 244     printf("%d. DVD/CD [%s]\n", menupos, drive_g->desc);
 245     return 1;
 246 }
 247
 248 // Show coreboot-fs menu item.
 249 static int
 250 menu_show_cbfs(struct ipl_entry_s *ie, int menupos)
 251 {
 252     int count = 0;
 253     struct cbfs_file *file = NULL;
 254     for (;;) {
 255         file = cbfs_findprefix("img/", file);
 256         if (!file)
 257             break;
 258         const char *filename = cbfs_filename(file);
 259         printf("%d. Payload [%s]\n", menupos + count, &filename[4]);
 260         count++;
 261         if (count > 8)
 262             break;
 263     }
 264     return count;
 265 }
 266
 267 // Show IPL option menu.
 268 static void
 269 interactive_bootmenu(void)
 270 {
 271     if (! CONFIG_BOOTMENU || ! qemu_cfg_show_boot_menu())
 272         return;
 273
 274     while (get_keystroke(0) >= 0)
 275         ;
 276
 277     printf("Press F12 for boot menu.\n\n");
 278
 279     enable_bootsplash();
 280     int scan_code = get_keystroke(CONFIG_BOOTMENU_WAIT);
 281     disable_bootsplash();
 282     if (scan_code != 0x86)
 283         /* not F12 */
 284         return;
 285
 286     while (get_keystroke(0) >= 0)
 287         ;
 288
 289     printf("Select boot device:\n\n");
 290     wait_threads();
 291
 292     int subcount[ARRAY_SIZE(IPL.bev)];
 293     int menupos = 1;
 294     int i;
 295     for (i = 0; i < IPL.bevcount; i++) {
 296         struct ipl_entry_s *ie = &IPL.bev[i];
 297         int sc;
 298         switch (ie->type) {
 299         case IPL_TYPE_FLOPPY:
 300             sc = menu_show_floppy(ie, menupos);
 301             break;
 302         case IPL_TYPE_HARDDISK:
 303             sc = menu_show_harddisk(ie, menupos);
 304             break;
 305         case IPL_TYPE_CDROM:
 306             sc = menu_show_cdrom(ie, menupos);
 307             break;
 308         case IPL_TYPE_CBFS:
 309             sc = menu_show_cbfs(ie, menupos);
 310             break;
 311         default:
 312             sc = menu_show_default(ie, menupos);
 313             break;
 314         }
 315         subcount[i] = sc;
 316         menupos += sc;
 317     }
 318
 319     for (;;) {
 320         scan_code = get_keystroke(1000);
 321         if (scan_code == 0x01)
 322             // ESC
 323             break;
 324         if (scan_code < 1 || scan_code > menupos)
 325             continue;
 326         int choice = scan_code - 1;
 327
 328         // Find out which IPL this was for.
 329         int bev = 0;
 330         while (choice > subcount[bev]) {
 331             choice -= subcount[bev];
 332             bev++;
 333         }
 334         IPL.bev[bev].subchoice = choice-1;
 335
 336         // Add user choice to the boot order.
 337         IPL.bootorder = (IPL.bootorder << 4) | (bev+1);
 338         break;
 339     }
 340     printf("\n");
 341 }
 342
 343 // Run the specified bcv.
 344 static void
 345 run_bcv(struct ipl_entry_s *ie)
 346 {
 347     switch (ie->type) {
 348     case BCV_TYPE_INTERNAL:
 349         map_hd_drive((void*)ie->vector);
 350         break;
 351     case BCV_TYPE_EXTERNAL:
 352         call_bcv(ie->vector >> 16, ie->vector & 0xffff);
 353         break;
 354     }
 355 }
 356
 357 // Prepare for boot - show menu and run bcvs.
 358 void
 359 boot_prep(void)
 360 {
 361     if (! CONFIG_BOOT) {
 362         wait_threads();
 363         return;
 364     }
 365
 366     // XXX - show available drives?
 367
 368     // Allow user to modify BCV/IPL order.
 369     interactive_bootmenu();
 370     wait_threads();
 371
 372     // Setup floppy boot order
 373     int override = IPL.bev[0].subchoice;
 374     struct drive_s *tmp = Drives.idmap[EXTTYPE_FLOPPY][0];
 375     Drives.idmap[EXTTYPE_FLOPPY][0] = Drives.idmap[EXTTYPE_FLOPPY][override];
 376     Drives.idmap[EXTTYPE_FLOPPY][override] = tmp;
 377
 378     // Run BCVs
 379     override = IPL.bev[1].subchoice;
 380     if (override < IPL.bcvcount)
 381         run_bcv(&IPL.bcv[override]);
 382     int i;
 383     for (i=0; i<IPL.bcvcount; i++)
 384         if (i != override)
 385             run_bcv(&IPL.bcv[i]);
 386 }
 387
 388
 389 /****************************************************************
 390  * Boot code (int 18/19)
 391  ****************************************************************/
 392
 393 // Jump to a bootup entry point.
 394 static void
 395 call_boot_entry(u16 bootseg, u16 bootip, u8 bootdrv)
 396 {
 397     dprintf(1, "Booting from %04x:%04x\n", bootseg, bootip);
 398     struct bregs br;
 399     memset(&br, 0, sizeof(br));
 400     br.flags = F_IF;
 401     br.code = SEGOFF(bootseg, bootip);
 402     // Set the magic number in ax and the boot drive in dl.
 403     br.dl = bootdrv;
 404     br.ax = 0xaa55;
 405     call16(&br);
 406 }
 407
 408 // Boot from a disk (either floppy or harddrive)
 409 static void
 410 boot_disk(u8 bootdrv, int checksig)
 411 {
 412     u16 bootseg = 0x07c0;
 413
 414     // Read sector
 415     struct bregs br;
 416     memset(&br, 0, sizeof(br));
 417     br.flags = F_IF;
 418     br.dl = bootdrv;
 419     br.es = bootseg;
 420     br.ah = 2;
 421     br.al = 1;
 422     br.cl = 1;
 423     call16_int(0x13, &br);
 424
 425     if (br.flags & F_CF) {
 426         printf("Boot failed: could not read the boot disk\n\n");
 427         return;
 428     }
 429
 430     if (checksig) {
 431         struct mbr_s *mbr = (void*)0;
 432         if (GET_FARVAR(bootseg, mbr->signature) != MBR_SIGNATURE) {
 433             printf("Boot failed: not a bootable disk\n\n");
 434             return;
 435         }
 436     }
 437
 438     /* Canonicalize bootseg:bootip */
 439     u16 bootip = (bootseg & 0x0fff) << 4;
 440     bootseg &= 0xf000;
 441
 442     call_boot_entry(bootseg, bootip, bootdrv);
 443 }
 444
 445 // Boot from a CD-ROM
 446 static void
 447 boot_cdrom(struct ipl_entry_s *ie)
 448 {
 449     if (! CONFIG_CDROM_BOOT)
 450         return;
 451
 452     if (!ie->vector)
 453         return;
 454
 455     struct drive_s *drive_g = (void*)ie->vector;
 456     int status = cdrom_boot(drive_g);
 457     if (status) {
 458         printf("Boot failed: Could not read from CDROM %s (code %04x)\n", drive_g->desc, status);
 459         return;
 460     }
 461
 462     u16 ebda_seg = get_ebda_seg();
 463     u8 bootdrv = GET_EBDA2(ebda_seg, cdemu.emulated_extdrive);
 464     u16 bootseg = GET_EBDA2(ebda_seg, cdemu.load_segment);
 465     /* Canonicalize bootseg:bootip */
 466     u16 bootip = (bootseg & 0x0fff) << 4;
 467     bootseg &= 0xf000;
 468
 469     call_boot_entry(bootseg, bootip, bootdrv);
 470 }
 471
 472 // Boot from a CBFS payload
 473 static void
 474 boot_cbfs(struct ipl_entry_s *ie)
 475 {
 476     if (!CONFIG_COREBOOT || !CONFIG_COREBOOT_FLASH)
 477         return;
 478     int count = ie->subchoice;
 479     struct cbfs_file *file = NULL;
 480     for (;;) {
 481         file = cbfs_findprefix("img/", file);
 482         if (!file)
 483             return;
 484         if (count--)
 485             continue;
 486         cbfs_run_payload(file);
 487     }
 488 }
 489
 490 static void
 491 do_boot(u16 seq_nr)
 492 {
 493     if (! CONFIG_BOOT)
 494         panic("Boot support not compiled in.\n");
 495
 496     u32 bootdev = IPL.bootorder;
 497     bootdev >>= 4 * seq_nr;
 498     bootdev &= 0xf;
 499
 500     /* Translate bootdev to an IPL table offset by subtracting 1 */
 501     bootdev -= 1;
 502
 503     if (bootdev >= IPL.bevcount) {
 504         printf("No bootable device.\n");
 505         // Loop with irqs enabled - this allows ctrl+alt+delete to work.
 506         for (;;)
 507             wait_irq();
 508     }
 509
 510     /* Do the loading, and set up vector as a far pointer to the boot
 511      * address, and bootdrv as the boot drive */
 512     struct ipl_entry_s *ie = &IPL.bev[bootdev];
 513     char desc[33];
 514     printf("Booting from %s...\n"
 515            , strtcpy(desc, ie->description, ARRAY_SIZE(desc)));
 516
 517     switch (ie->type) {
 518     case IPL_TYPE_FLOPPY:
 519         boot_disk(0x00, IPL.checkfloppysig);
 520         break;
 521     case IPL_TYPE_HARDDISK:
 522         boot_disk(0x80, 1);
 523         break;
 524     case IPL_TYPE_CDROM:
 525         boot_cdrom(ie);
 526         break;
 527     case IPL_TYPE_CBFS:
 528         boot_cbfs(ie);
 529         break;
 530     case IPL_TYPE_BEV:
 531         call_boot_entry(ie->vector >> 16, ie->vector & 0xffff, 0);
 532         break;
 533     }
 534
 535     // Boot failed: invoke the boot recovery function
 536     struct bregs br;
 537     memset(&br, 0, sizeof(br));
 538     br.flags = F_IF;
 539     call16_int(0x18, &br);
 540 }
 541
 542 // Boot Failure recovery: try the next device.
 543 void VISIBLE32FLAT
 544 handle_18(void)
 545 {
 546     debug_serial_setup();
 547     debug_enter(NULL, DEBUG_HDL_18);
 548     u16 ebda_seg = get_ebda_seg();
 549     u16 seq = GET_EBDA2(ebda_seg, boot_sequence) + 1;
 550     SET_EBDA2(ebda_seg, boot_sequence, seq);
 551     do_boot(seq);
 552 }
 553
 554 // INT 19h Boot Load Service Entry Point
 555 void VISIBLE32FLAT
 556 handle_19(void)
 557 {
 558     debug_serial_setup();
 559     debug_enter(NULL, DEBUG_HDL_19);
 560     SET_EBDA(boot_sequence, 0);
 561     do_boot(0);
 562 }