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