/*      $NetBSD: biosdisk.c,v 1.61 2024/01/06 21:26:43 mlelstv Exp $    */

/*
 * Copyright (c) 1996, 1998
 *      Matthias Drochner.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

/*
 * raw BIOS disk device for libsa.
 * needs lowlevel parts from bios_disk.S and biosdisk_ll.c
 * partly from netbsd:sys/arch/i386/boot/disk.c
 * no bad144 handling!
 *
 * A lot of this must match sys/kern/subr_disk_mbr.c
 */

/*
 * Ported to boot 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
 *
 * Mach Operating System
 * Copyright (c) 1992, 1991 Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */

#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
#define FSTYPENAMES
#endif

#include <lib/libkern/libkern.h>
#include <lib/libsa/stand.h>

#include <sys/types.h>
#include <sys/md5.h>
#include <sys/param.h>
#include <sys/disklabel.h>
#include <sys/disklabel_gpt.h>
#include <sys/uuid.h>

#include <fs/cd9660/iso.h>
#include <fs/unicode.h>

#include <lib/libsa/saerrno.h>
#include <machine/cpu.h>

#include "libi386.h"
#include "biosdisk_ll.h"
#include "biosdisk.h"
#ifdef _STANDALONE
#include "bootinfo.h"
#endif

#ifndef NO_GPT
#define MAXDEVNAME 39 /* "NAME=" + 34 char part_name */
#else
#define MAXDEVNAME 16
#endif

#ifndef BIOSDISK_BUFSIZE
#define BIOSDISK_BUFSIZE        2048    /* must be large enough for a CD sector */
#endif

#define BIOSDISKNPART 26

struct biosdisk {
        struct biosdisk_ll ll;
        daddr_t         boff;
        daddr_t         size;
        char            buf[BIOSDISK_BUFSIZE];
#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
        struct biosdisk_partition part[BIOSDISKNPART];
#endif
};

#include <dev/raidframe/raidframevar.h>
#define RF_COMPONENT_INFO_OFFSET   16384   /* from sys/dev/raidframe/rf_netbsdkintf.c */
#define RF_COMPONENT_LABEL_VERSION     2   /* from <dev/raidframe/rf_raid.h> */

#define RAIDFRAME_NDEV 16 /* abitrary limit to 15 raidframe devices */
struct raidframe {
        int     last_unit;
        int     serial;
        int     biosdev;
        int     parent_part;
#ifndef NO_GPT
        char    parent_name[MAXDEVNAME + 1];
#endif
        daddr_t offset;
        daddr_t size;
};


#ifndef NO_GPT
const struct uuid GET_nbsd_raid = GPT_ENT_TYPE_NETBSD_RAIDFRAME;
const struct uuid GET_nbsd_ffs = GPT_ENT_TYPE_NETBSD_FFS;
const struct uuid GET_nbsd_lfs = GPT_ENT_TYPE_NETBSD_LFS;
const struct uuid GET_nbsd_swap = GPT_ENT_TYPE_NETBSD_SWAP;
const struct uuid GET_nbsd_ccd = GPT_ENT_TYPE_NETBSD_CCD;
const struct uuid GET_nbsd_cgd = GPT_ENT_TYPE_NETBSD_CGD;

const struct uuid GET_efi = GPT_ENT_TYPE_EFI;
const struct uuid GET_mbr = GPT_ENT_TYPE_MBR;
const struct uuid GET_fbsd = GPT_ENT_TYPE_FREEBSD;
const struct uuid GET_fbsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
const struct uuid GET_fbsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
const struct uuid GET_fbsd_vinum = GPT_ENT_TYPE_FREEBSD_VINUM;
const struct uuid GET_fbsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
const struct uuid GET_ms_rsvd = GPT_ENT_TYPE_MS_RESERVED;
const struct uuid GET_ms_basic_data = GPT_ENT_TYPE_MS_BASIC_DATA;
const struct uuid GET_ms_ldm_metadata = GPT_ENT_TYPE_MS_LDM_METADATA;
const struct uuid GET_ms_ldm_data = GPT_ENT_TYPE_MS_LDM_DATA;
const struct uuid GET_linux_data = GPT_ENT_TYPE_LINUX_DATA;
const struct uuid GET_linux_raid = GPT_ENT_TYPE_LINUX_RAID;
const struct uuid GET_linux_swap = GPT_ENT_TYPE_LINUX_SWAP;
const struct uuid GET_linux_lvm = GPT_ENT_TYPE_LINUX_LVM;
const struct uuid GET_apple_hfs = GPT_ENT_TYPE_APPLE_HFS;
const struct uuid GET_apple_ufs = GPT_ENT_TYPE_APPLE_UFS;
const struct uuid GET_bios = GPT_ENT_TYPE_BIOS;

const struct gpt_part gpt_parts[] = {
        { &GET_nbsd_raid,       "NetBSD RAID" },
        { &GET_nbsd_ffs,        "NetBSD FFS" },
        { &GET_nbsd_lfs,        "NetBSD LFS" },
        { &GET_nbsd_swap,       "NetBSD Swap" },
        { &GET_nbsd_ccd,        "NetBSD ccd" },
        { &GET_nbsd_cgd,        "NetBSD cgd" },
        { &GET_efi,             "EFI System" },
        { &GET_mbr,             "MBR" },
        { &GET_fbsd,            "FreeBSD" },
        { &GET_fbsd_swap,       "FreeBSD Swap" },
        { &GET_fbsd_ufs,        "FreeBSD UFS" },
        { &GET_fbsd_vinum,      "FreeBSD Vinum" },
        { &GET_fbsd_zfs,        "FreeBSD ZFS" },
        { &GET_ms_rsvd,         "Microsoft Reserved" },
        { &GET_ms_basic_data,   "Microsoft Basic data" },
        { &GET_ms_ldm_metadata, "Microsoft LDM metadata" },
        { &GET_ms_ldm_data,     "Microsoft LDM data" },
        { &GET_linux_data,      "Linux data" },
        { &GET_linux_raid,      "Linux RAID" },
        { &GET_linux_swap,      "Linux Swap" },
        { &GET_linux_lvm,       "Linux LVM" },
        { &GET_apple_hfs,       "Apple HFS" },
        { &GET_apple_ufs,       "Apple UFS" },
        { &GET_bios,            "BIOS Boot (GRUB)" },
};
#endif /* NO_GPT */

