src/boot.c

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