1ca987d46SWarner Losh /*- 2ca987d46SWarner Losh * Copyright (c) 1998 Robert Nordier 3ca987d46SWarner Losh * All rights reserved. 4ca987d46SWarner Losh * 5ca987d46SWarner Losh * Redistribution and use in source and binary forms are freely 6ca987d46SWarner Losh * permitted provided that the above copyright notice and this 7ca987d46SWarner Losh * paragraph and the following disclaimer are duplicated in all 8ca987d46SWarner Losh * such forms. 9ca987d46SWarner Losh * 10ca987d46SWarner Losh * This software is provided "AS IS" and without any express or 11ca987d46SWarner Losh * implied warranties, including, without limitation, the implied 12ca987d46SWarner Losh * warranties of merchantability and fitness for a particular 13ca987d46SWarner Losh * purpose. 14ca987d46SWarner Losh */ 15ca987d46SWarner Losh 16ca987d46SWarner Losh #include <sys/cdefs.h> 17ca987d46SWarner Losh __FBSDID("$FreeBSD$"); 18ca987d46SWarner Losh 1965628439SWarner Losh #include "stand.h" 2065628439SWarner Losh 21ca987d46SWarner Losh #include <sys/param.h> 22ca987d46SWarner Losh #include <sys/errno.h> 23ca987d46SWarner Losh #include <sys/diskmbr.h> 24ca987d46SWarner Losh #ifdef GPT 25ca987d46SWarner Losh #include <sys/gpt.h> 26ca987d46SWarner Losh #endif 27ca987d46SWarner Losh #include <sys/reboot.h> 28ca987d46SWarner Losh #include <sys/queue.h> 29ca987d46SWarner Losh 30ca987d46SWarner Losh #include <machine/bootinfo.h> 31ca987d46SWarner Losh #include <machine/elf.h> 32ca987d46SWarner Losh #include <machine/pc/bios.h> 33ca987d46SWarner Losh 34ca987d46SWarner Losh #include <stdarg.h> 35ca987d46SWarner Losh #include <stddef.h> 36ca987d46SWarner Losh 37ca987d46SWarner Losh #include <a.out.h> 38ca987d46SWarner Losh 39ca987d46SWarner Losh #include <btxv86.h> 40ca987d46SWarner Losh 41ca987d46SWarner Losh #include "lib.h" 42ca987d46SWarner Losh #include "rbx.h" 43ca987d46SWarner Losh #include "drv.h" 44ca987d46SWarner Losh #include "edd.h" 45ca987d46SWarner Losh #include "cons.h" 46ca987d46SWarner Losh #include "bootargs.h" 47ca987d46SWarner Losh #include "paths.h" 48ca987d46SWarner Losh 49ca987d46SWarner Losh #include "libzfs.h" 50ca987d46SWarner Losh 51ca987d46SWarner Losh #define ARGS 0x900 52ca987d46SWarner Losh #define NOPT 14 53ca987d46SWarner Losh #define NDEV 3 54ca987d46SWarner Losh 55ca987d46SWarner Losh #define BIOS_NUMDRIVES 0x475 56ca987d46SWarner Losh #define DRV_HARD 0x80 57ca987d46SWarner Losh #define DRV_MASK 0x7f 58ca987d46SWarner Losh 59ca987d46SWarner Losh #define TYPE_AD 0 60ca987d46SWarner Losh #define TYPE_DA 1 61ca987d46SWarner Losh #define TYPE_MAXHARD TYPE_DA 62ca987d46SWarner Losh #define TYPE_FD 2 63ca987d46SWarner Losh 64ca987d46SWarner Losh #define DEV_GELIBOOT_BSIZE 4096 65ca987d46SWarner Losh 66ca987d46SWarner Losh extern uint32_t _end; 67ca987d46SWarner Losh 68ca987d46SWarner Losh #ifdef GPT 69ca987d46SWarner Losh static const uuid_t freebsd_zfs_uuid = GPT_ENT_TYPE_FREEBSD_ZFS; 70ca987d46SWarner Losh #endif 71ca987d46SWarner Losh static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */ 72ca987d46SWarner Losh static const unsigned char flags[NOPT] = { 73ca987d46SWarner Losh RBX_DUAL, 74ca987d46SWarner Losh RBX_SERIAL, 75ca987d46SWarner Losh RBX_ASKNAME, 76ca987d46SWarner Losh RBX_CDROM, 77ca987d46SWarner Losh RBX_CONFIG, 78ca987d46SWarner Losh RBX_KDB, 79ca987d46SWarner Losh RBX_GDB, 80ca987d46SWarner Losh RBX_MUTE, 81ca987d46SWarner Losh RBX_NOINTR, 82ca987d46SWarner Losh RBX_PAUSE, 83ca987d46SWarner Losh RBX_QUIET, 84ca987d46SWarner Losh RBX_DFLTROOT, 85ca987d46SWarner Losh RBX_SINGLE, 86ca987d46SWarner Losh RBX_VERBOSE 87ca987d46SWarner Losh }; 88ca987d46SWarner Losh uint32_t opts; 89ca987d46SWarner Losh 90ca987d46SWarner Losh static const unsigned char dev_maj[NDEV] = {30, 4, 2}; 91ca987d46SWarner Losh 92ca987d46SWarner Losh static char cmd[512]; 93ca987d46SWarner Losh static char cmddup[512]; 94ca987d46SWarner Losh static char kname[1024]; 95ca987d46SWarner Losh static char rootname[256]; 96ca987d46SWarner Losh static int comspeed = SIOSPD; 97ca987d46SWarner Losh static struct bootinfo bootinfo; 98ca987d46SWarner Losh static uint32_t bootdev; 99ca987d46SWarner Losh static struct zfs_boot_args zfsargs; 100ca987d46SWarner Losh 101ca987d46SWarner Losh vm_offset_t high_heap_base; 102ca987d46SWarner Losh uint32_t bios_basemem, bios_extmem, high_heap_size; 103ca987d46SWarner Losh 104ca987d46SWarner Losh static struct bios_smap smap; 105ca987d46SWarner Losh 106ca987d46SWarner Losh /* 107ca987d46SWarner Losh * The minimum amount of memory to reserve in bios_extmem for the heap. 108ca987d46SWarner Losh */ 109ca987d46SWarner Losh #define HEAP_MIN (64 * 1024 * 1024) 110ca987d46SWarner Losh 111ca987d46SWarner Losh static char *heap_next; 112ca987d46SWarner Losh static char *heap_end; 113ca987d46SWarner Losh 114ca987d46SWarner Losh /* Buffers that must not span a 64k boundary. */ 115ca987d46SWarner Losh #define READ_BUF_SIZE 8192 116ca987d46SWarner Losh struct dmadat { 117ca987d46SWarner Losh char rdbuf[READ_BUF_SIZE]; /* for reading large things */ 118ca987d46SWarner Losh char secbuf[READ_BUF_SIZE]; /* for MBR/disklabel */ 119ca987d46SWarner Losh }; 120ca987d46SWarner Losh static struct dmadat *dmadat; 121ca987d46SWarner Losh 122ca987d46SWarner Losh void exit(int); 123ca987d46SWarner Losh void reboot(void); 124ca987d46SWarner Losh static void load(void); 125ca987d46SWarner Losh static int parse_cmd(void); 126ca987d46SWarner Losh static void bios_getmem(void); 127ca987d46SWarner Losh int main(void); 128ca987d46SWarner Losh 129ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 130c1418270SIan Lepore #include "geliboot.h" 131ca987d46SWarner Losh static char gelipw[GELI_PW_MAXLEN]; 132ca987d46SWarner Losh static struct keybuf *gelibuf; 133ca987d46SWarner Losh #endif 134ca987d46SWarner Losh 135c1418270SIan Lepore struct zfsdsk { 136c1418270SIan Lepore struct dsk dsk; 137c1418270SIan Lepore #ifdef LOADER_GELI_SUPPORT 138c1418270SIan Lepore struct geli_dev *gdev; 139c1418270SIan Lepore #endif 140c1418270SIan Lepore }; 141c1418270SIan Lepore 142ca987d46SWarner Losh #include "zfsimpl.c" 143ca987d46SWarner Losh 144ca987d46SWarner Losh /* 145ca987d46SWarner Losh * Read from a dnode (which must be from a ZPL filesystem). 146ca987d46SWarner Losh */ 147ca987d46SWarner Losh static int 148ca987d46SWarner Losh zfs_read(spa_t *spa, const dnode_phys_t *dnode, off_t *offp, void *start, size_t size) 149ca987d46SWarner Losh { 150ca987d46SWarner Losh const znode_phys_t *zp = (const znode_phys_t *) dnode->dn_bonus; 151ca987d46SWarner Losh size_t n; 152ca987d46SWarner Losh int rc; 153ca987d46SWarner Losh 154ca987d46SWarner Losh n = size; 155ca987d46SWarner Losh if (*offp + n > zp->zp_size) 156ca987d46SWarner Losh n = zp->zp_size - *offp; 157ca987d46SWarner Losh 158ca987d46SWarner Losh rc = dnode_read(spa, dnode, *offp, start, n); 159ca987d46SWarner Losh if (rc) 160ca987d46SWarner Losh return (-1); 161ca987d46SWarner Losh *offp += n; 162ca987d46SWarner Losh 163ca987d46SWarner Losh return (n); 164ca987d46SWarner Losh } 165ca987d46SWarner Losh 166ca987d46SWarner Losh /* 167ca987d46SWarner Losh * Current ZFS pool 168ca987d46SWarner Losh */ 169ca987d46SWarner Losh static spa_t *spa; 170ca987d46SWarner Losh static spa_t *primary_spa; 171ca987d46SWarner Losh static vdev_t *primary_vdev; 172ca987d46SWarner Losh 173ca987d46SWarner Losh /* 174ca987d46SWarner Losh * A wrapper for dskread that doesn't have to worry about whether the 175ca987d46SWarner Losh * buffer pointer crosses a 64k boundary. 176ca987d46SWarner Losh */ 177ca987d46SWarner Losh static int 1781227a4f4SWarner Losh vdev_read(void *xvdev, void *priv, off_t off, void *buf, size_t bytes) 179ca987d46SWarner Losh { 180ca987d46SWarner Losh char *p; 181ca987d46SWarner Losh daddr_t lba, alignlba; 182ca987d46SWarner Losh off_t diff; 183ca987d46SWarner Losh unsigned int nb, alignnb; 184c1418270SIan Lepore struct zfsdsk *zdsk = (struct zfsdsk *) priv; 185ca987d46SWarner Losh 186ca987d46SWarner Losh if ((off & (DEV_BSIZE - 1)) || (bytes & (DEV_BSIZE - 1))) 187ca987d46SWarner Losh return -1; 188ca987d46SWarner Losh 189ca987d46SWarner Losh p = buf; 190ca987d46SWarner Losh lba = off / DEV_BSIZE; 191c1418270SIan Lepore lba += zdsk->dsk.start; 192ca987d46SWarner Losh /* 193ca987d46SWarner Losh * Align reads to 4k else 4k sector GELIs will not decrypt. 194ca987d46SWarner Losh * Round LBA down to nearest multiple of DEV_GELIBOOT_BSIZE bytes. 195ca987d46SWarner Losh */ 196ca987d46SWarner Losh alignlba = rounddown2(off, DEV_GELIBOOT_BSIZE) / DEV_BSIZE; 197ca987d46SWarner Losh /* 198ca987d46SWarner Losh * The read must be aligned to DEV_GELIBOOT_BSIZE bytes relative to the 199ca987d46SWarner Losh * start of the GELI partition, not the start of the actual disk. 200ca987d46SWarner Losh */ 201c1418270SIan Lepore alignlba += zdsk->dsk.start; 202ca987d46SWarner Losh diff = (lba - alignlba) * DEV_BSIZE; 203ca987d46SWarner Losh 204ca987d46SWarner Losh while (bytes > 0) { 205ca987d46SWarner Losh nb = bytes / DEV_BSIZE; 206ca987d46SWarner Losh /* 207ca987d46SWarner Losh * Ensure that the read size plus the leading offset does not 208ca987d46SWarner Losh * exceed the size of the read buffer. 209ca987d46SWarner Losh */ 210ca987d46SWarner Losh if (nb > (READ_BUF_SIZE - diff) / DEV_BSIZE) 211ca987d46SWarner Losh nb = (READ_BUF_SIZE - diff) / DEV_BSIZE; 212ca987d46SWarner Losh /* 213ca987d46SWarner Losh * Round the number of blocks to read up to the nearest multiple 214ca987d46SWarner Losh * of DEV_GELIBOOT_BSIZE. 215ca987d46SWarner Losh */ 216ca987d46SWarner Losh alignnb = roundup2(nb * DEV_BSIZE + diff, DEV_GELIBOOT_BSIZE) 217ca987d46SWarner Losh / DEV_BSIZE; 218ca987d46SWarner Losh 219c1418270SIan Lepore if (zdsk->dsk.size > 0 && alignlba + alignnb > 220c1418270SIan Lepore zdsk->dsk.size + zdsk->dsk.start) { 221c1418270SIan Lepore printf("Shortening read at %lld from %d to %lld\n", 222c1418270SIan Lepore alignlba, alignnb, 223c1418270SIan Lepore (zdsk->dsk.size + zdsk->dsk.start) - alignlba); 224c1418270SIan Lepore alignnb = (zdsk->dsk.size + zdsk->dsk.start) - alignlba; 22571f0c895SAllan Jude } 22671f0c895SAllan Jude 227c1418270SIan Lepore if (drvread(&zdsk->dsk, dmadat->rdbuf, alignlba, alignnb)) 228ca987d46SWarner Losh return -1; 229ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 230ca987d46SWarner Losh /* decrypt */ 231c1418270SIan Lepore if (zdsk->gdev != NULL) { 232c1418270SIan Lepore if (geli_read(zdsk->gdev, ((alignlba - zdsk->dsk.start) * 233ca987d46SWarner Losh DEV_BSIZE), dmadat->rdbuf, alignnb * DEV_BSIZE)) 234ca987d46SWarner Losh return (-1); 235ca987d46SWarner Losh } 236ca987d46SWarner Losh #endif 237ca987d46SWarner Losh memcpy(p, dmadat->rdbuf + diff, nb * DEV_BSIZE); 238ca987d46SWarner Losh p += nb * DEV_BSIZE; 239ca987d46SWarner Losh lba += nb; 240ca987d46SWarner Losh alignlba += alignnb; 241ca987d46SWarner Losh bytes -= nb * DEV_BSIZE; 242ca987d46SWarner Losh /* Don't need the leading offset after the first block. */ 243ca987d46SWarner Losh diff = 0; 244ca987d46SWarner Losh } 245ca987d46SWarner Losh 246ca987d46SWarner Losh return 0; 247ca987d46SWarner Losh } 2481227a4f4SWarner Losh /* Match the signature exactly due to signature madness */ 2491227a4f4SWarner Losh static int 2501227a4f4SWarner Losh vdev_read2(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes) 2511227a4f4SWarner Losh { 2521227a4f4SWarner Losh return vdev_read(vdev, priv, off, buf, bytes); 2531227a4f4SWarner Losh } 2541227a4f4SWarner Losh 255ca987d46SWarner Losh 256ca987d46SWarner Losh static int 257ca987d46SWarner Losh vdev_write(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes) 258ca987d46SWarner Losh { 259ca987d46SWarner Losh char *p; 260ca987d46SWarner Losh daddr_t lba; 261ca987d46SWarner Losh unsigned int nb; 262c1418270SIan Lepore struct zfsdsk *zdsk = (struct zfsdsk *) priv; 263ca987d46SWarner Losh 264ca987d46SWarner Losh if ((off & (DEV_BSIZE - 1)) || (bytes & (DEV_BSIZE - 1))) 265ca987d46SWarner Losh return -1; 266ca987d46SWarner Losh 267ca987d46SWarner Losh p = buf; 268ca987d46SWarner Losh lba = off / DEV_BSIZE; 269c1418270SIan Lepore lba += zdsk->dsk.start; 270ca987d46SWarner Losh while (bytes > 0) { 271ca987d46SWarner Losh nb = bytes / DEV_BSIZE; 272ca987d46SWarner Losh if (nb > READ_BUF_SIZE / DEV_BSIZE) 273ca987d46SWarner Losh nb = READ_BUF_SIZE / DEV_BSIZE; 274ca987d46SWarner Losh memcpy(dmadat->rdbuf, p, nb * DEV_BSIZE); 275c1418270SIan Lepore if (drvwrite(&zdsk->dsk, dmadat->rdbuf, lba, nb)) 276ca987d46SWarner Losh return -1; 277ca987d46SWarner Losh p += nb * DEV_BSIZE; 278ca987d46SWarner Losh lba += nb; 279ca987d46SWarner Losh bytes -= nb * DEV_BSIZE; 280ca987d46SWarner Losh } 281ca987d46SWarner Losh 282ca987d46SWarner Losh return 0; 283ca987d46SWarner Losh } 284ca987d46SWarner Losh 285ca987d46SWarner Losh static int 286ca987d46SWarner Losh xfsread(const dnode_phys_t *dnode, off_t *offp, void *buf, size_t nbyte) 287ca987d46SWarner Losh { 288ca987d46SWarner Losh if ((size_t)zfs_read(spa, dnode, offp, buf, nbyte) != nbyte) { 289ca987d46SWarner Losh printf("Invalid format\n"); 290ca987d46SWarner Losh return -1; 291ca987d46SWarner Losh } 292ca987d46SWarner Losh return 0; 293ca987d46SWarner Losh } 294ca987d46SWarner Losh 295ca987d46SWarner Losh /* 296ca987d46SWarner Losh * Read Pad2 (formerly "Boot Block Header") area of the first 297ca987d46SWarner Losh * vdev label of the given vdev. 298ca987d46SWarner Losh */ 299ca987d46SWarner Losh static int 300ca987d46SWarner Losh vdev_read_pad2(vdev_t *vdev, char *buf, size_t size) 301ca987d46SWarner Losh { 302ca987d46SWarner Losh blkptr_t bp; 303ca987d46SWarner Losh char *tmp = zap_scratch; 304ca987d46SWarner Losh off_t off = offsetof(vdev_label_t, vl_pad2); 305ca987d46SWarner Losh 306ca987d46SWarner Losh if (size > VDEV_PAD_SIZE) 307ca987d46SWarner Losh size = VDEV_PAD_SIZE; 308ca987d46SWarner Losh 309ca987d46SWarner Losh BP_ZERO(&bp); 310ca987d46SWarner Losh BP_SET_LSIZE(&bp, VDEV_PAD_SIZE); 311ca987d46SWarner Losh BP_SET_PSIZE(&bp, VDEV_PAD_SIZE); 312ca987d46SWarner Losh BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL); 313ca987d46SWarner Losh BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF); 314ca987d46SWarner Losh DVA_SET_OFFSET(BP_IDENTITY(&bp), off); 315ca987d46SWarner Losh if (vdev_read_phys(vdev, &bp, tmp, off, 0)) 316ca987d46SWarner Losh return (EIO); 317ca987d46SWarner Losh memcpy(buf, tmp, size); 318ca987d46SWarner Losh return (0); 319ca987d46SWarner Losh } 320ca987d46SWarner Losh 321ca987d46SWarner Losh static int 322ca987d46SWarner Losh vdev_clear_pad2(vdev_t *vdev) 323ca987d46SWarner Losh { 324ca987d46SWarner Losh char *zeroes = zap_scratch; 325ca987d46SWarner Losh uint64_t *end; 326ca987d46SWarner Losh off_t off = offsetof(vdev_label_t, vl_pad2); 327ca987d46SWarner Losh 328ca987d46SWarner Losh memset(zeroes, 0, VDEV_PAD_SIZE); 329ca987d46SWarner Losh end = (uint64_t *)(zeroes + VDEV_PAD_SIZE); 330ca987d46SWarner Losh /* ZIO_CHECKSUM_LABEL magic and pre-calcualted checksum for all zeros */ 331ca987d46SWarner Losh end[-5] = 0x0210da7ab10c7a11; 332ca987d46SWarner Losh end[-4] = 0x97f48f807f6e2a3f; 333ca987d46SWarner Losh end[-3] = 0xaf909f1658aacefc; 334ca987d46SWarner Losh end[-2] = 0xcbd1ea57ff6db48b; 335ca987d46SWarner Losh end[-1] = 0x6ec692db0d465fab; 336ca987d46SWarner Losh if (vdev_write(vdev, vdev->v_read_priv, off, zeroes, VDEV_PAD_SIZE)) 337ca987d46SWarner Losh return (EIO); 338ca987d46SWarner Losh return (0); 339ca987d46SWarner Losh } 340ca987d46SWarner Losh 341ca987d46SWarner Losh static void 342ca987d46SWarner Losh bios_getmem(void) 343ca987d46SWarner Losh { 344ca987d46SWarner Losh uint64_t size; 345ca987d46SWarner Losh 346ca987d46SWarner Losh /* Parse system memory map */ 347ca987d46SWarner Losh v86.ebx = 0; 348ca987d46SWarner Losh do { 349ca987d46SWarner Losh v86.ctl = V86_FLAGS; 350ca987d46SWarner Losh v86.addr = 0x15; /* int 0x15 function 0xe820*/ 351ca987d46SWarner Losh v86.eax = 0xe820; 352ca987d46SWarner Losh v86.ecx = sizeof(struct bios_smap); 353ca987d46SWarner Losh v86.edx = SMAP_SIG; 354ca987d46SWarner Losh v86.es = VTOPSEG(&smap); 355ca987d46SWarner Losh v86.edi = VTOPOFF(&smap); 356ca987d46SWarner Losh v86int(); 357ca987d46SWarner Losh if (V86_CY(v86.efl) || (v86.eax != SMAP_SIG)) 358ca987d46SWarner Losh break; 359ca987d46SWarner Losh /* look for a low-memory segment that's large enough */ 360ca987d46SWarner Losh if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) && 361ca987d46SWarner Losh (smap.length >= (512 * 1024))) 362ca987d46SWarner Losh bios_basemem = smap.length; 363ca987d46SWarner Losh /* look for the first segment in 'extended' memory */ 364ca987d46SWarner Losh if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0x100000)) { 365ca987d46SWarner Losh bios_extmem = smap.length; 366ca987d46SWarner Losh } 367ca987d46SWarner Losh 368ca987d46SWarner Losh /* 369ca987d46SWarner Losh * Look for the largest segment in 'extended' memory beyond 370ca987d46SWarner Losh * 1MB but below 4GB. 371ca987d46SWarner Losh */ 372ca987d46SWarner Losh if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base > 0x100000) && 373ca987d46SWarner Losh (smap.base < 0x100000000ull)) { 374ca987d46SWarner Losh size = smap.length; 375ca987d46SWarner Losh 376ca987d46SWarner Losh /* 377ca987d46SWarner Losh * If this segment crosses the 4GB boundary, truncate it. 378ca987d46SWarner Losh */ 379ca987d46SWarner Losh if (smap.base + size > 0x100000000ull) 380ca987d46SWarner Losh size = 0x100000000ull - smap.base; 381ca987d46SWarner Losh 382ca987d46SWarner Losh if (size > high_heap_size) { 383ca987d46SWarner Losh high_heap_size = size; 384ca987d46SWarner Losh high_heap_base = smap.base; 385ca987d46SWarner Losh } 386ca987d46SWarner Losh } 387ca987d46SWarner Losh } while (v86.ebx != 0); 388ca987d46SWarner Losh 389ca987d46SWarner Losh /* Fall back to the old compatibility function for base memory */ 390ca987d46SWarner Losh if (bios_basemem == 0) { 391ca987d46SWarner Losh v86.ctl = 0; 392ca987d46SWarner Losh v86.addr = 0x12; /* int 0x12 */ 393ca987d46SWarner Losh v86int(); 394ca987d46SWarner Losh 395ca987d46SWarner Losh bios_basemem = (v86.eax & 0xffff) * 1024; 396ca987d46SWarner Losh } 397ca987d46SWarner Losh 398ca987d46SWarner Losh /* Fall back through several compatibility functions for extended memory */ 399ca987d46SWarner Losh if (bios_extmem == 0) { 400ca987d46SWarner Losh v86.ctl = V86_FLAGS; 401ca987d46SWarner Losh v86.addr = 0x15; /* int 0x15 function 0xe801*/ 402ca987d46SWarner Losh v86.eax = 0xe801; 403ca987d46SWarner Losh v86int(); 404ca987d46SWarner Losh if (!V86_CY(v86.efl)) { 405ca987d46SWarner Losh bios_extmem = ((v86.ecx & 0xffff) + ((v86.edx & 0xffff) * 64)) * 1024; 406ca987d46SWarner Losh } 407ca987d46SWarner Losh } 408ca987d46SWarner Losh if (bios_extmem == 0) { 409ca987d46SWarner Losh v86.ctl = 0; 410ca987d46SWarner Losh v86.addr = 0x15; /* int 0x15 function 0x88*/ 411ca987d46SWarner Losh v86.eax = 0x8800; 412ca987d46SWarner Losh v86int(); 413ca987d46SWarner Losh bios_extmem = (v86.eax & 0xffff) * 1024; 414ca987d46SWarner Losh } 415ca987d46SWarner Losh 416ca987d46SWarner Losh /* 417ca987d46SWarner Losh * If we have extended memory and did not find a suitable heap 418ca987d46SWarner Losh * region in the SMAP, use the last 3MB of 'extended' memory as a 419ca987d46SWarner Losh * high heap candidate. 420ca987d46SWarner Losh */ 421ca987d46SWarner Losh if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) { 422ca987d46SWarner Losh high_heap_size = HEAP_MIN; 423ca987d46SWarner Losh high_heap_base = bios_extmem + 0x100000 - HEAP_MIN; 424ca987d46SWarner Losh } 425ca987d46SWarner Losh } 426ca987d46SWarner Losh 427ca987d46SWarner Losh /* 428ca987d46SWarner Losh * Try to detect a device supported by the legacy int13 BIOS 429ca987d46SWarner Losh */ 430ca987d46SWarner Losh static int 431ca987d46SWarner Losh int13probe(int drive) 432ca987d46SWarner Losh { 433ca987d46SWarner Losh v86.ctl = V86_FLAGS; 434ca987d46SWarner Losh v86.addr = 0x13; 435ca987d46SWarner Losh v86.eax = 0x800; 436ca987d46SWarner Losh v86.edx = drive; 437ca987d46SWarner Losh v86int(); 438ca987d46SWarner Losh 439ca987d46SWarner Losh if (!V86_CY(v86.efl) && /* carry clear */ 440ca987d46SWarner Losh ((v86.edx & 0xff) != (drive & DRV_MASK))) { /* unit # OK */ 441ca987d46SWarner Losh if ((v86.ecx & 0x3f) == 0) { /* absurd sector size */ 442ca987d46SWarner Losh return(0); /* skip device */ 443ca987d46SWarner Losh } 444ca987d46SWarner Losh return (1); 445ca987d46SWarner Losh } 446ca987d46SWarner Losh return(0); 447ca987d46SWarner Losh } 448ca987d46SWarner Losh 449ca987d46SWarner Losh /* 450ca987d46SWarner Losh * We call this when we find a ZFS vdev - ZFS consumes the dsk 451ca987d46SWarner Losh * structure so we must make a new one. 452ca987d46SWarner Losh */ 453c1418270SIan Lepore static struct zfsdsk * 454c1418270SIan Lepore copy_dsk(struct zfsdsk *zdsk) 455ca987d46SWarner Losh { 456c1418270SIan Lepore struct zfsdsk *newdsk; 457ca987d46SWarner Losh 458c1418270SIan Lepore newdsk = malloc(sizeof(struct zfsdsk)); 459c1418270SIan Lepore *newdsk = *zdsk; 460ca987d46SWarner Losh return (newdsk); 461ca987d46SWarner Losh } 462ca987d46SWarner Losh 463ca987d46SWarner Losh /* 464ca987d46SWarner Losh * Get disk size from eax=0x800 and 0x4800. We need to probe both 465ca987d46SWarner Losh * because 0x4800 may not be available and we would like to get more 466ca987d46SWarner Losh * or less correct disk size - if it is possible at all. 467ca987d46SWarner Losh * Note we do not really want to touch drv.c because that code is shared 468ca987d46SWarner Losh * with boot2 and we can not afford to grow that code. 469ca987d46SWarner Losh */ 470ca987d46SWarner Losh static uint64_t 471c1418270SIan Lepore drvsize_ext(struct zfsdsk *zdsk) 472ca987d46SWarner Losh { 473c1418270SIan Lepore struct dsk *dskp; 474ca987d46SWarner Losh uint64_t size, tmp; 475ca987d46SWarner Losh int cyl, hds, sec; 476ca987d46SWarner Losh 477c1418270SIan Lepore dskp = &zdsk->dsk; 478c1418270SIan Lepore 479ca987d46SWarner Losh v86.ctl = V86_FLAGS; 480ca987d46SWarner Losh v86.addr = 0x13; 481ca987d46SWarner Losh v86.eax = 0x800; 482ca987d46SWarner Losh v86.edx = dskp->drive; 483ca987d46SWarner Losh v86int(); 484ca987d46SWarner Losh 485ca987d46SWarner Losh /* Don't error out if we get bad sector number, try EDD as well */ 486ca987d46SWarner Losh if (V86_CY(v86.efl) || /* carry set */ 487ca987d46SWarner Losh (v86.edx & 0xff) <= (unsigned)(dskp->drive & 0x7f)) /* unit # bad */ 488ca987d46SWarner Losh return (0); 489ca987d46SWarner Losh cyl = ((v86.ecx & 0xc0) << 2) + ((v86.ecx & 0xff00) >> 8) + 1; 490ca987d46SWarner Losh /* Convert max head # -> # of heads */ 491ca987d46SWarner Losh hds = ((v86.edx & 0xff00) >> 8) + 1; 492ca987d46SWarner Losh sec = v86.ecx & 0x3f; 493ca987d46SWarner Losh 494ca987d46SWarner Losh size = (uint64_t)cyl * hds * sec; 495ca987d46SWarner Losh 496ca987d46SWarner Losh /* Determine if we can use EDD with this device. */ 497ca987d46SWarner Losh v86.ctl = V86_FLAGS; 498ca987d46SWarner Losh v86.addr = 0x13; 499ca987d46SWarner Losh v86.eax = 0x4100; 500ca987d46SWarner Losh v86.edx = dskp->drive; 501ca987d46SWarner Losh v86.ebx = 0x55aa; 502ca987d46SWarner Losh v86int(); 503ca987d46SWarner Losh if (V86_CY(v86.efl) || /* carry set */ 504ca987d46SWarner Losh (v86.ebx & 0xffff) != 0xaa55 || /* signature */ 505ca987d46SWarner Losh (v86.ecx & EDD_INTERFACE_FIXED_DISK) == 0) 506ca987d46SWarner Losh return (size); 507ca987d46SWarner Losh 508ca987d46SWarner Losh tmp = drvsize(dskp); 509ca987d46SWarner Losh if (tmp > size) 510ca987d46SWarner Losh size = tmp; 511ca987d46SWarner Losh 512ca987d46SWarner Losh return (size); 513ca987d46SWarner Losh } 514ca987d46SWarner Losh 515ca987d46SWarner Losh /* 516ca987d46SWarner Losh * The "layered" ioctl to read disk/partition size. Unfortunately 517ca987d46SWarner Losh * the zfsboot case is hardest, because we do not have full software 518ca987d46SWarner Losh * stack available, so we need to do some manual work here. 519ca987d46SWarner Losh */ 520ca987d46SWarner Losh uint64_t 521ca987d46SWarner Losh ldi_get_size(void *priv) 522ca987d46SWarner Losh { 523c1418270SIan Lepore struct zfsdsk *zdsk = priv; 524c1418270SIan Lepore uint64_t size = zdsk->dsk.size; 525ca987d46SWarner Losh 526c1418270SIan Lepore if (zdsk->dsk.start == 0) 527c1418270SIan Lepore size = drvsize_ext(zdsk); 528ca987d46SWarner Losh 529ca987d46SWarner Losh return (size * DEV_BSIZE); 530ca987d46SWarner Losh } 531ca987d46SWarner Losh 532ca987d46SWarner Losh static void 533c1418270SIan Lepore probe_drive(struct zfsdsk *zdsk) 534ca987d46SWarner Losh { 535ca987d46SWarner Losh #ifdef GPT 536ca987d46SWarner Losh struct gpt_hdr hdr; 537ca987d46SWarner Losh struct gpt_ent *ent; 538ca987d46SWarner Losh unsigned part, entries_per_sec; 539ca987d46SWarner Losh daddr_t slba; 540ca987d46SWarner Losh #endif 541ca987d46SWarner Losh #if defined(GPT) || defined(LOADER_GELI_SUPPORT) 542ca987d46SWarner Losh daddr_t elba; 543ca987d46SWarner Losh #endif 544ca987d46SWarner Losh 545ca987d46SWarner Losh struct dos_partition *dp; 546ca987d46SWarner Losh char *sec; 547ca987d46SWarner Losh unsigned i; 548ca987d46SWarner Losh 549ca987d46SWarner Losh /* 550ca987d46SWarner Losh * If we find a vdev on the whole disk, stop here. 551ca987d46SWarner Losh */ 552c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) 553ca987d46SWarner Losh return; 554ca987d46SWarner Losh 555ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 556ca987d46SWarner Losh /* 557ca987d46SWarner Losh * Taste the disk, if it is GELI encrypted, decrypt it and check to see if 558ca987d46SWarner Losh * it is a usable vdev then. Otherwise dig 559ca987d46SWarner Losh * out the partition table and probe each slice/partition 560ca987d46SWarner Losh * in turn for a vdev or GELI encrypted vdev. 561ca987d46SWarner Losh */ 562c1418270SIan Lepore elba = drvsize_ext(zdsk); 563ca987d46SWarner Losh if (elba > 0) { 564ca987d46SWarner Losh elba--; 565ca987d46SWarner Losh } 566c1418270SIan Lepore zdsk->gdev = geli_taste(vdev_read, zdsk, elba, "disk%u:0:"); 567c1418270SIan Lepore if (zdsk->gdev != NULL) { 568c1418270SIan Lepore if (geli_havekey(zdsk->gdev) == 0 || 569c1418270SIan Lepore geli_passphrase(zdsk->gdev, gelipw) == 0) { 570c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) { 571ca987d46SWarner Losh return; 572ca987d46SWarner Losh } 573ca987d46SWarner Losh } 574ca987d46SWarner Losh } 575ca987d46SWarner Losh #endif /* LOADER_GELI_SUPPORT */ 576ca987d46SWarner Losh 577ca987d46SWarner Losh sec = dmadat->secbuf; 578c1418270SIan Lepore zdsk->dsk.start = 0; 579ca987d46SWarner Losh 580ca987d46SWarner Losh #ifdef GPT 581ca987d46SWarner Losh /* 582ca987d46SWarner Losh * First check for GPT. 583ca987d46SWarner Losh */ 584c1418270SIan Lepore if (drvread(&zdsk->dsk, sec, 1, 1)) { 585ca987d46SWarner Losh return; 586ca987d46SWarner Losh } 587ca987d46SWarner Losh memcpy(&hdr, sec, sizeof(hdr)); 588ca987d46SWarner Losh if (memcmp(hdr.hdr_sig, GPT_HDR_SIG, sizeof(hdr.hdr_sig)) != 0 || 589ca987d46SWarner Losh hdr.hdr_lba_self != 1 || hdr.hdr_revision < 0x00010000 || 590ca987d46SWarner Losh hdr.hdr_entsz < sizeof(*ent) || DEV_BSIZE % hdr.hdr_entsz != 0) { 591ca987d46SWarner Losh goto trymbr; 592ca987d46SWarner Losh } 593ca987d46SWarner Losh 594ca987d46SWarner Losh /* 595ca987d46SWarner Losh * Probe all GPT partitions for the presence of ZFS pools. We 596ca987d46SWarner Losh * return the spa_t for the first we find (if requested). This 597ca987d46SWarner Losh * will have the effect of booting from the first pool on the 598ca987d46SWarner Losh * disk. 599ca987d46SWarner Losh * 600ca987d46SWarner Losh * If no vdev is found, GELI decrypting the device and try again 601ca987d46SWarner Losh */ 602ca987d46SWarner Losh entries_per_sec = DEV_BSIZE / hdr.hdr_entsz; 603ca987d46SWarner Losh slba = hdr.hdr_lba_table; 604ca987d46SWarner Losh elba = slba + hdr.hdr_entries / entries_per_sec; 605ca987d46SWarner Losh while (slba < elba) { 606c1418270SIan Lepore zdsk->dsk.start = 0; 607c1418270SIan Lepore if (drvread(&zdsk->dsk, sec, slba, 1)) 608ca987d46SWarner Losh return; 609ca987d46SWarner Losh for (part = 0; part < entries_per_sec; part++) { 610ca987d46SWarner Losh ent = (struct gpt_ent *)(sec + part * hdr.hdr_entsz); 611ca987d46SWarner Losh if (memcmp(&ent->ent_type, &freebsd_zfs_uuid, 612ca987d46SWarner Losh sizeof(uuid_t)) == 0) { 613c1418270SIan Lepore zdsk->dsk.start = ent->ent_lba_start; 614c1418270SIan Lepore zdsk->dsk.size = ent->ent_lba_end - ent->ent_lba_start + 1; 615c1418270SIan Lepore zdsk->dsk.slice = part + 1; 616c1418270SIan Lepore zdsk->dsk.part = 255; 617c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) { 618ca987d46SWarner Losh /* 619ca987d46SWarner Losh * This slice had a vdev. We need a new dsk 620ca987d46SWarner Losh * structure now since the vdev now owns this one. 621ca987d46SWarner Losh */ 622c1418270SIan Lepore zdsk = copy_dsk(zdsk); 623ca987d46SWarner Losh } 624ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 625c1418270SIan Lepore else if ((zdsk->gdev = geli_taste(vdev_read, zdsk, 626c1418270SIan Lepore ent->ent_lba_end - ent->ent_lba_start, "disk%up%u:", 627c1418270SIan Lepore zdsk->dsk.unit, zdsk->dsk.slice)) != NULL) { 628c1418270SIan Lepore if (geli_havekey(zdsk->gdev) == 0 || 629c1418270SIan Lepore geli_passphrase(zdsk->gdev, gelipw) == 0) { 630ca987d46SWarner Losh /* 631ca987d46SWarner Losh * This slice has GELI, check it for ZFS. 632ca987d46SWarner Losh */ 633c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) { 634ca987d46SWarner Losh /* 635ca987d46SWarner Losh * This slice had a vdev. We need a new dsk 636ca987d46SWarner Losh * structure now since the vdev now owns this one. 637ca987d46SWarner Losh */ 638c1418270SIan Lepore zdsk = copy_dsk(zdsk); 639ca987d46SWarner Losh } 640ca987d46SWarner Losh break; 641ca987d46SWarner Losh } 642ca987d46SWarner Losh } 643ca987d46SWarner Losh #endif /* LOADER_GELI_SUPPORT */ 644ca987d46SWarner Losh } 645ca987d46SWarner Losh } 646ca987d46SWarner Losh slba++; 647ca987d46SWarner Losh } 648ca987d46SWarner Losh return; 649ca987d46SWarner Losh trymbr: 650ca987d46SWarner Losh #endif /* GPT */ 651ca987d46SWarner Losh 652c1418270SIan Lepore if (drvread(&zdsk->dsk, sec, DOSBBSECTOR, 1)) 653ca987d46SWarner Losh return; 654ca987d46SWarner Losh dp = (void *)(sec + DOSPARTOFF); 655ca987d46SWarner Losh 656ca987d46SWarner Losh for (i = 0; i < NDOSPART; i++) { 657ca987d46SWarner Losh if (!dp[i].dp_typ) 658ca987d46SWarner Losh continue; 659c1418270SIan Lepore zdsk->dsk.start = dp[i].dp_start; 660c1418270SIan Lepore zdsk->dsk.size = dp[i].dp_size; 661c1418270SIan Lepore zdsk->dsk.slice = i + 1; 662c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) { 663c1418270SIan Lepore zdsk = copy_dsk(zdsk); 664ca987d46SWarner Losh } 665ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 666c1418270SIan Lepore else if ((zdsk->gdev = geli_taste(vdev_read, zdsk, dp[i].dp_size - 667c1418270SIan Lepore dp[i].dp_start, "disk%us%u:")) != NULL) { 668c1418270SIan Lepore if (geli_havekey(zdsk->gdev) == 0 || 669c1418270SIan Lepore geli_passphrase(zdsk->gdev, gelipw) == 0) { 670ca987d46SWarner Losh /* 671ca987d46SWarner Losh * This slice has GELI, check it for ZFS. 672ca987d46SWarner Losh */ 673c1418270SIan Lepore if (vdev_probe(vdev_read2, zdsk, NULL) == 0) { 674ca987d46SWarner Losh /* 675ca987d46SWarner Losh * This slice had a vdev. We need a new dsk 676ca987d46SWarner Losh * structure now since the vdev now owns this one. 677ca987d46SWarner Losh */ 678c1418270SIan Lepore zdsk = copy_dsk(zdsk); 679ca987d46SWarner Losh } 680ca987d46SWarner Losh break; 681ca987d46SWarner Losh } 682ca987d46SWarner Losh } 683ca987d46SWarner Losh #endif /* LOADER_GELI_SUPPORT */ 684ca987d46SWarner Losh } 685ca987d46SWarner Losh } 686ca987d46SWarner Losh 687ca987d46SWarner Losh int 688ca987d46SWarner Losh main(void) 689ca987d46SWarner Losh { 690ca987d46SWarner Losh dnode_phys_t dn; 691ca987d46SWarner Losh off_t off; 692c1418270SIan Lepore struct zfsdsk *zdsk; 693ca987d46SWarner Losh int autoboot, i; 694ca987d46SWarner Losh int nextboot; 695ca987d46SWarner Losh int rc; 696ca987d46SWarner Losh 697ca987d46SWarner Losh dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base); 698ca987d46SWarner Losh 699ca987d46SWarner Losh bios_getmem(); 700ca987d46SWarner Losh 701ca987d46SWarner Losh if (high_heap_size > 0) { 702ca987d46SWarner Losh heap_end = PTOV(high_heap_base + high_heap_size); 703ca987d46SWarner Losh heap_next = PTOV(high_heap_base); 704ca987d46SWarner Losh } else { 705ca987d46SWarner Losh heap_next = (char *)dmadat + sizeof(*dmadat); 706ca987d46SWarner Losh heap_end = (char *)PTOV(bios_basemem); 707ca987d46SWarner Losh } 70865628439SWarner Losh setheap(heap_next, heap_end); 709ca987d46SWarner Losh 7105abe8cb6SKristof Provost zdsk = calloc(1, sizeof(struct zfsdsk)); 711c1418270SIan Lepore zdsk->dsk.drive = *(uint8_t *)PTOV(ARGS); 712c1418270SIan Lepore zdsk->dsk.type = zdsk->dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; 713c1418270SIan Lepore zdsk->dsk.unit = zdsk->dsk.drive & DRV_MASK; 714c1418270SIan Lepore zdsk->dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1; 715c1418270SIan Lepore zdsk->dsk.part = 0; 716c1418270SIan Lepore zdsk->dsk.start = 0; 717c1418270SIan Lepore zdsk->dsk.size = drvsize_ext(zdsk); 718ca987d46SWarner Losh 719ca987d46SWarner Losh bootinfo.bi_version = BOOTINFO_VERSION; 720ca987d46SWarner Losh bootinfo.bi_size = sizeof(bootinfo); 721ca987d46SWarner Losh bootinfo.bi_basemem = bios_basemem / 1024; 722ca987d46SWarner Losh bootinfo.bi_extmem = bios_extmem / 1024; 723ca987d46SWarner Losh bootinfo.bi_memsizes_valid++; 724c1418270SIan Lepore bootinfo.bi_bios_dev = zdsk->dsk.drive; 725ca987d46SWarner Losh 726c1418270SIan Lepore bootdev = MAKEBOOTDEV(dev_maj[zdsk->dsk.type], 727c1418270SIan Lepore zdsk->dsk.slice, zdsk->dsk.unit, zdsk->dsk.part); 728ca987d46SWarner Losh 729ca987d46SWarner Losh /* Process configuration file */ 730ca987d46SWarner Losh 731ca987d46SWarner Losh autoboot = 1; 732ca987d46SWarner Losh 733ca987d46SWarner Losh zfs_init(); 734ca987d46SWarner Losh 735ca987d46SWarner Losh /* 736ca987d46SWarner Losh * Probe the boot drive first - we will try to boot from whatever 737ca987d46SWarner Losh * pool we find on that drive. 738ca987d46SWarner Losh */ 739c1418270SIan Lepore probe_drive(zdsk); 740ca987d46SWarner Losh 741ca987d46SWarner Losh /* 742ca987d46SWarner Losh * Probe the rest of the drives that the bios knows about. This 743ca987d46SWarner Losh * will find any other available pools and it may fill in missing 744ca987d46SWarner Losh * vdevs for the boot pool. 745ca987d46SWarner Losh */ 746ca987d46SWarner Losh #ifndef VIRTUALBOX 747ca987d46SWarner Losh for (i = 0; i < *(unsigned char *)PTOV(BIOS_NUMDRIVES); i++) 748ca987d46SWarner Losh #else 749ca987d46SWarner Losh for (i = 0; i < MAXBDDEV; i++) 750ca987d46SWarner Losh #endif 751ca987d46SWarner Losh { 752ca987d46SWarner Losh if ((i | DRV_HARD) == *(uint8_t *)PTOV(ARGS)) 753ca987d46SWarner Losh continue; 754ca987d46SWarner Losh 755ca987d46SWarner Losh if (!int13probe(i | DRV_HARD)) 756ca987d46SWarner Losh break; 757ca987d46SWarner Losh 7585abe8cb6SKristof Provost zdsk = calloc(1, sizeof(struct zfsdsk)); 759c1418270SIan Lepore zdsk->dsk.drive = i | DRV_HARD; 760c1418270SIan Lepore zdsk->dsk.type = zdsk->dsk.drive & TYPE_AD; 761c1418270SIan Lepore zdsk->dsk.unit = i; 762c1418270SIan Lepore zdsk->dsk.slice = 0; 763c1418270SIan Lepore zdsk->dsk.part = 0; 764c1418270SIan Lepore zdsk->dsk.start = 0; 765c1418270SIan Lepore zdsk->dsk.size = drvsize_ext(zdsk); 766c1418270SIan Lepore probe_drive(zdsk); 767ca987d46SWarner Losh } 768ca987d46SWarner Losh 769ca987d46SWarner Losh /* 770ca987d46SWarner Losh * The first discovered pool, if any, is the pool. 771ca987d46SWarner Losh */ 772ca987d46SWarner Losh spa = spa_get_primary(); 773ca987d46SWarner Losh if (!spa) { 774ca987d46SWarner Losh printf("%s: No ZFS pools located, can't boot\n", BOOTPROG); 775ca987d46SWarner Losh for (;;) 776ca987d46SWarner Losh ; 777ca987d46SWarner Losh } 778ca987d46SWarner Losh 779ca987d46SWarner Losh primary_spa = spa; 780ca987d46SWarner Losh primary_vdev = spa_get_primary_vdev(spa); 781ca987d46SWarner Losh 782ca987d46SWarner Losh nextboot = 0; 783ca987d46SWarner Losh rc = vdev_read_pad2(primary_vdev, cmd, sizeof(cmd)); 784ca987d46SWarner Losh if (vdev_clear_pad2(primary_vdev)) 785ca987d46SWarner Losh printf("failed to clear pad2 area of primary vdev\n"); 786ca987d46SWarner Losh if (rc == 0) { 787ca987d46SWarner Losh if (*cmd) { 788ca987d46SWarner Losh /* 789ca987d46SWarner Losh * We could find an old-style ZFS Boot Block header here. 790ca987d46SWarner Losh * Simply ignore it. 791ca987d46SWarner Losh */ 792ca987d46SWarner Losh if (*(uint64_t *)cmd != 0x2f5b007b10c) { 793ca987d46SWarner Losh /* 794ca987d46SWarner Losh * Note that parse() is destructive to cmd[] and we also want 795ca987d46SWarner Losh * to honor RBX_QUIET option that could be present in cmd[]. 796ca987d46SWarner Losh */ 797ca987d46SWarner Losh nextboot = 1; 798ca987d46SWarner Losh memcpy(cmddup, cmd, sizeof(cmd)); 799ca987d46SWarner Losh if (parse_cmd()) { 800ca987d46SWarner Losh printf("failed to parse pad2 area of primary vdev\n"); 801ca987d46SWarner Losh reboot(); 802ca987d46SWarner Losh } 803ca987d46SWarner Losh if (!OPT_CHECK(RBX_QUIET)) 804ca987d46SWarner Losh printf("zfs nextboot: %s\n", cmddup); 805ca987d46SWarner Losh } 806ca987d46SWarner Losh /* Do not process this command twice */ 807ca987d46SWarner Losh *cmd = 0; 808ca987d46SWarner Losh } 809ca987d46SWarner Losh } else 810ca987d46SWarner Losh printf("failed to read pad2 area of primary vdev\n"); 811ca987d46SWarner Losh 812ca987d46SWarner Losh /* Mount ZFS only if it's not already mounted via nextboot parsing. */ 813ca987d46SWarner Losh if (zfsmount.spa == NULL && 814ca987d46SWarner Losh (zfs_spa_init(spa) != 0 || zfs_mount(spa, 0, &zfsmount) != 0)) { 815ca987d46SWarner Losh printf("%s: failed to mount default pool %s\n", 816ca987d46SWarner Losh BOOTPROG, spa->spa_name); 817ca987d46SWarner Losh autoboot = 0; 818ca987d46SWarner Losh } else if (zfs_lookup(&zfsmount, PATH_CONFIG, &dn) == 0 || 819ca987d46SWarner Losh zfs_lookup(&zfsmount, PATH_DOTCONFIG, &dn) == 0) { 820ca987d46SWarner Losh off = 0; 821ca987d46SWarner Losh zfs_read(spa, &dn, &off, cmd, sizeof(cmd)); 822ca987d46SWarner Losh } 823ca987d46SWarner Losh 824ca987d46SWarner Losh if (*cmd) { 825ca987d46SWarner Losh /* 826ca987d46SWarner Losh * Note that parse_cmd() is destructive to cmd[] and we also want 827ca987d46SWarner Losh * to honor RBX_QUIET option that could be present in cmd[]. 828ca987d46SWarner Losh */ 829ca987d46SWarner Losh memcpy(cmddup, cmd, sizeof(cmd)); 830ca987d46SWarner Losh if (parse_cmd()) 831ca987d46SWarner Losh autoboot = 0; 832ca987d46SWarner Losh if (!OPT_CHECK(RBX_QUIET)) 833ca987d46SWarner Losh printf("%s: %s\n", PATH_CONFIG, cmddup); 834ca987d46SWarner Losh /* Do not process this command twice */ 835ca987d46SWarner Losh *cmd = 0; 836ca987d46SWarner Losh } 837ca987d46SWarner Losh 838ca987d46SWarner Losh /* Do not risk waiting at the prompt forever. */ 839ca987d46SWarner Losh if (nextboot && !autoboot) 840ca987d46SWarner Losh reboot(); 841ca987d46SWarner Losh 842ca987d46SWarner Losh /* 843ca987d46SWarner Losh * Try to exec /boot/loader. If interrupted by a keypress, 844ca987d46SWarner Losh * or in case of failure, try to load a kernel directly instead. 845ca987d46SWarner Losh */ 846ca987d46SWarner Losh 847ca987d46SWarner Losh if (autoboot && !*kname) { 848060679efSWarner Losh memcpy(kname, PATH_LOADER, sizeof(PATH_LOADER)); 849ca987d46SWarner Losh if (!keyhit(3)) { 850ca987d46SWarner Losh load(); 851ca987d46SWarner Losh memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL)); 852ca987d46SWarner Losh } 853ca987d46SWarner Losh } 854ca987d46SWarner Losh 855ca987d46SWarner Losh /* Present the user with the boot2 prompt. */ 856ca987d46SWarner Losh 857ca987d46SWarner Losh for (;;) { 858ca987d46SWarner Losh if (!autoboot || !OPT_CHECK(RBX_QUIET)) { 859ca987d46SWarner Losh printf("\nFreeBSD/x86 boot\n"); 860ca987d46SWarner Losh if (zfs_rlookup(spa, zfsmount.rootobj, rootname) != 0) 861ca987d46SWarner Losh printf("Default: %s/<0x%llx>:%s\n" 862ca987d46SWarner Losh "boot: ", 863ca987d46SWarner Losh spa->spa_name, zfsmount.rootobj, kname); 864ca987d46SWarner Losh else if (rootname[0] != '\0') 865ca987d46SWarner Losh printf("Default: %s/%s:%s\n" 866ca987d46SWarner Losh "boot: ", 867ca987d46SWarner Losh spa->spa_name, rootname, kname); 868ca987d46SWarner Losh else 869ca987d46SWarner Losh printf("Default: %s:%s\n" 870ca987d46SWarner Losh "boot: ", 871ca987d46SWarner Losh spa->spa_name, kname); 872ca987d46SWarner Losh } 873ca987d46SWarner Losh if (ioctrl & IO_SERIAL) 874ca987d46SWarner Losh sio_flush(); 875ca987d46SWarner Losh if (!autoboot || keyhit(5)) 876ca987d46SWarner Losh getstr(cmd, sizeof(cmd)); 877ca987d46SWarner Losh else if (!autoboot || !OPT_CHECK(RBX_QUIET)) 878ca987d46SWarner Losh putchar('\n'); 879ca987d46SWarner Losh autoboot = 0; 880ca987d46SWarner Losh if (parse_cmd()) 881ca987d46SWarner Losh putchar('\a'); 882ca987d46SWarner Losh else 883ca987d46SWarner Losh load(); 884ca987d46SWarner Losh } 885ca987d46SWarner Losh } 886ca987d46SWarner Losh 887ca987d46SWarner Losh /* XXX - Needed for btxld to link the boot2 binary; do not remove. */ 888ca987d46SWarner Losh void 889ca987d46SWarner Losh exit(int x) 890ca987d46SWarner Losh { 891ca987d46SWarner Losh __exit(x); 892ca987d46SWarner Losh } 893ca987d46SWarner Losh 894ca987d46SWarner Losh void 895ca987d46SWarner Losh reboot(void) 896ca987d46SWarner Losh { 897ca987d46SWarner Losh __exit(0); 898ca987d46SWarner Losh } 899ca987d46SWarner Losh 900ca987d46SWarner Losh static void 901ca987d46SWarner Losh load(void) 902ca987d46SWarner Losh { 903ca987d46SWarner Losh union { 904ca987d46SWarner Losh struct exec ex; 905ca987d46SWarner Losh Elf32_Ehdr eh; 906ca987d46SWarner Losh } hdr; 907ca987d46SWarner Losh static Elf32_Phdr ep[2]; 908ca987d46SWarner Losh static Elf32_Shdr es[2]; 909ca987d46SWarner Losh caddr_t p; 910ca987d46SWarner Losh dnode_phys_t dn; 911ca987d46SWarner Losh off_t off; 912ca987d46SWarner Losh uint32_t addr, x; 913ca987d46SWarner Losh int fmt, i, j; 914ca987d46SWarner Losh 915ca987d46SWarner Losh if (zfs_lookup(&zfsmount, kname, &dn)) { 916ca987d46SWarner Losh printf("\nCan't find %s\n", kname); 917ca987d46SWarner Losh return; 918ca987d46SWarner Losh } 919ca987d46SWarner Losh off = 0; 920ca987d46SWarner Losh if (xfsread(&dn, &off, &hdr, sizeof(hdr))) 921ca987d46SWarner Losh return; 922ca987d46SWarner Losh if (N_GETMAGIC(hdr.ex) == ZMAGIC) 923ca987d46SWarner Losh fmt = 0; 924ca987d46SWarner Losh else if (IS_ELF(hdr.eh)) 925ca987d46SWarner Losh fmt = 1; 926ca987d46SWarner Losh else { 927ca987d46SWarner Losh printf("Invalid %s\n", "format"); 928ca987d46SWarner Losh return; 929ca987d46SWarner Losh } 930ca987d46SWarner Losh if (fmt == 0) { 931ca987d46SWarner Losh addr = hdr.ex.a_entry & 0xffffff; 932ca987d46SWarner Losh p = PTOV(addr); 933ca987d46SWarner Losh off = PAGE_SIZE; 934ca987d46SWarner Losh if (xfsread(&dn, &off, p, hdr.ex.a_text)) 935ca987d46SWarner Losh return; 936ca987d46SWarner Losh p += roundup2(hdr.ex.a_text, PAGE_SIZE); 937ca987d46SWarner Losh if (xfsread(&dn, &off, p, hdr.ex.a_data)) 938ca987d46SWarner Losh return; 939ca987d46SWarner Losh p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE); 940ca987d46SWarner Losh bootinfo.bi_symtab = VTOP(p); 941ca987d46SWarner Losh memcpy(p, &hdr.ex.a_syms, sizeof(hdr.ex.a_syms)); 942ca987d46SWarner Losh p += sizeof(hdr.ex.a_syms); 943ca987d46SWarner Losh if (hdr.ex.a_syms) { 944ca987d46SWarner Losh if (xfsread(&dn, &off, p, hdr.ex.a_syms)) 945ca987d46SWarner Losh return; 946ca987d46SWarner Losh p += hdr.ex.a_syms; 947ca987d46SWarner Losh if (xfsread(&dn, &off, p, sizeof(int))) 948ca987d46SWarner Losh return; 949ca987d46SWarner Losh x = *(uint32_t *)p; 950ca987d46SWarner Losh p += sizeof(int); 951ca987d46SWarner Losh x -= sizeof(int); 952ca987d46SWarner Losh if (xfsread(&dn, &off, p, x)) 953ca987d46SWarner Losh return; 954ca987d46SWarner Losh p += x; 955ca987d46SWarner Losh } 956ca987d46SWarner Losh } else { 957ca987d46SWarner Losh off = hdr.eh.e_phoff; 958ca987d46SWarner Losh for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) { 959ca987d46SWarner Losh if (xfsread(&dn, &off, ep + j, sizeof(ep[0]))) 960ca987d46SWarner Losh return; 961ca987d46SWarner Losh if (ep[j].p_type == PT_LOAD) 962ca987d46SWarner Losh j++; 963ca987d46SWarner Losh } 964ca987d46SWarner Losh for (i = 0; i < 2; i++) { 965ca987d46SWarner Losh p = PTOV(ep[i].p_paddr & 0xffffff); 966ca987d46SWarner Losh off = ep[i].p_offset; 967ca987d46SWarner Losh if (xfsread(&dn, &off, p, ep[i].p_filesz)) 968ca987d46SWarner Losh return; 969ca987d46SWarner Losh } 970ca987d46SWarner Losh p += roundup2(ep[1].p_memsz, PAGE_SIZE); 971ca987d46SWarner Losh bootinfo.bi_symtab = VTOP(p); 972ca987d46SWarner Losh if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) { 973ca987d46SWarner Losh off = hdr.eh.e_shoff + sizeof(es[0]) * 974ca987d46SWarner Losh (hdr.eh.e_shstrndx + 1); 975ca987d46SWarner Losh if (xfsread(&dn, &off, &es, sizeof(es))) 976ca987d46SWarner Losh return; 977ca987d46SWarner Losh for (i = 0; i < 2; i++) { 978ca987d46SWarner Losh memcpy(p, &es[i].sh_size, sizeof(es[i].sh_size)); 979ca987d46SWarner Losh p += sizeof(es[i].sh_size); 980ca987d46SWarner Losh off = es[i].sh_offset; 981ca987d46SWarner Losh if (xfsread(&dn, &off, p, es[i].sh_size)) 982ca987d46SWarner Losh return; 983ca987d46SWarner Losh p += es[i].sh_size; 984ca987d46SWarner Losh } 985ca987d46SWarner Losh } 986ca987d46SWarner Losh addr = hdr.eh.e_entry & 0xffffff; 987ca987d46SWarner Losh } 988ca987d46SWarner Losh bootinfo.bi_esymtab = VTOP(p); 989ca987d46SWarner Losh bootinfo.bi_kernelname = VTOP(kname); 990ca987d46SWarner Losh zfsargs.size = sizeof(zfsargs); 991ca987d46SWarner Losh zfsargs.pool = zfsmount.spa->spa_guid; 992ca987d46SWarner Losh zfsargs.root = zfsmount.rootobj; 993ca987d46SWarner Losh zfsargs.primary_pool = primary_spa->spa_guid; 994ca987d46SWarner Losh #ifdef LOADER_GELI_SUPPORT 995ca987d46SWarner Losh explicit_bzero(gelipw, sizeof(gelipw)); 996ca987d46SWarner Losh gelibuf = malloc(sizeof(struct keybuf) + (GELI_MAX_KEYS * sizeof(struct keybuf_ent))); 997c1418270SIan Lepore geli_export_key_buffer(gelibuf); 998ca987d46SWarner Losh zfsargs.notapw = '\0'; 999ca987d46SWarner Losh zfsargs.keybuf_sentinel = KEYBUF_SENTINEL; 1000ca987d46SWarner Losh zfsargs.keybuf = gelibuf; 1001ca987d46SWarner Losh #else 1002ca987d46SWarner Losh zfsargs.gelipw[0] = '\0'; 1003ca987d46SWarner Losh #endif 1004ca987d46SWarner Losh if (primary_vdev != NULL) 1005ca987d46SWarner Losh zfsargs.primary_vdev = primary_vdev->v_guid; 1006ca987d46SWarner Losh else 1007ca987d46SWarner Losh printf("failed to detect primary vdev\n"); 1008b92c2c90SIan Lepore /* 1009b92c2c90SIan Lepore * Note that the zfsargs struct is passed by value, not by pointer. Code in 1010b92c2c90SIan Lepore * btxldr.S copies the values from the entry stack to a fixed location 1011b92c2c90SIan Lepore * within loader(8) at startup due to the presence of KARGS_FLAGS_EXTARG. 1012b92c2c90SIan Lepore */ 1013ca987d46SWarner Losh __exec((caddr_t)addr, RB_BOOTINFO | (opts & RBX_MASK), 1014ca987d46SWarner Losh bootdev, 1015ca987d46SWarner Losh KARGS_FLAGS_ZFS | KARGS_FLAGS_EXTARG, 1016ca987d46SWarner Losh (uint32_t) spa->spa_guid, 1017ca987d46SWarner Losh (uint32_t) (spa->spa_guid >> 32), 1018ca987d46SWarner Losh VTOP(&bootinfo), 1019ca987d46SWarner Losh zfsargs); 1020ca987d46SWarner Losh } 1021ca987d46SWarner Losh 1022ca987d46SWarner Losh static int 1023ca987d46SWarner Losh zfs_mount_ds(char *dsname) 1024ca987d46SWarner Losh { 1025ca987d46SWarner Losh uint64_t newroot; 1026ca987d46SWarner Losh spa_t *newspa; 1027ca987d46SWarner Losh char *q; 1028ca987d46SWarner Losh 1029ca987d46SWarner Losh q = strchr(dsname, '/'); 1030ca987d46SWarner Losh if (q) 1031ca987d46SWarner Losh *q++ = '\0'; 1032ca987d46SWarner Losh newspa = spa_find_by_name(dsname); 1033ca987d46SWarner Losh if (newspa == NULL) { 1034ca987d46SWarner Losh printf("\nCan't find ZFS pool %s\n", dsname); 1035ca987d46SWarner Losh return -1; 1036ca987d46SWarner Losh } 1037ca987d46SWarner Losh 1038ca987d46SWarner Losh if (zfs_spa_init(newspa)) 1039ca987d46SWarner Losh return -1; 1040ca987d46SWarner Losh 1041ca987d46SWarner Losh newroot = 0; 1042ca987d46SWarner Losh if (q) { 1043ca987d46SWarner Losh if (zfs_lookup_dataset(newspa, q, &newroot)) { 1044ca987d46SWarner Losh printf("\nCan't find dataset %s in ZFS pool %s\n", 1045ca987d46SWarner Losh q, newspa->spa_name); 1046ca987d46SWarner Losh return -1; 1047ca987d46SWarner Losh } 1048ca987d46SWarner Losh } 1049ca987d46SWarner Losh if (zfs_mount(newspa, newroot, &zfsmount)) { 1050ca987d46SWarner Losh printf("\nCan't mount ZFS dataset\n"); 1051ca987d46SWarner Losh return -1; 1052ca987d46SWarner Losh } 1053ca987d46SWarner Losh spa = newspa; 1054ca987d46SWarner Losh return (0); 1055ca987d46SWarner Losh } 1056ca987d46SWarner Losh 1057ca987d46SWarner Losh static int 1058ca987d46SWarner Losh parse_cmd(void) 1059ca987d46SWarner Losh { 1060ca987d46SWarner Losh char *arg = cmd; 1061ca987d46SWarner Losh char *ep, *p, *q; 1062ca987d46SWarner Losh const char *cp; 1063ca987d46SWarner Losh int c, i, j; 1064ca987d46SWarner Losh 1065ca987d46SWarner Losh while ((c = *arg++)) { 1066ca987d46SWarner Losh if (c == ' ' || c == '\t' || c == '\n') 1067ca987d46SWarner Losh continue; 1068ca987d46SWarner Losh for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++); 1069ca987d46SWarner Losh ep = p; 1070ca987d46SWarner Losh if (*p) 1071ca987d46SWarner Losh *p++ = 0; 1072ca987d46SWarner Losh if (c == '-') { 1073ca987d46SWarner Losh while ((c = *arg++)) { 1074ca987d46SWarner Losh if (c == 'P') { 1075ca987d46SWarner Losh if (*(uint8_t *)PTOV(0x496) & 0x10) { 1076ca987d46SWarner Losh cp = "yes"; 1077ca987d46SWarner Losh } else { 1078ca987d46SWarner Losh opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL); 1079ca987d46SWarner Losh cp = "no"; 1080ca987d46SWarner Losh } 1081ca987d46SWarner Losh printf("Keyboard: %s\n", cp); 1082ca987d46SWarner Losh continue; 1083ca987d46SWarner Losh } else if (c == 'S') { 1084ca987d46SWarner Losh j = 0; 1085ca987d46SWarner Losh while ((unsigned int)(i = *arg++ - '0') <= 9) 1086ca987d46SWarner Losh j = j * 10 + i; 1087ca987d46SWarner Losh if (j > 0 && i == -'0') { 1088ca987d46SWarner Losh comspeed = j; 1089ca987d46SWarner Losh break; 1090ca987d46SWarner Losh } 1091ca987d46SWarner Losh /* Fall through to error below ('S' not in optstr[]). */ 1092ca987d46SWarner Losh } 1093ca987d46SWarner Losh for (i = 0; c != optstr[i]; i++) 1094ca987d46SWarner Losh if (i == NOPT - 1) 1095ca987d46SWarner Losh return -1; 1096ca987d46SWarner Losh opts ^= OPT_SET(flags[i]); 1097ca987d46SWarner Losh } 1098ca987d46SWarner Losh ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) : 1099ca987d46SWarner Losh OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD; 1100ca987d46SWarner Losh if (ioctrl & IO_SERIAL) { 1101ca987d46SWarner Losh if (sio_init(115200 / comspeed) != 0) 1102ca987d46SWarner Losh ioctrl &= ~IO_SERIAL; 1103ca987d46SWarner Losh } 1104ca987d46SWarner Losh } if (c == '?') { 1105ca987d46SWarner Losh dnode_phys_t dn; 1106ca987d46SWarner Losh 1107ca987d46SWarner Losh if (zfs_lookup(&zfsmount, arg, &dn) == 0) { 1108ca987d46SWarner Losh zap_list(spa, &dn); 1109ca987d46SWarner Losh } 1110ca987d46SWarner Losh return -1; 1111ca987d46SWarner Losh } else { 1112ca987d46SWarner Losh arg--; 1113ca987d46SWarner Losh 1114ca987d46SWarner Losh /* 1115ca987d46SWarner Losh * Report pool status if the comment is 'status'. Lets 1116ca987d46SWarner Losh * hope no-one wants to load /status as a kernel. 1117ca987d46SWarner Losh */ 1118ca987d46SWarner Losh if (!strcmp(arg, "status")) { 1119ca987d46SWarner Losh spa_all_status(); 1120ca987d46SWarner Losh return -1; 1121ca987d46SWarner Losh } 1122ca987d46SWarner Losh 1123ca987d46SWarner Losh /* 1124ca987d46SWarner Losh * If there is "zfs:" prefix simply ignore it. 1125ca987d46SWarner Losh */ 1126ca987d46SWarner Losh if (strncmp(arg, "zfs:", 4) == 0) 1127ca987d46SWarner Losh arg += 4; 1128ca987d46SWarner Losh 1129ca987d46SWarner Losh /* 1130ca987d46SWarner Losh * If there is a colon, switch pools. 1131ca987d46SWarner Losh */ 1132ca987d46SWarner Losh q = strchr(arg, ':'); 1133ca987d46SWarner Losh if (q) { 1134ca987d46SWarner Losh *q++ = '\0'; 1135ca987d46SWarner Losh if (zfs_mount_ds(arg) != 0) 1136ca987d46SWarner Losh return -1; 1137ca987d46SWarner Losh arg = q; 1138ca987d46SWarner Losh } 1139ca987d46SWarner Losh if ((i = ep - arg)) { 1140ca987d46SWarner Losh if ((size_t)i >= sizeof(kname)) 1141ca987d46SWarner Losh return -1; 1142ca987d46SWarner Losh memcpy(kname, arg, i + 1); 1143ca987d46SWarner Losh } 1144ca987d46SWarner Losh } 1145ca987d46SWarner Losh arg = p; 1146ca987d46SWarner Losh } 1147ca987d46SWarner Losh return 0; 1148ca987d46SWarner Losh } 1149