struct btinfo_bootdisk bi_disk;
struct btinfo_bootwedge bi_wedge;
struct btinfo_rootdevice bi_root;

#define MBR_PARTS(buf) ((char *)(buf) + offsetof(struct mbr_sector, mbr_parts))

#ifndef devb2cdb
#define devb2cdb(bno)   (((bno) * DEV_BSIZE) / ISO_DEFAULT_BLOCK_SIZE)
#endif

static void
dealloc_biosdisk(struct biosdisk *d)
{
#ifndef NO_GPT
        int i;

        for (i = 0; i < __arraycount(d->part); i++) {
                if (d->part[i].part_name != NULL)
                        dealloc(d->part[i].part_name, BIOSDISK_PART_NAME_LEN);
        }
#endif

        dealloc(d, sizeof(*d));

        return;
}

static struct biosdisk_partition *
copy_biosdisk_part(struct biosdisk *d)
{
        struct biosdisk_partition *part;

        part = alloc(sizeof(d->part));
        if (part == NULL)
                goto out;

        memcpy(part, d->part, sizeof(d->part));

#ifndef NO_GPT
        int i;

        for (i = 0; i < __arraycount(d->part); i++) {
                if (d->part[i].part_name != NULL) {
                        part[i].part_name = alloc(BIOSDISK_PART_NAME_LEN);
                        memcpy(part[i].part_name, d->part[i].part_name,
                               BIOSDISK_PART_NAME_LEN);
                }
        }
#endif

out:
        return part;
}

int
biosdisk_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
                  void *buf, size_t *rsize)
{
        struct biosdisk *d;
        int blks, frag;

        if (flag != F_READ)
                return EROFS;

        d = (struct biosdisk *) devdata;

        if (d->ll.type == BIOSDISK_TYPE_CD)
                dblk = devb2cdb(dblk);

        dblk += d->boff;

        blks = size / d->ll.secsize;
        if (blks && readsects(&d->ll, dblk, blks, buf, 0)) {
                if (rsize)
                        *rsize = 0;
                return EIO;
        }

        /* needed for CD */
        frag = size % d->ll.secsize;
        if (frag) {
                if (readsects(&d->ll, dblk + blks, 1, d->buf, 0)) {
                        if (rsize)
                                *rsize = blks * d->ll.secsize;
                        return EIO;
                }
                memcpy(buf + blks * d->ll.secsize, d->buf, frag);
        }

        if (rsize)
                *rsize = size;
        return 0;
}

static struct biosdisk *
alloc_biosdisk(int biosdev)
{
        struct biosdisk *d;

        d = alloc(sizeof(*d));
        if (d == NULL)
                return NULL;
        memset(d, 0, sizeof(*d));

        d->ll.dev = biosdev;
        if (set_geometry(&d->ll, NULL)) {
#ifdef DISK_DEBUG
                printf("no geometry information\n");
#endif
                dealloc_biosdisk(d);
                return NULL;
        }
        return d;
}

#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
static void
md5(void *hash, const void *data, size_t len)
{
        MD5_CTX ctx;

        MD5Init(&ctx);
        MD5Update(&ctx, data, len);
        MD5Final(hash, &ctx);

        return;
}
#endif

#ifndef NO_GPT
bool
guid_is_nil(const struct uuid *u)
{
        static const struct uuid nil = { .time_low = 0 };
        return (memcmp(u, &nil, sizeof(*u)) == 0 ? true : false);
}

bool
guid_is_equal(const struct uuid *a, const struct uuid *b)
{
        return (memcmp(a, b, sizeof(*a)) == 0 ? true : false);
}

static void
part_name_utf8(const uint16_t *utf16_src, size_t utf16_srclen,
               char *utf8_dst, size_t utf8_dstlen)
{
        char *c = utf8_dst;
        size_t r = utf8_dstlen - 1;
        size_t n;
        int j;

        if (utf8_dst == NULL)
                return;

        for (j = 0; j < utf16_srclen && utf16_src[j] != 0x0000; j++) {
                n = wput_utf8(c, r, le16toh(utf16_src[j]));
                if (n == 0)
                        break;
                c += n; r -= n;
        }
        *c = '\0';

        return;
}

static int
check_gpt(struct biosdisk *d, daddr_t rf_offset, daddr_t sector)
{
        struct gpt_hdr gpth;
        const struct gpt_ent *ep;
        const struct uuid *u;
        daddr_t entblk;
        size_t size;
        uint32_t crc;
        int sectors;
        int entries;
        int entry;
        int i, j;

        /* read in gpt_hdr sector */
        if (readsects(&d->ll, sector, 1, d->buf, 1)) {
#ifdef DISK_DEBUG
                printf("Error reading GPT header at %"PRId64"\n", sector);
#endif
                return EIO;
        }

        memcpy(&gpth, d->buf, sizeof(gpth));

        if (memcmp(GPT_HDR_SIG, gpth.hdr_sig, sizeof(gpth.hdr_sig)))
                return -1;

        crc = gpth.hdr_crc_self;
        gpth.hdr_crc_self = 0;
        gpth.hdr_crc_self = crc32(0, (const void *)&gpth, GPT_HDR_SIZE);
        if (gpth.hdr_crc_self != crc) {
                return -1;
        }

        if (gpth.hdr_lba_self + rf_offset != sector)
                return -1;

#ifdef _STANDALONE
        bi_wedge.matchblk = sector;
        bi_wedge.matchnblks = 1;

        md5(bi_wedge.matchhash, d->buf, d->ll.secsize);
#endif

        sectors = sizeof(d->buf)/d->ll.secsize; /* sectors per buffer */
        entries = sizeof(d->buf)/gpth.hdr_entsz; /* entries per buffer */
        entblk = gpth.hdr_lba_table + rf_offset;
        crc = crc32(0, NULL, 0);

        j = 0;
        ep = (const struct gpt_ent *)d->buf;

        for (entry = 0; entry < gpth.hdr_entries; entry += entries) {
                size = MIN(sizeof(d->buf),
                    (gpth.hdr_entries - entry) * gpth.hdr_entsz);
                entries = size / gpth.hdr_entsz;
                sectors = roundup(size, d->ll.secsize) / d->ll.secsize;
                if (readsects(&d->ll, entblk, sectors, d->buf, 1))
                        return -1;
                entblk += sectors;
                crc = crc32(crc, (const void *)d->buf, size);

                for (i = 0; j < BIOSDISKNPART && i < entries; i++) {
                        u = (const struct uuid *)ep[i].ent_type;
                        if (!guid_is_nil(u)) {
                                d->part[j].offset = ep[i].ent_lba_start;
                                d->part[j].size = ep[i].ent_lba_end -
                                    ep[i].ent_lba_start + 1;
                                if (guid_is_equal(u, &GET_nbsd_ffs))
                                        d->part[j].fstype = FS_BSDFFS;
                                else if (guid_is_equal(u, &GET_nbsd_lfs))
                                        d->part[j].fstype = FS_BSDLFS;
                                else if (guid_is_equal(u, &GET_nbsd_raid))
                                        d->part[j].fstype = FS_RAID;
                                else if (guid_is_equal(u, &GET_nbsd_swap))
                                        d->part[j].fstype = FS_SWAP;
                                else if (guid_is_equal(u, &GET_nbsd_ccd))
                                        d->part[j].fstype = FS_CCD;
                                else if (guid_is_equal(u, &GET_nbsd_cgd))
                                        d->part[j].fstype = FS_CGD;
                                else
                                        d->part[j].fstype = FS_OTHER;
#ifndef NO_GPT
                                for (int k = 0;
                                     k < __arraycount(gpt_parts);
                                     k++) {
                                        if (guid_is_equal(u, gpt_parts[k].guid))
                                                d->part[j].guid = &gpt_parts[k];
                                }
                                d->part[j].attr = ep[i].ent_attr;

                                d->part[j].part_name =
                                    alloc(BIOSDISK_PART_NAME_LEN);
                                part_name_utf8(ep[i].ent_name,
                                               sizeof(ep[i].ent_name),
                                               d->part[j].part_name,
                                               BIOSDISK_PART_NAME_LEN);
#endif
                                j++;
                        }
                }

        }

        if (crc != gpth.hdr_crc_table) {
#ifdef DISK_DEBUG       
                printf("GPT table CRC invalid\n");
#endif
                return -1;
        }

        return 0;
}

