sys/arch/i386/stand/lib/biosdisk.c

   1 /*      $NetBSD: biosdisk.c,v 1.44 2015/01/18 20:18:07 jakllsch Exp $   */
   2
   3 /*
   4  * Copyright (c) 1996, 1998
   5  *      Matthias Drochner.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  */
  28
  29 /*
  30  * raw BIOS disk device for libsa.
  31  * needs lowlevel parts from bios_disk.S and biosdisk_ll.c
  32  * partly from netbsd:sys/arch/i386/boot/disk.c
  33  * no bad144 handling!
  34  *
  35  * A lot of this must match sys/kern/subr_disk_mbr.c
  36  */
  37
  38 /*
  39  * Ported to boot 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
  40  *
  41  * Mach Operating System
  42  * Copyright (c) 1992, 1991 Carnegie Mellon University
  43  * All Rights Reserved.
  44  *
  45  * Permission to use, copy, modify and distribute this software and its
  46  * documentation is hereby granted, provided that both the copyright
  47  * notice and this permission notice appear in all copies of the
  48  * software, derivative works or modified versions, and any portions
  49  * thereof, and that both notices appear in supporting documentation.
  50  *
  51  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  52  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  53  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  54  *
  55  * Carnegie Mellon requests users of this software to return to
  56  *
  57  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  58  *  School of Computer Science
  59  *  Carnegie Mellon University
  60  *  Pittsburgh PA 15213-3890
  61  *
  62  * any improvements or extensions that they make and grant Carnegie Mellon
  63  * the rights to redistribute these changes.
  64  */
  65
  66 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
  67 #define FSTYPENAMES
  68 #endif
  69
  70 #include <lib/libkern/libkern.h>
  71 #include <lib/libsa/stand.h>
  72
  73 #include <sys/types.h>
  74 #include <sys/md5.h>
  75 #include <sys/param.h>
  76 #include <sys/disklabel.h>
  77 #include <sys/disklabel_gpt.h>
  78 #include <sys/uuid.h>
  79
  80 #include <fs/cd9660/iso.h>
  81
  82 #include <lib/libsa/saerrno.h>
  83 #include <machine/cpu.h>
  84
  85 #include "libi386.h"
  86 #include "biosdisk_ll.h"
  87 #include "biosdisk.h"
  88 #ifdef _STANDALONE
  89 #include "bootinfo.h"
  90 #endif
  91
  92 #define BUFSIZE 2048    /* must be large enough for a CD sector */
  93
  94 #define BIOSDISKNPART 26
  95
  96 struct biosdisk {
  97         struct biosdisk_ll ll;
  98         daddr_t         boff;
  99         char            buf[BUFSIZE];
 100 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 101         struct {
 102                 daddr_t offset;
 103                 daddr_t size;
 104                 int     fstype;
 105         } part[BIOSDISKNPART];
 106 #endif
 107 };
 108
 109 #ifndef NO_GPT
 110 const struct uuid GET_nbsd_raid = GPT_ENT_TYPE_NETBSD_RAIDFRAME;
 111 const struct uuid GET_nbsd_ffs = GPT_ENT_TYPE_NETBSD_FFS;
 112 const struct uuid GET_nbsd_lfs = GPT_ENT_TYPE_NETBSD_LFS;
 113 const struct uuid GET_nbsd_swap = GPT_ENT_TYPE_NETBSD_SWAP;
 114 #endif /* NO_GPT */
 115
 116 #ifdef _STANDALONE
 117 static struct btinfo_bootdisk bi_disk;
 118 static struct btinfo_bootwedge bi_wedge;
 119 #endif
 120
 121 #define MBR_PARTS(buf) ((char *)(buf) + offsetof(struct mbr_sector, mbr_parts))
 122
 123 #define RF_PROTECTED_SECTORS    64      /* XXX refer to <.../rf_optnames.h> */
 124
 125 int
 126 biosdisk_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
 127                   void *buf, size_t *rsize)
 128 {
 129         struct biosdisk *d;
 130         int blks, frag;
 131
 132         if (flag != F_READ)
 133                 return EROFS;
 134
 135         d = (struct biosdisk *) devdata;
 136
 137         if (d->ll.type == BIOSDISK_TYPE_CD)
 138                 dblk = dblk * DEV_BSIZE / ISO_DEFAULT_BLOCK_SIZE;
 139
 140         dblk += d->boff;
 141
 142         blks = size / d->ll.secsize;
 143         if (blks && readsects(&d->ll, dblk, blks, buf, 0)) {
 144                 if (rsize)
 145                         *rsize = 0;
 146                 return EIO;
 147         }
 148
 149         /* needed for CD */
 150         frag = size % d->ll.secsize;
 151         if (frag) {
 152                 if (readsects(&d->ll, dblk + blks, 1, d->buf, 0)) {
 153                         if (rsize)
 154                                 *rsize = blks * d->ll.secsize;
 155                         return EIO;
 156                 }
 157                 memcpy(buf + blks * d->ll.secsize, d->buf, frag);
 158         }
 159
 160         if (rsize)
 161                 *rsize = size;
 162         return 0;
 163 }
 164
 165 static struct biosdisk *
 166 alloc_biosdisk(int biosdev)
 167 {
 168         struct biosdisk *d;
 169
 170         d = alloc(sizeof(*d));
 171         if (d == NULL)
 172                 return NULL;
 173         memset(d, 0, sizeof(*d));
 174
 175         d->ll.dev = biosdev;
 176         if (set_geometry(&d->ll, NULL)) {
 177 #ifdef DISK_DEBUG
 178                 printf("no geometry information\n");
 179 #endif
 180                 dealloc(d, sizeof(*d));
 181                 return NULL;
 182         }
 183         return d;
 184 }
 185
 186 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 187 static void
 188 md5(void *hash, const void *data, size_t len)
 189 {
 190         MD5_CTX ctx;
 191
 192         MD5Init(&ctx);
 193         MD5Update(&ctx, data, len);
 194         MD5Final(hash, &ctx);
 195
 196         return;
 197 }
 198 #endif
 199
 200 #ifndef NO_GPT
 201 static bool
 202 guid_is_nil(const struct uuid *u)
 203 {
 204         static const struct uuid nil = { .time_low = 0 };
 205         return (memcmp(u, &nil, sizeof(*u)) == 0 ? true : false);
 206 }
 207
 208 static bool
 209 guid_is_equal(const struct uuid *a, const struct uuid *b)
 210 {
 211         return (memcmp(a, b, sizeof(*a)) == 0 ? true : false);
 212 }
 213
 214 static int
 215 check_gpt(struct biosdisk *d, daddr_t sector)
 216 {
 217         struct gpt_hdr gpth;
 218         const struct gpt_ent *ep;
 219         const struct uuid *u;
 220         daddr_t entblk;
 221         size_t size;
 222         uint32_t crc;
 223         int sectors;
 224         int entries;
 225         int entry;
 226         int i, j;
 227
 228         /* read in gpt_hdr sector */
 229         if (readsects(&d->ll, sector, 1, d->buf, 1)) {
 230 #ifdef DISK_DEBUG
 231                 printf("Error reading GPT header at %"PRId64"\n", sector);
 232 #endif
 233                 return EIO;
 234         }
 235
 236         memcpy(&gpth, d->buf, sizeof(gpth));
 237
 238         if (memcmp(GPT_HDR_SIG, gpth.hdr_sig, sizeof(gpth.hdr_sig)))
 239                 return -1;
 240
 241         crc = gpth.hdr_crc_self;
 242         gpth.hdr_crc_self = 0;
 243         gpth.hdr_crc_self = crc32(0, (const void *)&gpth, GPT_HDR_SIZE);
 244         if (gpth.hdr_crc_self != crc) {
 245                 return -1;
 246         }
 247
 248         if (gpth.hdr_lba_self != sector)
 249                 return -1;
 250
 251 #ifdef _STANDALONE
 252         bi_wedge.matchblk = sector;
 253         bi_wedge.matchnblks = 1;
 254
 255         md5(bi_wedge.matchhash, d->buf, d->ll.secsize);
 256 #endif
 257
 258         sectors = sizeof(d->buf)/d->ll.secsize; /* sectors per buffer */
 259         entries = sizeof(d->buf)/gpth.hdr_entsz; /* entries per buffer */
 260         entblk = gpth.hdr_lba_table;
 261         crc = crc32(0, NULL, 0);
 262
 263         j = 0;
 264         ep = (const struct gpt_ent *)d->buf;
 265
 266         for (entry = 0; entry < gpth.hdr_entries; entry += entries) {
 267                 size = MIN(sizeof(d->buf),
 268                     (gpth.hdr_entries - entry) * gpth.hdr_entsz);
 269                 entries = size / gpth.hdr_entsz;
 270                 sectors = roundup(size, d->ll.secsize) / d->ll.secsize;
 271                 if (readsects(&d->ll, entblk, sectors, d->buf, 1))
 272                         return -1;
 273                 entblk += sectors;
 274                 crc = crc32(crc, (const void *)d->buf, size);
 275
 276                 for (i = 0; j < BIOSDISKNPART && i < entries; i++, j++) {
 277                         u = (const struct uuid *)ep[i].ent_type;
 278                         if (!guid_is_nil(u)) {
 279                                 d->part[j].offset = ep[i].ent_lba_start;
 280                                 d->part[j].size = ep[i].ent_lba_end -
 281                                     ep[i].ent_lba_start + 1;
 282                                 if (guid_is_equal(u, &GET_nbsd_ffs))
 283                                         d->part[j].fstype = FS_BSDFFS;
 284                                 else if (guid_is_equal(u, &GET_nbsd_lfs))
 285                                         d->part[j].fstype = FS_BSDLFS;
 286                                 else if (guid_is_equal(u, &GET_nbsd_raid))
 287                                         d->part[j].fstype = FS_RAID;
 288                                 else if (guid_is_equal(u, &GET_nbsd_swap))
 289                                         d->part[j].fstype = FS_SWAP;
 290                                 else
 291                                         d->part[j].fstype = FS_OTHER;
 292                         }
 293                 }
 294
 295         }
 296
 297         if (crc != gpth.hdr_crc_table) {
 298 #ifdef DISK_DEBUG
 299                 printf("GPT table CRC invalid\n");
 300 #endif
 301                 return -1;
 302         }
 303
 304         return 0;
 305 }
 306
 307 static int
 308 read_gpt(struct biosdisk *d)
 309 {
 310         struct biosdisk_extinfo ed;
 311         daddr_t gptsector[2];
 312         int i, error;
 313
 314         if (d->ll.type != BIOSDISK_TYPE_HD)
 315                 /* No GPT on floppy and CD */
 316                 return -1;
 317
 318         gptsector[0] = GPT_HDR_BLKNO;
 319         if (set_geometry(&d->ll, &ed) == 0 && d->ll.flags & BIOSDISK_INT13EXT) {
 320                 gptsector[1] = ed.totsec - 1;
 321                 /* Sanity check values returned from BIOS */
 322                 if (ed.sbytes >= 512 && (ed.sbytes & (ed.sbytes - 1)) == 0)
 323                         d->ll.secsize = ed.sbytes;
 324         } else {
 325 #ifdef DISK_DEBUG
 326                 printf("Unable to determine extended disk geometry - "
 327                         "using CHS\n");
 328 #endif
 329                 /* at least try some other reasonable values then */
 330                 gptsector[1] = d->ll.chs_sectors - 1;
 331         }
 332
 333         for (i = 0; i < __arraycount(gptsector); i++) {
 334                 error = check_gpt(d, gptsector[i]);
 335                 if (error == 0)
 336                         break;
 337         }
 338
 339         if (i >= __arraycount(gptsector)) {
 340                 memset(d->part, 0, sizeof(d->part));
 341                 return -1;
 342         }
 343
 344 #ifndef USE_SECONDARY_GPT
 345         if (i > 0) {
 346 #ifdef DISK_DEBUG
 347                 printf("ignoring valid secondary GPT\n");
 348 #endif
 349                 return -1;
 350         }
 351 #endif
 352
 353 #ifdef DISK_DEBUG
 354         printf("using %s GPT\n", (i == 0) ? "primary" : "secondary");
 355 #endif
 356         return 0;
 357 }
 358 #endif  /* !NO_GPT */
 359
 360 #ifndef NO_DISKLABEL
 361 static void
 362 ingest_label(struct biosdisk *d, struct disklabel *lp)
 363 {
 364         int part;
 365
 366         memset(d->part, 0, sizeof(d->part));
 367
 368         for (part = 0; part < lp->d_npartitions; part++) {
 369                 if (lp->d_partitions[part].p_size == 0)
 370                         continue;
 371                 if (lp->d_partitions[part].p_fstype == FS_UNUSED)
 372                         continue;
 373                 d->part[part].fstype = lp->d_partitions[part].p_fstype;
 374                 d->part[part].offset = lp->d_partitions[part].p_offset;
 375                 d->part[part].size = lp->d_partitions[part].p_size;
 376         }
 377 }
 378
 379 static int
 380 check_label(struct biosdisk *d, daddr_t sector)
 381 {
 382         struct disklabel *lp;
 383
 384         /* find partition in NetBSD disklabel */
 385         if (readsects(&d->ll, sector + LABELSECTOR, 1, d->buf, 0)) {
 386 #ifdef DISK_DEBUG
 387                 printf("Error reading disklabel\n");
 388 #endif
 389                 return EIO;
 390         }
 391         lp = (struct disklabel *) (d->buf + LABELOFFSET);
 392         if (lp->d_magic != DISKMAGIC || dkcksum(lp)) {
 393 #ifdef DISK_DEBUG
 394                 printf("warning: no disklabel in sector %"PRId64"\n", sector);
 395 #endif
 396                 return -1;
 397         }
 398
 399         ingest_label(d, lp);
 400
 401 #ifdef _STANDALONE
 402         bi_disk.labelsector = sector + LABELSECTOR;
 403         bi_disk.label.type = lp->d_type;
 404         memcpy(bi_disk.label.packname, lp->d_packname, 16);
 405         bi_disk.label.checksum = lp->d_checksum;
 406
 407         bi_wedge.matchblk = sector + LABELSECTOR;
 408         bi_wedge.matchnblks = 1;
 409
 410         md5(bi_wedge.matchhash, d->buf, d->ll.secsize);
 411 #endif
 412
 413         return 0;
 414 }
 415
 416 static int
 417 read_minix_subp(struct biosdisk *d, struct disklabel* dflt_lbl,
 418                         int this_ext, daddr_t sector)
 419 {
 420         struct mbr_partition mbr[MBR_PART_COUNT];
 421         int i;
 422         int typ;
 423         struct partition *p;
 424
 425         if (readsects(&d->ll, sector, 1, d->buf, 0)) {
 426 #ifdef DISK_DEBUG
 427                 printf("Error reading MFS sector %"PRId64"\n", sector);
 428 #endif
 429                 return EIO;
 430         }
 431         if ((uint8_t)d->buf[510] != 0x55 || (uint8_t)d->buf[511] != 0xAA) {
 432                 return -1;
 433         }
 434         memcpy(&mbr, MBR_PARTS(d->buf), sizeof(mbr));
 435         for (i = 0; i < MBR_PART_COUNT; i++) {
 436                 typ = mbr[i].mbrp_type;
 437                 if (typ == 0)
 438                         continue;
 439                 sector = this_ext + mbr[i].mbrp_start;
 440                 if (dflt_lbl->d_npartitions >= MAXPARTITIONS)
 441                         continue;
 442                 p = &dflt_lbl->d_partitions[dflt_lbl->d_npartitions++];
 443                 p->p_offset = sector;
 444                 p->p_size = mbr[i].mbrp_size;
 445                 p->p_fstype = xlat_mbr_fstype(typ);
 446         }
 447         return 0;
 448 }
 449
 450 static int
 451 read_label(struct biosdisk *d)
 452 {
 453         struct disklabel dflt_lbl;
 454         struct mbr_partition mbr[MBR_PART_COUNT];
 455         struct partition *p;
 456         uint32_t sector;
 457         int i;
 458         int error;
 459         int typ;
 460         uint32_t ext_base, this_ext, next_ext;
 461 #ifdef COMPAT_386BSD_MBRPART
 462         int sector_386bsd = -1;
 463 #endif
 464
 465         memset(&dflt_lbl, 0, sizeof(dflt_lbl));
 466         dflt_lbl.d_npartitions = 8;
 467
 468         d->boff = 0;
 469
 470         if (d->ll.type != BIOSDISK_TYPE_HD)
 471                 /* No label on floppy and CD */
 472                 return -1;
 473
 474         /*
 475          * find NetBSD Partition in DOS partition table
 476          * XXX check magic???
 477          */
 478         ext_base = 0;
 479         next_ext = 0;
 480         for (;;) {
 481                 this_ext = ext_base + next_ext;
 482                 next_ext = 0;
 483                 if (readsects(&d->ll, this_ext, 1, d->buf, 0)) {
 484 #ifdef DISK_DEBUG
 485                         printf("error reading MBR sector %u\n", this_ext);
 486 #endif
 487                         return EIO;
 488                 }
 489                 memcpy(&mbr, MBR_PARTS(d->buf), sizeof(mbr));
 490                 /* Look for NetBSD partition ID */
 491                 for (i = 0; i < MBR_PART_COUNT; i++) {
 492                         typ = mbr[i].mbrp_type;
 493                         if (typ == 0)
 494                                 continue;
 495                         sector = this_ext + mbr[i].mbrp_start;
 496 #ifdef DISK_DEBUG
 497                         printf("ptn type %d in sector %u\n", typ, sector);
 498 #endif
 499                         if (typ == MBR_PTYPE_MINIX_14B) {
 500                                 if (!read_minix_subp(d, &dflt_lbl,
 501                                                    this_ext, sector)) {
 502                                         /* Don't add "container" partition */
 503                                         continue;
 504                                 }
 505                         }
 506                         if (typ == MBR_PTYPE_NETBSD) {
 507                                 error = check_label(d, sector);
 508                                 if (error >= 0)
 509                                         return error;
 510                         }
 511                         if (MBR_IS_EXTENDED(typ)) {
 512                                 next_ext = mbr[i].mbrp_start;
 513                                 continue;
 514                         }
 515 #ifdef COMPAT_386BSD_MBRPART
 516                         if (this_ext == 0 && typ == MBR_PTYPE_386BSD)
 517                                 sector_386bsd = sector;
 518 #endif
 519                         if (this_ext != 0) {
 520                                 if (dflt_lbl.d_npartitions >= MAXPARTITIONS)
 521                                         continue;
 522                                 p = &dflt_lbl.d_partitions[dflt_lbl.d_npartitions++];
 523                         } else
 524                                 p = &dflt_lbl.d_partitions[i];
 525                         p->p_offset = sector;
 526                         p->p_size = mbr[i].mbrp_size;
 527                         p->p_fstype = xlat_mbr_fstype(typ);
 528                 }
 529                 if (next_ext == 0)
 530                         break;
 531                 if (ext_base == 0) {
 532                         ext_base = next_ext;
 533                         next_ext = 0;
 534                 }
 535         }
 536
 537         sector = 0;
 538 #ifdef COMPAT_386BSD_MBRPART
 539         if (sector_386bsd != -1) {
 540                 printf("old BSD partition ID!\n");
 541                 sector = sector_386bsd;
 542         }
 543 #endif
 544
 545         /*
 546          * One of two things:
 547          *      1. no MBR
 548          *      2. no NetBSD partition in MBR
 549          *
 550          * We simply default to "start of disk" in this case and
 551          * press on.
 552          */
 553         error = check_label(d, sector);
 554         if (error >= 0)
 555                 return error;
 556
 557         /*
 558          * Nothing at start of disk, return info from mbr partitions.
 559          */
 560         /* XXX fill it to make checksum match kernel one */
 561         dflt_lbl.d_checksum = dkcksum(&dflt_lbl);
 562         ingest_label(d, &dflt_lbl);
 563         return 0;
 564 }
 565 #endif /* NO_DISKLABEL */
 566
 567 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 568 static int
 569 read_partitions(struct biosdisk *d)
 570 {
 571         int error;
 572
 573         error = -1;
 574
 575 #ifndef NO_GPT
 576         error = read_gpt(d);
 577         if (error == 0)
 578                 return 0;
 579
 580 #endif
 581 #ifndef NO_DISKLABEL
 582         error = read_label(d);
 583
 584 #endif
 585         return error;
 586 }
 587 #endif
 588
 589 void
 590 biosdisk_probe(void)
 591 {
 592         struct biosdisk d;
 593         struct biosdisk_extinfo ed;
 594         uint64_t size;
 595         int first;
 596         int i;
 597 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 598         int part;
 599 #endif
 600
 601         for (i = 0; i < MAX_BIOSDISKS + 2; i++) {
 602                 first = 1;
 603                 memset(&d, 0, sizeof(d));
 604                 memset(&ed, 0, sizeof(ed));
 605                 if (i >= MAX_BIOSDISKS)
 606                         d.ll.dev = 0x00 + i - MAX_BIOSDISKS;    /* fd */
 607                 else
 608                         d.ll.dev = 0x80 + i;                    /* hd/cd */
 609                 if (set_geometry(&d.ll, &ed))
 610                         continue;
 611                 printf("disk ");
 612                 switch (d.ll.type) {
 613                 case BIOSDISK_TYPE_CD:
 614                         printf("cd0\n  cd0a\n");
 615                         break;
 616                 case BIOSDISK_TYPE_FD:
 617                         printf("fd%d\n", d.ll.dev & 0x7f);
 618                         printf("  fd%da\n", d.ll.dev & 0x7f);
 619                         break;
 620                 case BIOSDISK_TYPE_HD:
 621                         printf("hd%d", d.ll.dev & 0x7f);
 622                         if (d.ll.flags & BIOSDISK_INT13EXT) {
 623                                 printf(" size ");
 624                                 size = ed.totsec * ed.sbytes;
 625                                 if (size >= (10ULL * 1024 * 1024 * 1024))
 626                                         printf("%"PRIu64" GB",
 627                                             size / (1024 * 1024 * 1024));
 628                                 else
 629                                         printf("%"PRIu64" MB",
 630                                             size / (1024 * 1024));
 631                         }
 632                         printf("\n");
 633                         break;
 634                 }
 635 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 636                 if (d.ll.type != BIOSDISK_TYPE_HD)
 637                         continue;
 638
 639                 if (read_partitions(&d) != 0)
 640                         continue;
 641
 642                 for (part = 0; part < BIOSDISKNPART; part++) {
 643                         if (d.part[part].size == 0)
 644                                 continue;
 645                         if (d.part[part].fstype == FS_UNUSED)
 646                                 continue;
 647                         if (first) {
 648                                 printf(" ");
 649                                 first = 0;
 650                         }
 651                         printf(" hd%d%c(", d.ll.dev & 0x7f, part + 'a');
 652                         if (d.part[part].fstype < FSMAXTYPES)
 653                                 printf("%s",
 654                                   fstypenames[d.part[part].fstype]);
 655                         else
 656                                 printf("%d", d.part[part].fstype);
 657                         printf(")");
 658                 }
 659 #endif
 660                 if (first == 0)
 661                         printf("\n");
 662         }
 663 }
 664
 665 /* Determine likely partition for possible sector number of dos
 666  * partition.
 667  */
 668
 669 int
 670 biosdisk_findpartition(int biosdev, daddr_t sector)
 671 {
 672 #if defined(NO_DISKLABEL) && defined(NO_GPT)
 673         return 0;
 674 #else
 675         struct biosdisk *d;
 676         int partition = 0;
 677 #ifdef DISK_DEBUG
 678         printf("looking for partition device %x, sector %"PRId64"\n", biosdev, sector);
 679 #endif
 680
 681         /* Look for netbsd partition that is the dos boot one */
 682         d = alloc_biosdisk(biosdev);
 683         if (d == NULL)
 684                 return 0;
 685
 686         if (read_partitions(d) == 0) {
 687                 for (partition = (BIOSDISKNPART-1); --partition;) {
 688                         if (d->part[partition].fstype == FS_UNUSED)
 689                                 continue;
 690                         if (d->part[partition].offset == sector)
 691                                 break;
 692                 }
 693         }
 694
 695         dealloc(d, sizeof(*d));
 696         return partition;
 697 #endif /* NO_DISKLABEL && NO_GPT */
 698 }
 699
 700 #ifdef _STANDALONE
 701 static void
 702 add_biosdisk_bootinfo(void)
 703 {
 704         static bool done;
 705
 706         if (bootinfo == NULL) {
 707                 done = false;
 708                 return;
 709         }
 710
 711         if (done)
 712                 return;
 713
 714         BI_ADD(&bi_disk, BTINFO_BOOTDISK, sizeof(bi_disk));
 715         BI_ADD(&bi_wedge, BTINFO_BOOTWEDGE, sizeof(bi_wedge));
 716
 717         done = true;
 718
 719         return;
 720 }
 721
 722 #endif
 723
 724 int
 725 biosdisk_open(struct open_file *f, ...)
 726 /* struct open_file *f, int biosdev, int partition */
 727 {
 728         va_list ap;
 729         struct biosdisk *d;
 730         int biosdev;
 731         int partition;
 732         int error = 0;
 733
 734         va_start(ap, f);
 735         biosdev = va_arg(ap, int);
 736         d = alloc_biosdisk(biosdev);
 737         if (d == NULL) {
 738                 error = ENXIO;
 739                 goto out;
 740         }
 741
 742         partition = va_arg(ap, int);
 743 #ifdef _STANDALONE
 744         bi_disk.biosdev = d->ll.dev;
 745         bi_disk.partition = partition;
 746         bi_disk.labelsector = -1;
 747
 748         bi_wedge.biosdev = d->ll.dev;
 749         bi_wedge.matchblk = -1;
 750 #endif
 751
 752 #if !defined(NO_DISKLABEL) || !defined(NO_GPT)
 753         error = read_partitions(d);
 754         if (error == -1) {
 755                 error = 0;
 756                 goto nolabel;
 757         }
 758         if (error)
 759                 goto out;
 760
 761         if (partition >= BIOSDISKNPART ||
 762             d->part[partition].fstype == FS_UNUSED) {
 763 #ifdef DISK_DEBUG
 764                 printf("illegal partition\n");
 765 #endif
 766                 error = EPART;
 767                 goto out;
 768         }
 769
 770         d->boff = d->part[partition].offset;
 771
 772         if (d->part[partition].fstype == FS_RAID)
 773                 d->boff += RF_PROTECTED_SECTORS;
 774
 775 #ifdef _STANDALONE
 776         bi_wedge.startblk = d->part[partition].offset;
 777         bi_wedge.nblks = d->part[partition].size;
 778 #endif
 779
 780 nolabel:
 781 #endif
 782 #ifdef DISK_DEBUG
 783         printf("partition @%"PRId64"\n", d->boff);
 784 #endif
 785
 786 #ifdef _STANDALONE
 787         add_biosdisk_bootinfo();
 788 #endif
 789
 790         f->f_devdata = d;
 791 out:
 792         va_end(ap);
 793         if (error)
 794                 dealloc(d, sizeof(*d));
 795         return error;
 796 }
 797
 798 #ifndef LIBSA_NO_FS_CLOSE
 799 int
 800 biosdisk_close(struct open_file *f)
 801 {
 802         struct biosdisk *d = f->f_devdata;
 803
 804         /* let the floppy drive go off */
 805         if (d->ll.type == BIOSDISK_TYPE_FD)
 806                 wait_sec(3);    /* 2s is enough on all PCs I found */
 807
 808         dealloc(d, sizeof(*d));
 809         f->f_devdata = NULL;
 810         return 0;
 811 }
 812 #endif
 813
 814 int
 815 biosdisk_ioctl(struct open_file *f, u_long cmd, void *arg)
 816 {
 817         return EIO;
 818 }