sys/boot/i386/boot2/boot2.c

   1 /*-
   2  * Copyright (c) 1998 Robert Nordier
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are freely
   6  * permitted provided that the above copyright notice and this
   7  * paragraph and the following disclaimer are duplicated in all
   8  * such forms.
   9  *
  10  * This software is provided "AS IS" and without any express or
  11  * implied warranties, including, without limitation, the implied
  12  * warranties of merchantability and fitness for a particular
  13  * purpose.
  14  *
  15  * $FreeBSD: src/sys/boot/i386/boot2/boot2.c,v 1.64 2003/08/25 23:28:31 obrien Exp $
  16  * $DragonFly: src/sys/boot/i386/boot2/Attic/boot2.c,v 1.10 2004/06/27 08:00:46 dillon Exp $
  17  */
  18 #include <sys/param.h>
  19 #include <sys/disklabel.h>
  20 #include <sys/diskslice.h>
  21 #include <sys/diskmbr.h>
  22 #include <sys/dirent.h>
  23 #include <machine/bootinfo.h>
  24 #include <machine/elf.h>
  25
  26 #include <stdarg.h>
  27
  28 #include <a.out.h>
  29
  30 #include <btxv86.h>
  31
  32 #include "boot2.h"
  33 #include "lib.h"
  34
  35 #define SECOND          18      /* Circa that many ticks in a second. */
  36
  37 #define RBX_ASKNAME     0x0     /* -a */
  38 #define RBX_SINGLE      0x1     /* -s */
  39 #define RBX_DFLTROOT    0x5     /* -r */
  40 #define RBX_KDB         0x6     /* -d */
  41 #define RBX_CONFIG      0xa     /* -c */
  42 #define RBX_VERBOSE     0xb     /* -v */
  43 #define RBX_SERIAL      0xc     /* -h */
  44 #define RBX_CDROM       0xd     /* -C */
  45 #define RBX_GDB         0xf     /* -g */
  46 #define RBX_MUTE        0x10    /* -m */
  47 #define RBX_PAUSE       0x12    /* -p */
  48 #define RBX_NOINTR      0x1c    /* -n */
  49 #define RBX_VIDEO       0x1d    /* -V */
  50 #define RBX_PROBEKBD    0x1e    /* -P */
  51 /* 0x1f is reserved for the historical RB_BOOTINFO option */
  52
  53 #define RBF_MUTE        (1 << RBX_MUTE)
  54 #define RBF_SERIAL      (1 << RBX_SERIAL)
  55 #define RBF_VIDEO       (1 << RBX_VIDEO)
  56
  57 /* pass: -a, -s, -r, -d, -c, -v, -h, -C, -g, -m, -p, -V */
  58 #define RBX_MASK        0x2005ffff
  59
  60 #define PATH_CONFIG     "/boot.config"
  61 #define PATH_BOOT3      "/boot/loader"
  62 #define PATH_KERNEL     "/kernel"
  63
  64 #define ARGS            0x900
  65 #define NDEV            3
  66 #define MEM_BASE        0x12
  67 #define MEM_EXT         0x15
  68 #define V86_CY(x)       ((x) & 1)
  69 #define V86_ZR(x)       ((x) & 0x40)
  70
  71 #define DRV_HARD        0x80
  72 #define DRV_MASK        0x7f
  73
  74 #define TYPE_AD         0
  75 #define TYPE_DA         1
  76 #define TYPE_MAXHARD    TYPE_DA
  77 #define TYPE_FD         2
  78
  79 #define NOPT            12
  80
  81 extern uint32_t _end;
  82
  83 static const char optstr[NOPT] = { "VhaCgmnPprsv" };
  84 static const unsigned char flags[NOPT] = {
  85     RBX_VIDEO,
  86     RBX_SERIAL,
  87     RBX_ASKNAME,
  88     RBX_CDROM,
  89     RBX_GDB,
  90     RBX_MUTE,
  91     RBX_NOINTR,
  92     RBX_PROBEKBD,
  93     RBX_PAUSE,
  94     RBX_DFLTROOT,
  95     RBX_SINGLE,
  96     RBX_VERBOSE
  97 };
  98
  99 static const char *const dev_nm[NDEV] = {"ad", "da", "fd"};
 100 static const unsigned char dev_maj[NDEV] = {30, 4, 2};
 101
 102 static struct dsk {
 103     unsigned drive;
 104     unsigned type;
 105     unsigned unit;
 106     unsigned slice;
 107     unsigned part;
 108     unsigned start;
 109     int init;
 110 } dsk;
 111 static char cmd[512];
 112 static char kname[1024];
 113 static uint32_t opts;
 114 static struct bootinfo bootinfo;
 115
 116 void exit(int);
 117 static void load(void);
 118 static int parse(void);
 119 static int xfsread(ino_t, void *, size_t);
 120 static int dskread(void *, unsigned, unsigned);
 121 static void printf(const char *,...);
 122 static void putchar(int);
 123 static uint32_t memsize(void);
 124 static int drvread(void *, unsigned, unsigned);
 125 static int keyhit(unsigned);
 126 static void xputc(int);
 127 static int xgetc(int);
 128 static int getc(int);
 129
 130 static void
 131 memcpy(void *d, const void *s, int len)
 132 {
 133     char *dd = d;
 134     const char *ss = s;
 135
 136 #if 0
 137     if (dd < ss) {
 138         while (--len >= 0)
 139             *dd++ = *ss++;
 140     } else {
 141 #endif
 142         while (--len >= 0)
 143             dd[len] = ss[len];
 144 #if 0
 145     }
 146 #endif
 147 }
 148
 149 static inline int
 150 strcmp(const char *s1, const char *s2)
 151 {
 152     for (; *s1 == *s2 && *s1; s1++, s2++);
 153     return (unsigned char)*s1 - (unsigned char)*s2;
 154 }
 155
 156 #include "ufsread.c"
 157
 158 static int
 159 xfsread(ino_t inode, void *buf, size_t nbyte)
 160 {
 161     if ((size_t)fsread(inode, buf, nbyte) != nbyte) {
 162         printf("Invalid %s\n", "format");
 163         return -1;
 164     }
 165     return 0;
 166 }
 167
 168 static inline uint32_t
 169 memsize(void)
 170 {
 171     v86.addr = MEM_EXT;
 172     v86.eax = 0x8800;
 173     v86int();
 174     return v86.eax;
 175 }
 176
 177 static inline void
 178 getstr(void)
 179 {
 180     char *s;
 181     int c;
 182
 183     s = cmd;
 184     for (;;) {
 185         switch (c = xgetc(0)) {
 186         case 0:
 187             break;
 188         case '\177':
 189         case '\b':
 190             if (s > cmd) {
 191                 s--;
 192                 printf("\b \b");
 193             }
 194             break;
 195         case '\n':
 196         case '\r':
 197             *s = 0;
 198             return;
 199         default:
 200             if (s - cmd < sizeof(cmd) - 1)
 201                 *s++ = c;
 202             putchar(c);
 203         }
 204     }
 205 }
 206
 207 static inline void
 208 putc(int c)
 209 {
 210     v86.addr = 0x10;
 211     v86.eax = 0xe00 | (c & 0xff);
 212     v86.ebx = 0x7;
 213     v86int();
 214 }
 215
 216 int
 217 main(void)
 218 {
 219     int autoboot;
 220     ino_t ino;
 221
 222     dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
 223     v86.ctl = V86_FLAGS;
 224     dsk.drive = *(uint8_t *)PTOV(ARGS);
 225     dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
 226     dsk.unit = dsk.drive & DRV_MASK;
 227     dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1;
 228     bootinfo.bi_version = BOOTINFO_VERSION;
 229     bootinfo.bi_size = sizeof(bootinfo);
 230     bootinfo.bi_basemem = 0;    /* XXX will be filled by loader or kernel */
 231     bootinfo.bi_extmem = memsize();
 232     bootinfo.bi_memsizes_valid++;
 233
 234     /* Process configuration file */
 235
 236     autoboot = 1;
 237
 238     if ((ino = lookup(PATH_CONFIG)))
 239         fsread(ino, cmd, sizeof(cmd));
 240
 241     if (cmd[0]) {
 242         printf("%s: %s", PATH_CONFIG, cmd);
 243         if (parse())
 244             autoboot = 0;
 245         /* Do not process this command twice */
 246         *cmd = 0;
 247     }
 248
 249     /*
 250      * Setup our (serial) console after processing the config file.  If
 251      * the initialization fails, don't try to use the serial port.  This
 252      * can happen if the serial port is unmaped (happens on new laptops a lot).
 253      */
 254     if ((opts & (RBF_MUTE|RBF_SERIAL|RBF_VIDEO)) == 0)
 255         opts |= RBF_SERIAL|RBF_VIDEO;
 256     if (opts & RBF_SERIAL) {
 257         if (sio_init())
 258             opts = RBF_VIDEO;
 259     }
 260
 261
 262     /*
 263      * Try to exec stage 3 boot loader. If interrupted by a keypress,
 264      * or in case of failure, try to load a kernel directly instead.
 265      */
 266
 267     if (autoboot && !*kname) {
 268         memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
 269         if (!keyhit(3*SECOND)) {
 270             load();
 271             memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
 272         }
 273     }
 274
 275     /* Present the user with the boot2 prompt. */
 276
 277     for (;;) {
 278         printf("\nDragonFly boot\n"
 279                "%u:%s(%u,%c)%s: ",
 280                dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
 281                'a' + dsk.part, kname);
 282         if (!autoboot || keyhit(5*SECOND))
 283             getstr();
 284         else
 285             putchar('\n');
 286         autoboot = 0;
 287         if (cmd[0] == 0 || parse())
 288             putchar('\a');
 289         else
 290             load();
 291     }
 292 }
 293
 294 /* XXX - Needed for btxld to link the boot2 binary; do not remove. */
 295 void
 296 exit(int x)
 297 {
 298 }
 299
 300 static void
 301 load(void)
 302 {
 303     union {
 304         struct exec ex;
 305         Elf32_Ehdr eh;
 306     } hdr;
 307     Elf32_Phdr ep[2];
 308     Elf32_Shdr es[2];
 309     caddr_t p;
 310     ino_t ino;
 311     uint32_t addr, x;
 312     int fmt, i, j;
 313
 314     if (!(ino = lookup(kname))) {
 315         if (!ls)
 316             printf("No %s\n", kname);
 317         return;
 318     }
 319     if (xfsread(ino, &hdr, sizeof(hdr)))
 320         return;
 321     if (N_GETMAGIC(hdr.ex) == ZMAGIC)
 322         fmt = 0;
 323     else if (IS_ELF(hdr.eh))
 324         fmt = 1;
 325     else {
 326         printf("Invalid %s\n", "format");
 327         return;
 328     }
 329     if (fmt == 0) {
 330         addr = hdr.ex.a_entry & 0xffffff;
 331         p = PTOV(addr);
 332         fs_off = PAGE_SIZE;
 333         if (xfsread(ino, p, hdr.ex.a_text))
 334             return;
 335         p += roundup2(hdr.ex.a_text, PAGE_SIZE);
 336         if (xfsread(ino, p, hdr.ex.a_data))
 337             return;
 338         p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE);
 339         bootinfo.bi_symtab = VTOP(p);
 340         memcpy(p, &hdr.ex.a_syms, sizeof(hdr.ex.a_syms));
 341         p += sizeof(hdr.ex.a_syms);
 342         if (hdr.ex.a_syms) {
 343             if (xfsread(ino, p, hdr.ex.a_syms))
 344                 return;
 345             p += hdr.ex.a_syms;
 346             if (xfsread(ino, p, sizeof(int)))
 347                 return;
 348             x = *(uint32_t *)p;
 349             p += sizeof(int);
 350             x -= sizeof(int);
 351             if (xfsread(ino, p, x))
 352                 return;
 353             p += x;
 354         }
 355     } else {
 356         fs_off = hdr.eh.e_phoff;
 357         for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) {
 358             if (xfsread(ino, ep + j, sizeof(ep[0])))
 359                 return;
 360             if (ep[j].p_type == PT_LOAD)
 361                 j++;
 362         }
 363         for (i = 0; i < 2; i++) {
 364             p = PTOV(ep[i].p_paddr & 0xffffff);
 365             fs_off = ep[i].p_offset;
 366             if (xfsread(ino, p, ep[i].p_filesz))
 367                 return;
 368         }
 369         p += roundup2(ep[1].p_memsz, PAGE_SIZE);
 370         bootinfo.bi_symtab = VTOP(p);
 371         if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) {
 372             fs_off = hdr.eh.e_shoff + sizeof(es[0]) *
 373                 (hdr.eh.e_shstrndx + 1);
 374             if (xfsread(ino, &es, sizeof(es)))
 375                 return;
 376             for (i = 0; i < 2; i++) {
 377                 memcpy(p, &es[i].sh_size, sizeof(es[i].sh_size));
 378                 p += sizeof(es[i].sh_size);
 379                 fs_off = es[i].sh_offset;
 380                 if (xfsread(ino, p, es[i].sh_size))
 381                     return;
 382                 p += es[i].sh_size;
 383             }
 384         }
 385         addr = hdr.eh.e_entry & 0xffffff;
 386     }
 387     bootinfo.bi_esymtab = VTOP(p);
 388     bootinfo.bi_kernelname = VTOP(kname);
 389     bootinfo.bi_bios_dev = dsk.drive;
 390     __exec((caddr_t)addr, opts & RBX_MASK,
 391            MAKEBOOTDEV(dev_maj[dsk.type], 0, dsk.slice, dsk.unit, dsk.part),
 392            0, 0, 0, VTOP(&bootinfo));
 393 }
 394
 395 static int
 396 parse()
 397 {
 398     char *arg = cmd;
 399     char *p, *q;
 400     unsigned int drv;
 401     int c, i;
 402
 403     while ((c = *arg++)) {
 404         if (c == ' ' || c == '\t' || c == '\n')
 405             continue;
 406         for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++)
 407             ;
 408         if (*p)
 409             *p++ = 0;
 410         if (c == '-') {
 411             while ((c = *arg++)) {
 412                 for (i = NOPT - 1; i >= 0; --i) {
 413                     if (optstr[i] == c) {
 414                         opts ^= 1 << flags[i];
 415                         goto ok;
 416                     }
 417                 }
 418                 return(-1);
 419                 ok: ;   /* ugly but save space */
 420             }
 421             if (opts & (1 << RBX_PROBEKBD)) {
 422                 i = *(uint8_t *)PTOV(0x496) & 0x10;
 423                 if (!i) {
 424                     printf("NO KB\n");
 425                     opts |= RBF_VIDEO | RBF_SERIAL;
 426                 }
 427                 opts &= ~(1 << RBX_PROBEKBD);
 428             }
 429         } else {
 430             for (q = arg--; *q && *q != '('; q++);
 431             if (*q) {
 432                 drv = -1;
 433                 if (arg[1] == ':') {
 434                     drv = *arg - '0';
 435                     if (drv > 9)
 436                         return (-1);
 437                     arg += 2;
 438                 }
 439                 if (q - arg != 2)
 440                     return -1;
 441                 for (i = 0; arg[0] != dev_nm[i][0] ||
 442                             arg[1] != dev_nm[i][1]; i++)
 443                     if (i == NDEV - 1)
 444                         return -1;
 445                 dsk.type = i;
 446                 arg += 3;
 447                 dsk.unit = *arg - '0';
 448                 if (arg[1] != ',' || dsk.unit > 9)
 449                     return -1;
 450                 arg += 2;
 451                 dsk.slice = WHOLE_DISK_SLICE;
 452                 if (arg[1] == ',') {
 453                     dsk.slice = *arg - '0' + 1;
 454                     if (dsk.slice > NDOSPART)
 455                         return -1;
 456                     arg += 2;
 457                 }
 458                 if (arg[1] != ')')
 459                     return -1;
 460                 dsk.part = *arg - 'a';
 461                 if (dsk.part > 7)
 462                     return (-1);
 463                 arg += 2;
 464                 if (drv == -1)
 465                     drv = dsk.unit;
 466                 dsk.drive = (dsk.type <= TYPE_MAXHARD
 467                              ? DRV_HARD : 0) + drv;
 468                 dsk_meta = 0;
 469             }
 470             if ((i = p - arg - !*(p - 1))) {
 471                 if ((size_t)i >= sizeof(kname))
 472                     return -1;
 473                 memcpy(kname, arg, i + 1);
 474             }
 475         }
 476         arg = p;
 477     }
 478     return 0;
 479 }
 480
 481 static int
 482 dskread(void *buf, unsigned lba, unsigned nblk)
 483 {
 484     struct dos_partition *dp;
 485     struct disklabel *d;
 486     char *sec;
 487     unsigned sl, i;
 488
 489     if (!dsk_meta) {
 490         sec = dmadat->secbuf;
 491         dsk.start = 0;
 492         if (drvread(sec, DOSBBSECTOR, 1))
 493             return -1;
 494         dp = (void *)(sec + DOSPARTOFF);
 495         sl = dsk.slice;
 496         if (sl < BASE_SLICE) {
 497             for (i = 0; i < NDOSPART; i++)
 498                 if (dp[i].dp_typ == DOSPTYP_386BSD &&
 499                     (dp[i].dp_flag & 0x80 || sl < BASE_SLICE)) {
 500                     sl = BASE_SLICE + i;
 501                     if (dp[i].dp_flag & 0x80 ||
 502                         dsk.slice == COMPATIBILITY_SLICE)
 503                         break;
 504                 }
 505             if (dsk.slice == WHOLE_DISK_SLICE)
 506                 dsk.slice = sl;
 507         }
 508         if (sl != WHOLE_DISK_SLICE) {
 509             if (sl != COMPATIBILITY_SLICE)
 510                 dp += sl - BASE_SLICE;
 511             if (dp->dp_typ != DOSPTYP_386BSD) {
 512                 printf("Invalid %s\n", "slice");
 513                 return -1;
 514             }
 515             dsk.start = dp->dp_start;
 516         }
 517         if (drvread(sec, dsk.start + LABELSECTOR, 1))
 518                 return -1;
 519         d = (void *)(sec + LABELOFFSET);
 520         if (d->d_magic != DISKMAGIC || d->d_magic2 != DISKMAGIC) {
 521             if (dsk.part != RAW_PART) {
 522                 printf("Invalid %s\n", "label");
 523                 return -1;
 524             }
 525         } else {
 526             if (!dsk.init) {
 527                 if (d->d_type == DTYPE_SCSI)
 528                     dsk.type = TYPE_DA;
 529                 dsk.init++;
 530             }
 531             if (dsk.part >= d->d_npartitions ||
 532                 !d->d_partitions[dsk.part].p_size) {
 533                 printf("Invalid %s\n", "partition");
 534                 return -1;
 535             }
 536             dsk.start += d->d_partitions[dsk.part].p_offset;
 537             dsk.start -= d->d_partitions[RAW_PART].p_offset;
 538         }
 539     }
 540     return drvread(buf, dsk.start + lba, nblk);
 541 }
 542
 543 static void
 544 printf(const char *fmt,...)
 545 {
 546     va_list ap;
 547     char buf[10];
 548     char *s;
 549     unsigned u;
 550     int c;
 551
 552     va_start(ap, fmt);
 553     while ((c = *fmt++)) {
 554         if (c == '%') {
 555             c = *fmt++;
 556             switch (c) {
 557             case 'c':
 558                 putchar(va_arg(ap, int));
 559                 continue;
 560             case 's':
 561                 for (s = va_arg(ap, char *); *s; s++)
 562                     putchar(*s);
 563                 continue;
 564             case 'u':
 565                 u = va_arg(ap, unsigned);
 566                 s = buf;
 567                 do
 568                     *s++ = '0' + u % 10U;
 569                 while (u /= 10U);
 570                 while (--s >= buf)
 571                     putchar(*s);
 572                 continue;
 573             }
 574         }
 575         putchar(c);
 576     }
 577     va_end(ap);
 578     return;
 579 }
 580
 581 static void
 582 putchar(int c)
 583 {
 584     if (c == '\n')
 585         xputc('\r');
 586     xputc(c);
 587 }
 588
 589 static int
 590 drvread(void *buf, unsigned lba, unsigned nblk)
 591 {
 592     static unsigned c = 0x2d5c7c2f;     /* twiddle */
 593
 594     c = (c << 8) | (c >> 24);
 595     xputc(c);
 596     xputc('\b');
 597     v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
 598     v86.addr = XREADORG;                /* call to xread in boot1 */
 599     v86.es = VTOPSEG(buf);
 600     v86.eax = lba;
 601     v86.ebx = VTOPOFF(buf);
 602     v86.ecx = lba >> 16;
 603     v86.edx = nblk << 8 | dsk.drive;
 604     v86int();
 605     v86.ctl = V86_FLAGS;
 606     if (V86_CY(v86.efl)) {
 607         printf("error %u lba %u\n", v86.eax >> 8 & 0xff, lba);
 608         return -1;
 609     }
 610     return 0;
 611 }
 612
 613 static int
 614 keyhit(unsigned ticks)
 615 {
 616     uint32_t t0, t1;
 617
 618     if (opts & 1 << RBX_NOINTR)
 619         return 0;
 620     t0 = 0;
 621     for (;;) {
 622         if (xgetc(1))
 623             return 1;
 624         t1 = *(uint32_t *)PTOV(0x46c);
 625         if (!t0)
 626             t0 = t1;
 627         if (t1 < t0 || t1 >= t0 + ticks)
 628             return 0;
 629     }
 630 }
 631
 632 static void
 633 xputc(int c)
 634 {
 635     if (opts & RBF_VIDEO)
 636         putc(c);
 637     if (opts & RBF_SERIAL)
 638         sio_putc(c);
 639 }
 640
 641 static int
 642 xgetc(int fn)
 643 {
 644     if (opts & 1 << RBX_NOINTR)
 645         return 0;
 646     for (;;) {
 647         if ((opts & RBF_VIDEO) && getc(1))
 648             return fn ? 1 : getc(0);
 649         if ((opts & RBF_SERIAL) && sio_ischar())
 650             return fn ? 1 : sio_getc();
 651         if (fn)
 652             return 0;
 653     }
 654 }
 655
 656 static int
 657 getc(int fn)
 658 {
 659     v86.addr = 0x16;
 660     v86.eax = fn << 8;
 661     v86int();
 662     return fn == 0 ? v86.eax & 0xff : !V86_ZR(v86.efl);
 663 }