static int
read_gpt(struct biosdisk *d, daddr_t rf_offset, daddr_t rf_size)
{
        struct biosdisk_extinfo ed;
        daddr_t gptsector[2];
        int i, error;

        if (d->ll.type != BIOSDISK_TYPE_HD)
                /* No GPT on floppy and CD */
                return -1;

        if (rf_offset && rf_size) {
                gptsector[0] = rf_offset + GPT_HDR_BLKNO;
                gptsector[1] = rf_offset + rf_size - 1;
        } else {
                gptsector[0] = GPT_HDR_BLKNO;
                if (set_geometry(&d->ll, &ed) == 0 &&
                    d->ll.flags & BIOSDISK_INT13EXT) {
                        gptsector[1] = ed.totsec - 1;
                        /* Sanity check values returned from BIOS */
                        if (ed.sbytes >= 512 &&
                            (ed.sbytes & (ed.sbytes - 1)) == 0)
                                d->ll.secsize = ed.sbytes;
                } else {
#ifdef DISK_DEBUG
                        printf("Unable to determine extended disk geometry - "
                                "using CHS\n");
#endif
                        /* at least try some other reasonable values then */
                        gptsector[1] = d->ll.chs_sectors - 1;
                }
        }

        for (i = 0; i < __arraycount(gptsector); i++) {
                error = check_gpt(d, rf_offset, gptsector[i]);
                if (error == 0)
                        break;
        }

        if (i >= __arraycount(gptsector)) {
                memset(d->part, 0, sizeof(d->part));
                return -1;
        }

#ifndef USE_SECONDARY_GPT
        if (i > 0) {
#ifdef DISK_DEBUG
                printf("ignoring valid secondary GPT\n");
#endif
                return -1;
        }
#endif

#ifdef DISK_DEBUG
        printf("using %s GPT\n", (i == 0) ? "primary" : "secondary");
#endif
        return 0;
}
#endif  /* !NO_GPT */

#ifndef NO_DISKLABEL
static void
ingest_label(struct biosdisk *d, struct disklabel *lp)
{
        int part;

        memset(d->part, 0, sizeof(d->part));

        for (part = 0; part < lp->d_npartitions; part++) {
                if (lp->d_partitions[part].p_size == 0)
                        continue;
                if (lp->d_partitions[part].p_fstype == FS_UNUSED)
                        continue;
                d->part[part].fstype = lp->d_partitions[part].p_fstype;
                d->part[part].offset = lp->d_partitions[part].p_offset;
                d->part[part].size = lp->d_partitions[part].p_size;
        }
}

static int
check_label(struct biosdisk *d, daddr_t sector)
{
        struct disklabel *lp;

        /* find partition in NetBSD disklabel */
        if (readsects(&d->ll, sector + LABELSECTOR, 1, d->buf, 0)) {
#ifdef DISK_DEBUG
                printf("Error reading disklabel\n");
#endif
                return EIO;
        }
        lp = (struct disklabel *) (d->buf + LABELOFFSET);
        if (lp->d_magic != DISKMAGIC || dkcksum(lp)) {
#ifdef DISK_DEBUG
                printf("warning: no disklabel in sector %"PRId64"\n", sector);
#endif
                return -1;
        }

        ingest_label(d, lp);

        bi_disk.labelsector = sector + LABELSECTOR;
        bi_disk.label.type = lp->d_type;
        memcpy(bi_disk.label.packname, lp->d_packname, 16);
        bi_disk.label.checksum = lp->d_checksum;

        bi_wedge.matchblk = sector + LABELSECTOR;
        bi_wedge.matchnblks = 1;

        md5(bi_wedge.matchhash, d->buf, d->ll.secsize);

        return 0;
}

static int
read_minix_subp(struct biosdisk *d, struct disklabel* dflt_lbl,
                        int this_ext, daddr_t sector)
{
        struct mbr_partition mbr[MBR_PART_COUNT];
        int i;
        int typ;
        struct partition *p;

        if (readsects(&d->ll, sector, 1, d->buf, 0)) {
#ifdef DISK_DEBUG
                printf("Error reading MFS sector %"PRId64"\n", sector);
#endif
                return EIO;
        }
        if ((uint8_t)d->buf[510] != 0x55 || (uint8_t)d->buf[511] != 0xAA) {
                return -1;
        }
        memcpy(&mbr, MBR_PARTS(d->buf), sizeof(mbr));
        for (i = 0; i < MBR_PART_COUNT; i++) {
                typ = mbr[i].mbrp_type;
                if (typ == 0)
                        continue;
                sector = this_ext + mbr[i].mbrp_start;
                if (dflt_lbl->d_npartitions >= MAXPARTITIONS)
                        continue;
                p = &dflt_lbl->d_partitions[dflt_lbl->d_npartitions++];
                p->p_offset = sector;
                p->p_size = mbr[i].mbrp_size;
                p->p_fstype = xlat_mbr_fstype(typ);
        }
        return 0;
}

#if defined(EFIBOOT) && defined(SUPPORT_CD9660)
static int
check_cd9660(struct biosdisk *d)
{
        struct biosdisk_extinfo ed;
        struct iso_primary_descriptor *vd;
        daddr_t bno;

        for (bno = 16;; bno++) {
                if (readsects(&d->ll, bno, 1, d->buf, 0))
                        return -1;
                vd = (struct iso_primary_descriptor *)d->buf;
                if (memcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
                        return -1;
                if (isonum_711(vd->type) == ISO_VD_END)
                        return -1;
                if (isonum_711(vd->type) == ISO_VD_PRIMARY)
                        break;
        }
        if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE)
                return -1;

        if (set_geometry(&d->ll, &ed))
                return -1;

        memset(d->part, 0, sizeof(d->part));
        d->part[0].fstype = FS_ISO9660;
        d->part[0].offset = 0;
        d->part[0].size = ed.totsec;
        return 0;
}
#endif

static int
read_label(struct biosdisk *d, daddr_t offset)
{
        struct disklabel dflt_lbl;
        struct mbr_partition mbr[MBR_PART_COUNT];
        struct partition *p;
        uint32_t sector;
        int i;
        int error;
        int typ;
        uint32_t ext_base, this_ext, next_ext;
#ifdef COMPAT_386BSD_MBRPART
        int sector_386bsd = -1;
#endif

        memset(&dflt_lbl, 0, sizeof(dflt_lbl));
        dflt_lbl.d_npartitions = 8;

        d->boff = 0;
        d->size = 0;

        if (d->ll.type != BIOSDISK_TYPE_HD)
                /* No label on floppy and CD */
                return -1;

        /*
         * find NetBSD Partition in DOS partition table
         * XXX check magic???
         */
        ext_base = offset;
        next_ext = offset;
        for (;;) {
                this_ext = ext_base + next_ext;
                next_ext = offset;
                if (readsects(&d->ll, this_ext, 1, d->buf, 0)) {
#ifdef DISK_DEBUG
                        printf("error reading MBR sector %u\n", this_ext);
#endif
                        return EIO;
                }
                memcpy(&mbr, MBR_PARTS(d->buf), sizeof(mbr));
                /* Look for NetBSD partition ID */
                for (i = 0; i < MBR_PART_COUNT; i++) {
                        typ = mbr[i].mbrp_type;
                        if (typ == 0)
                                continue;
                        sector = this_ext + mbr[i].mbrp_start;
#ifdef DISK_DEBUG
                        printf("ptn type %d in sector %u\n", typ, sector);
#endif
                        if (typ == MBR_PTYPE_MINIX_14B) {
                                if (!read_minix_subp(d, &dflt_lbl,
                                                   this_ext, sector)) {
                                        /* Don't add "container" partition */
                                        continue;
                                }
                        }
                        if (typ == MBR_PTYPE_NETBSD) {
                                error = check_label(d, sector);
                                if (error >= 0)
                                        return error;
                        }
                        if (MBR_IS_EXTENDED(typ)) {
                                next_ext = mbr[i].mbrp_start + offset;
                                continue;
                        }
#ifdef COMPAT_386BSD_MBRPART
                        if (this_ext == offset && typ == MBR_PTYPE_386BSD)
                                sector_386bsd = sector;
#endif
                        if (this_ext != offset) {
                                if (dflt_lbl.d_npartitions >= MAXPARTITIONS)
                                        continue;
                                p = &dflt_lbl.d_partitions[dflt_lbl.d_npartitions++];
                        } else
                                p = &dflt_lbl.d_partitions[i];
                        p->p_offset = sector;
                        p->p_size = mbr[i].mbrp_size;
                        p->p_fstype = xlat_mbr_fstype(typ);
                }
                if (next_ext == offset)
                        break;
                if (ext_base == offset) {
                        ext_base = next_ext;
                        next_ext = offset;
                }
        }

        sector = offset;
#ifdef COMPAT_386BSD_MBRPART
        if (sector_386bsd != -1) {
                printf("old BSD partition ID!\n");
                sector = sector_386bsd;
        }
#endif

        /*
         * One of two things:
         *      1. no MBR
         *      2. no NetBSD partition in MBR
         *
         * We simply default to "start of disk" in this case and
         * press on.
         */
        error = check_label(d, sector);
        if (error >= 0)
                return error;

#if defined(EFIBOOT) && defined(SUPPORT_CD9660)
        /* Check CD/DVD */
        error = check_cd9660(d);
        if (error >= 0)
                return error;
#endif

        /*
         * Nothing at start of disk, return info from mbr partitions.
         */
        /* XXX fill it to make checksum match kernel one */
        dflt_lbl.d_checksum = dkcksum(&dflt_lbl);
        ingest_label(d, &dflt_lbl);
        return 0;
}
#endif /* NO_DISKLABEL */

#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
static int
read_partitions(struct biosdisk *d, daddr_t offset, daddr_t size)
{
        int error;

        error = -1;

#ifndef NO_GPT
        error = read_gpt(d, offset, size);
        if (error == 0)
                return 0;

#endif
#ifndef NO_DISKLABEL
        error = read_label(d, offset);
#endif
        return error;
}
#endif

#ifndef NO_RAIDFRAME
static void
raidframe_probe(struct raidframe *raidframe, int *raidframe_count,
                struct biosdisk *d, int part)
{
        int i = *raidframe_count;
        struct RF_ComponentLabel_s label;
        daddr_t offset;

        if (i + 1 > RAIDFRAME_NDEV)
                return;

        offset = d->part[part].offset;
        if ((biosdisk_read_raidframe(d->ll.dev, offset, &label)) != 0)
                return;

        if (label.version != RF_COMPONENT_LABEL_VERSION)
                printf("Unexpected raidframe label version\n");

        raidframe[i].last_unit = label.last_unit;
        raidframe[i].serial = label.serial_number;
        raidframe[i].biosdev = d->ll.dev;
        raidframe[i].parent_part = part;
#ifndef NO_GPT
        if (d->part[part].part_name)
                strlcpy(raidframe[i].parent_name,
                        d->part[part].part_name, MAXDEVNAME);
        else
                raidframe[i].parent_name[0] = '\0';
#endif
        raidframe[i].offset = offset;
        raidframe[i].size = label.__numBlocks;

        (*raidframe_count)++;

        return;
}
#endif

void
biosdisk_probe(void)
{
        struct biosdisk *d;
        struct biosdisk_extinfo ed;
#ifndef NO_RAIDFRAME
        struct raidframe raidframe[RAIDFRAME_NDEV];
        int raidframe_count = 0;
#endif
        uint64_t size;
        int first;
        int i;
#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
        int part;
#endif

        for (i = 0; i < MAX_BIOSDISKS + 2; i++) {
                first = 1;
                d = alloc(sizeof(*d));
                if (d == NULL) {
                        printf("Out of memory\n");
                        return;
                }
                memset(d, 0, sizeof(*d));
                memset(&ed, 0, sizeof(ed));
                if (i >= MAX_BIOSDISKS)
                        d->ll.dev = 0x00 + i - MAX_BIOSDISKS;   /* fd */
                else
                        d->ll.dev = 0x80 + i;                   /* hd/cd */
                if (set_geometry(&d->ll, &ed))
                        goto next_disk;
                printf("disk ");
                switch (d->ll.type) {
                case BIOSDISK_TYPE_CD:
                        printf("cd0\n  cd0a\n");
                        break;
                case BIOSDISK_TYPE_FD:
                        printf("fd%d\n", d->ll.dev & 0x7f);
                        printf("  fd%da\n", d->ll.dev & 0x7f);
                        break;
                case BIOSDISK_TYPE_HD:
                        printf("hd%d", d->ll.dev & 0x7f);
                        if (d->ll.flags & BIOSDISK_INT13EXT) {
                                printf(" size ");
                                size = ed.totsec * ed.sbytes;
                                if (size >= (10ULL * 1024 * 1024 * 1024))
                                        printf("%"PRIu64" GB",
                                            size / (1024 * 1024 * 1024));
                                else
                                        printf("%"PRIu64" MB",
                                            size / (1024 * 1024));
                        }
                        printf("\n");
                        break;
                }
#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
                if (d->ll.type != BIOSDISK_TYPE_HD)
                        goto next_disk;

                if (read_partitions(d, 0, 0) != 0)
                        goto next_disk;

                for (part = 0; part < BIOSDISKNPART; part++) {
                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype == FS_UNUSED)
                                continue;
#ifndef NO_RAIDFRAME
                        if (d->part[part].fstype == FS_RAID)
                                raidframe_probe(raidframe,
                                                &raidframe_count, d, part);
#endif
                        if (first) {
                                printf(" ");
                                first = 0;
                        }
#ifndef NO_GPT
                        if (d->part[part].part_name &&
                            d->part[part].part_name[0])
                                printf(" NAME=%s(", d->part[part].part_name);
                        else
#endif
                                printf(" hd%d%c(", d->ll.dev & 0x7f, part + 'a');

#ifndef NO_GPT
                        if (d->part[part].guid != NULL)
                                printf("%s", d->part[part].guid->name);
                        else
#endif

                        if (d->part[part].fstype < FSMAXTYPES)
                                printf("%s",
                                  fstypenames[d->part[part].fstype]);
                        else
                                printf("%d", d->part[part].fstype);
                        printf(")");
                }
#endif
                if (first == 0)
                        printf("\n");

next_disk:
                dealloc_biosdisk(d);
        }

#ifndef NO_RAIDFRAME
        for (i = 0; i < raidframe_count; i++) {
                size_t secsize;

                if ((d = alloc_biosdisk(raidframe[i].biosdev)) == NULL) {
                        printf("Out of memory\n");
                        return;
                }

                secsize = d->ll.secsize;

                printf("raidframe raid%d serial %d in ",
                       raidframe[i].last_unit, raidframe[i].serial);
#ifndef NO_GPT
                if (raidframe[i].parent_name[0])
                        printf("NAME=%s size ", raidframe[i].parent_name);
                else
#endif
                printf("hd%d%c size ", d->ll.dev & 0x7f,
                       raidframe[i].parent_part + 'a');
                if (raidframe[i].size >= (10ULL * 1024 * 1024 * 1024 / secsize))
                        printf("%"PRIu64" GB",
                            raidframe[i].size / (1024 * 1024 * 1024 / secsize));
                else
                        printf("%"PRIu64" MB",
                            raidframe[i].size / (1024 * 1024 / secsize));
                printf("\n");

                if (read_partitions(d,
                    raidframe[i].offset + RF_PROTECTED_SECTORS,
                    raidframe[i].size) != 0)
                        goto next_raidrame;

                first = 1;
                for (part = 0; part < BIOSDISKNPART; part++) {
#ifndef NO_GPT
                        bool bootme = d->part[part].attr & GPT_ENT_ATTR_BOOTME;
#else
                        bool bootme = 0;
#endif

                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype == FS_UNUSED)
                                continue;
                        if (d->part[part].fstype == FS_RAID)
                                continue;
                        if (first) {
                                printf(" ");
                                first = 0;
                        }
#ifndef NO_GPT
                        if (d->part[part].part_name &&
                            d->part[part].part_name[0])
                                printf(" NAME=%s(", d->part[part].part_name);
                        else
#endif
                                printf(" raid%d%c(", raidframe[i].last_unit,
                                       part + 'a');
#ifndef NO_GPT
                        if (d->part[part].guid != NULL)
                                printf("%s", d->part[part].guid->name);
                        else
#endif
                        if (d->part[part].fstype < FSMAXTYPES)
                                printf("%s",
                                  fstypenames[d->part[part].fstype]);
                        else
                                printf("%d", d->part[part].fstype);
                        printf("%s)", bootme ? ", bootme" : "");
                }

next_raidrame:
                if (first == 0)
                        printf("\n");

                dealloc_biosdisk(d);
        }
#endif
}

/* Determine likely partition for possible sector number of dos
 * partition.
 */

int
biosdisk_findpartition(int biosdev, daddr_t sector,
                       int *partition, const char **part_name)
{
#if defined(NO_DISKLABEL) && defined(NO_GPT)
        *partition = 0;
        if (part_name)
                *part_name = NULL;
        return 0;
#else
        int i;
        struct biosdisk *d;
        int biosboot_sector_part = -1;
        int bootable_fs_part = -1;
        int boot_part = 0;
#ifndef NO_GPT
        int gpt_bootme_part = -1;
        static char namebuf[MAXDEVNAME + 1];
#endif

#ifdef DISK_DEBUG
        printf("looking for partition device %x, sector %"PRId64"\n", biosdev, sector);
#endif

        /* default to first partition */
        *partition = 0;
        if (part_name)
                *part_name = NULL;

        /* Look for netbsd partition that is the dos boot one */
        d = alloc_biosdisk(biosdev);
        if (d == NULL)
                return -1;

        if (read_partitions(d, 0, 0) == 0) {
                for (i = 0; i < BIOSDISKNPART; i++) {
                        if (d->part[i].fstype == FS_UNUSED)
                                continue;

                        if (d->part[i].offset == sector &&
                            biosboot_sector_part == -1)
                                biosboot_sector_part = i;

#ifndef NO_GPT
                        if (d->part[i].attr & GPT_ENT_ATTR_BOOTME &&
                            gpt_bootme_part == -1)
                                gpt_bootme_part = i;
#endif
                        switch (d->part[i].fstype) {
                        case FS_BSDFFS:
                        case FS_BSDLFS:
                        case FS_RAID:
                        case FS_CCD:
                        case FS_CGD:
                        case FS_ISO9660:
                                if (bootable_fs_part == -1)
                                        bootable_fs_part = i;
                                break;

                        default:
                                break;
                        }
                }

#ifndef NO_GPT
                if (gpt_bootme_part != -1)
                        boot_part = gpt_bootme_part;
                else
#endif
                if (biosboot_sector_part != -1)
                        boot_part = biosboot_sector_part;
                else if (bootable_fs_part != -1)
                        boot_part = bootable_fs_part;
                else
                        boot_part = 0;

                *partition = boot_part;
#ifndef NO_GPT
                if (part_name &&
                    d->part[boot_part].part_name &&
                    d->part[boot_part].part_name[0]) {
                        strlcpy(namebuf, d->part[boot_part].part_name,
                                BIOSDISK_PART_NAME_LEN);
                        *part_name = namebuf;
                }
#endif
        }

        dealloc_biosdisk(d);
        return 0;
#endif /* NO_DISKLABEL && NO_GPT */
}

int
biosdisk_readpartition(int biosdev, daddr_t offset, daddr_t size,
    struct biosdisk_partition **partpp, int *rnum)
{
#if defined(NO_DISKLABEL) && defined(NO_GPT)
        return ENOTSUP;
#else
        struct biosdisk *d;
        struct biosdisk_partition *part;
        int rv;

        /* Look for netbsd partition that is the dos boot one */
        d = alloc_biosdisk(biosdev);
        if (d == NULL)
                return ENOMEM;

        if (read_partitions(d, offset, size)) {
                rv = EINVAL;
                goto out;
        }

        part = copy_biosdisk_part(d);
        if (part == NULL) {
                rv = ENOMEM;
                goto out;
        }

        *partpp = part;
        *rnum = (int)__arraycount(d->part);
        rv = 0;
out:
        dealloc_biosdisk(d);
        return rv;
#endif /* NO_DISKLABEL && NO_GPT */
}

#ifndef NO_RAIDFRAME
int
biosdisk_read_raidframe(int biosdev, daddr_t offset,
                        struct RF_ComponentLabel_s *label)
{
#if defined(NO_DISKLABEL) && defined(NO_GPT)
        return ENOTSUP;
#else
        struct biosdisk *d;
        struct biosdisk_extinfo ed;
        daddr_t size;
        int rv = -1;

        /* Look for netbsd partition that is the dos boot one */
        d = alloc_biosdisk(biosdev);
        if (d == NULL)
                goto out;

        if (d->ll.type != BIOSDISK_TYPE_HD)
                /* No raidframe on floppy and CD */
                goto out;

        if (set_geometry(&d->ll, &ed) != 0)
                goto out;

        /* Sanity check values returned from BIOS */
        if (ed.sbytes >= 512 &&
            (ed.sbytes & (ed.sbytes - 1)) == 0)
                d->ll.secsize = ed.sbytes;

        offset += (RF_COMPONENT_INFO_OFFSET / d->ll.secsize);
        size = roundup(sizeof(*label), d->ll.secsize) / d->ll.secsize;
        if (readsects(&d->ll, offset, size, d->buf, 0))
                goto out;
        memcpy(label, d->buf, sizeof(*label));
        rv = 0;
out:
        if (d != NULL)
                dealloc_biosdisk(d);
        return rv;
#endif /* NO_DISKLABEL && NO_GPT */
}
#endif /* NO_RAIDFRAME */

#ifdef _STANDALONE
static void
add_biosdisk_bootinfo(void)
{
#ifndef EFIBOOT
        if (bootinfo == NULL) {
                return;
        }
        BI_ADD(&bi_disk, BTINFO_BOOTDISK, sizeof(bi_disk));
        BI_ADD(&bi_wedge, BTINFO_BOOTWEDGE, sizeof(bi_wedge));
#endif
        return;
}
#endif

#ifndef NO_GPT
static void
raidframe_part_offset(struct biosdisk *d, int part)
{
        struct biosdisk raidframe;
        daddr_t rf_offset;
        daddr_t rf_size;
        int i, candidate;

        memset(&raidframe, 0, sizeof(raidframe));
        raidframe.ll = d->ll;

        rf_offset = d->part[part].offset + RF_PROTECTED_SECTORS;
        rf_size = d->part[part].size;
        if (read_gpt(&raidframe, rf_offset, rf_size) != 0) {
                d->boff += RF_PROTECTED_SECTORS;
                return;
        }

        candidate = 0;
        for (i = 0; i < BIOSDISKNPART; i++) {
                if (raidframe.part[i].size == 0)
                        continue;
                if (raidframe.part[i].fstype == FS_UNUSED)
                        continue;
#ifndef NO_GPT
                if (raidframe.part[i].attr & GPT_ENT_ATTR_BOOTME) {
                        candidate = i;
                        break;
                }
#endif
                if (raidframe.part[i].fstype == FS_BSDFFS ||
                    raidframe.part[i].fstype == FS_BSDLFS) {
                        if (candidate == 0)
                                candidate = i;
                }
        }

        d->boff += RF_PROTECTED_SECTORS + raidframe.part[candidate].offset;
        d->size = raidframe.part[candidate].size;
}
#endif

int
biosdisk_open(struct open_file *f, ...)
/* struct open_file *f, int biosdev, int partition */
{
        va_list ap;
        struct biosdisk *d;
        int biosdev;
        int partition;
        int error = 0;

        va_start(ap, f);
        biosdev = va_arg(ap, int);
        d = alloc_biosdisk(biosdev);
        if (d == NULL) {
                error = ENXIO;
                goto out;
        }

        partition = va_arg(ap, int);
        bi_disk.biosdev = d->ll.dev;
        bi_disk.partition = partition;
        bi_disk.labelsector = -1;

        bi_wedge.biosdev = d->ll.dev;
        bi_wedge.matchblk = -1;

#if !defined(NO_DISKLABEL) || !defined(NO_GPT)
        error = read_partitions(d, 0, 0);
        if (error == -1) {
                error = 0;
                goto nolabel;
        }
        if (error)
                goto out;

        if (partition >= BIOSDISKNPART ||
            d->part[partition].fstype == FS_UNUSED) {
#ifdef DISK_DEBUG
                printf("illegal partition\n");
#endif
                error = EPART;
                goto out;
        }

        d->boff = d->part[partition].offset;
        d->size = d->part[partition].size;

        if (d->part[partition].fstype == FS_RAID)
#ifndef NO_GPT
                raidframe_part_offset(d, partition);
#else
                d->boff += RF_PROTECTED_SECTORS;
#endif

#ifdef _STANDALONE
        bi_wedge.startblk = d->boff;
        bi_wedge.nblks = d->size;
#endif

nolabel:
#endif
#ifdef DISK_DEBUG
        printf("partition @%"PRId64"\n", d->boff);
#endif

#ifdef _STANDALONE
        add_biosdisk_bootinfo();
#endif

        f->f_devdata = d;
out:
        va_end(ap);
        if (error)
                dealloc_biosdisk(d);
        return error;
}

#ifndef NO_GPT
static int
biosdisk_find_name(const char *fname, int *biosdev,
                   daddr_t *offset, daddr_t *size)
{
        struct biosdisk *d;
        char name[MAXDEVNAME + 1];
        char *sep;
#ifndef NO_RAIDFRAME
        struct raidframe raidframe[RAIDFRAME_NDEV];
        int raidframe_count = 0;
#endif
        int i;
        int part;
        int ret = -1;

        /* Strip leadinf NAME= and cut after the coloon included */
        strlcpy(name, fname + 5, MAXDEVNAME);
        sep = strchr(name, ':');
        if (sep)
                *sep = '\0';

        for (i = 0; i < MAX_BIOSDISKS; i++) {
                d = alloc(sizeof(*d));
                if (d == NULL) {
                        printf("Out of memory\n");
                        goto out;
                }

                memset(d, 0, sizeof(*d));
                d->ll.dev = 0x80 + i;                   /* hd/cd */
                if (set_geometry(&d->ll, NULL))
                        goto next_disk;

                if (d->ll.type != BIOSDISK_TYPE_HD)
                        goto next_disk;

                if (read_partitions(d, 0, 0) != 0)
                        goto next_disk;

                for (part = 0; part < BIOSDISKNPART; part++) {
                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype == FS_UNUSED)
                                continue;
#ifndef NO_RAIDFRAME
                        if (d->part[part].fstype == FS_RAID) {
                                raidframe_probe(raidframe,
                                                &raidframe_count, d, part);
                                /*
                                 * Do not match RAID partition for a name,
                                 * we want to report an inner partition.
                                 */
                                continue;
                        }
#endif
                        if (d->part[part].part_name != NULL &&
                            strcmp(d->part[part].part_name, name) == 0) {
                                *biosdev = d->ll.dev;
                                *offset = d->part[part].offset;
                                *size = d->part[part].size;
                                ret = 0;
                                goto out;
                        }

                }
next_disk:
                dealloc_biosdisk(d);
                d = NULL;
        }

#ifndef NO_RAIDFRAME
        for (i = 0; i < raidframe_count; i++) {
                int first_bootme = -1;
                int first_ffs = -1;
                int candidate = -1;

                if ((d = alloc_biosdisk(raidframe[i].biosdev)) == NULL) {
                        printf("Out of memory\n");
                        goto out;
                }

                if (read_partitions(d,
                    raidframe[i].offset + RF_PROTECTED_SECTORS,
                    raidframe[i].size) != 0)
                        goto next_raidframe;

                for (part = 0; part < BIOSDISKNPART; part++) {
                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype == FS_UNUSED)
                                continue;

                        if (first_bootme == -1 && 
                            d->part[part].attr & GPT_ENT_ATTR_BOOTME)
                                first_bootme = part;

                        if (first_ffs == -1 && 
                            (d->part[part].fstype == FS_BSDFFS ||
                             d->part[part].fstype == FS_BSDLFS))
                                first_ffs = part;

                        if (d->part[part].part_name != NULL &&
                            strcmp(d->part[part].part_name, name) == 0) {
                                *biosdev = raidframe[i].biosdev;
                                *offset = raidframe[i].offset
                                        + RF_PROTECTED_SECTORS
                                        + d->part[part].offset;
                                *size = d->part[part].size;
                                ret = 0;
                                goto out;
                        }
                }

                if (strcmp(raidframe[i].parent_name, name) == 0) {
                        if (first_bootme != -1)
                                candidate = first_bootme;
                        else if (first_ffs != -1)
                                candidate = first_ffs;
                }

                if (candidate != -1) {
                        *biosdev = raidframe[i].biosdev;
                        *offset = raidframe[i].offset
                                + RF_PROTECTED_SECTORS
                                + d->part[candidate].offset;
                        *size = d->part[candidate].size;
                        ret = 0;
                        goto out;
                }

next_raidframe:
                dealloc_biosdisk(d);
                d = NULL;
        }
#endif

out:
        if (d != NULL)
                dealloc_biosdisk(d);

        return ret;
}
#endif

#ifndef NO_RAIDFRAME
static int
biosdisk_find_raid(const char *name, int *biosdev,
                   daddr_t *offset, daddr_t *size)
{
        struct biosdisk *d = NULL;
        struct raidframe raidframe[RAIDFRAME_NDEV];
        int raidframe_count = 0;
        int i;
        int target_unit = 0;
        int target_part;
        int part;
        int ret = -1;

        if (strstr(name, "raid") != name)
                goto out;

#define isnum(c) ((c) >= '0' && (c) <= '9')
        i = 4; /* skip leading "raid" */
        if (!isnum(name[i]))
                goto out;
        do {
                target_unit *= 10;
                target_unit += name[i++] - '0';
        } while (isnum(name[i]));

#define isvalidpart(c) ((c) >= 'a' && (c) <= 'z')

        if (!isvalidpart(name[i]))
                goto out;
        target_part = name[i] - 'a';

        for (i = 0; i < MAX_BIOSDISKS; i++) {
                d = alloc(sizeof(*d));
                if (d == NULL) {
                        printf("Out of memory\n");
                        goto out;
                }

                memset(d, 0, sizeof(*d));
                d->ll.dev = 0x80 + i;                   /* hd/cd */
                if (set_geometry(&d->ll, NULL))
                        goto next_disk;

                if (d->ll.type != BIOSDISK_TYPE_HD)
                        goto next_disk;

                if (read_partitions(d, 0, 0) != 0)
                        goto next_disk;

                for (part = 0; part < BIOSDISKNPART; part++) {
                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype != FS_RAID)
                                continue;
                        raidframe_probe(raidframe,
                                        &raidframe_count, d, part);

                }
next_disk:
                dealloc_biosdisk(d);
                d = NULL;
        }

        for (i = 0; i < raidframe_count; i++) {
                int first_bootme = -1;
                int first_ffs = -1;
                int candidate = -1;

                if (raidframe[i].last_unit != target_unit)
                        continue;

                if ((d = alloc_biosdisk(raidframe[i].biosdev)) == NULL) {
                        printf("Out of memory\n");
                        goto out;
                }

                if (read_partitions(d,
                    raidframe[i].offset + RF_PROTECTED_SECTORS,
                    raidframe[i].size) != 0)
                        goto next_raidframe;

                for (part = 0; part < BIOSDISKNPART; part++) {
                        if (d->part[part].size == 0)
                                continue;
                        if (d->part[part].fstype == FS_UNUSED)
                                continue;

#ifndef NO_GPT
                        if (first_bootme == -1 &&
                            d->part[part].attr & GPT_ENT_ATTR_BOOTME)
                                first_bootme = part;
#endif

                        if (first_ffs == -1 &&
                            (d->part[part].fstype == FS_BSDFFS ||
                             d->part[part].fstype == FS_BSDLFS))
                                first_ffs = part;

                        if (part == target_part) {
                                *biosdev = raidframe[i].biosdev;
                                *offset = raidframe[i].offset
                                        + RF_PROTECTED_SECTORS
                                        + d->part[part].offset;
                                *size = d->part[part].size;
                                ret = 0;
                                goto out;
                        }
                }

                if (first_bootme != -1)
                        candidate = first_bootme;
                else if (first_ffs != -1)
                        candidate = first_ffs;

                if (candidate != -1) {
                        *biosdev = raidframe[i].biosdev;
                        *offset = raidframe[i].offset
                                + RF_PROTECTED_SECTORS
                                + d->part[candidate].offset;
                        *size = d->part[candidate].size;
                        ret = 0;
                        goto out;
                }

next_raidframe:
                dealloc_biosdisk(d);
                d = NULL;
        }
out:
        if (d != NULL)
                dealloc_biosdisk(d);

        return ret;
}
#endif

int
biosdisk_open_name(struct open_file *f, const char *name)
{
#if defined(NO_GPT) && defined(NO_RAIDFRAME)
        return ENXIO;
#else
        struct biosdisk *d = NULL;
        int biosdev;
        daddr_t offset;
        daddr_t size;
        int error = -1;

#ifndef NO_GPT
        if (error && strstr(name, "NAME=") == name)
                error = biosdisk_find_name(name, &biosdev, &offset, &size);
#endif
#ifndef NO_RAIDFRAME
        if (error && strstr(name, "raid") == name)
                error = biosdisk_find_raid(name, &biosdev, &offset, &size);
#endif

        if (error != 0) {
                printf("%s not found\n", name);
                error = ENXIO;
                goto out;
        }

        d = alloc_biosdisk(biosdev);
        if (d == NULL) {
                error = ENXIO;
                goto out;
        }

        bi_disk.biosdev = d->ll.dev;
        bi_disk.partition = 0;
        bi_disk.labelsector = -1;

        bi_wedge.biosdev = d->ll.dev;

        /*
         * If we did not get wedge match info from check_gpt()
         * compute it now.
         */
        if (bi_wedge.matchblk == -1) {
                if (readsects(&d->ll, offset, 1, d->buf, 1)) {
#ifdef DISK_DEBUG
                        printf("Error reading sector at %"PRId64"\n", offset);
#endif
                        error =  EIO;
                        goto out;
                }

                bi_wedge.matchblk = offset;
                bi_wedge.matchnblks = 1;

                md5(bi_wedge.matchhash, d->buf, d->ll.secsize);
        }

        d->boff = offset;

        bi_wedge.startblk = offset;
        bi_wedge.nblks = size;

#ifdef _STANDALONE
        add_biosdisk_bootinfo();
#endif

        f->f_devdata = d;
out:
        if (error && d != NULL)
                dealloc_biosdisk(d);
        return error;
#endif
}



#ifndef LIBSA_NO_FS_CLOSE
int
biosdisk_close(struct open_file *f)
{
        struct biosdisk *d = f->f_devdata;

        /* let the floppy drive go off */
        if (d->ll.type == BIOSDISK_TYPE_FD)
                wait_sec(3);    /* 2s is enough on all PCs I found */

        dealloc_biosdisk(d);
        f->f_devdata = NULL;
        return 0;
}
#endif

int
biosdisk_ioctl(struct open_file *f, u_long cmd, void *arg)
{
        return EIO;
}