svn commit: r239058 - in head/sys/boot: common userboot
userboot/test userboot/userboot
Doug Rabson
dfr at rabson.org
Sun Aug 5 13:06:20 UTC 2012
If you change the loader callbacks structure, you need to change the version number to avoid unexpected results for mismatched combinations of application and userboot.so.
On 5 Aug 2012, at 13:15, Andrey V. Elsukov wrote:
> Author: ae
> Date: Sun Aug 5 12:15:15 2012
> New Revision: 239058
> URL: http://svn.freebsd.org/changeset/base/239058
>
> Log:
> Introduce new API to work with disks from the loader's drivers.
> It uses new API from the part.c to work with partition tables.
>
> Update userboot's disk driver to use new API. Note that struct
> loader_callbacks_v1 has changed.
>
> Modified:
> head/sys/boot/common/Makefile.inc
> head/sys/boot/common/disk.c
> head/sys/boot/common/disk.h
> head/sys/boot/userboot/test/test.c
> head/sys/boot/userboot/userboot.h
> head/sys/boot/userboot/userboot/Makefile
> head/sys/boot/userboot/userboot/devicename.c
> head/sys/boot/userboot/userboot/userboot_disk.c
>
> Modified: head/sys/boot/common/Makefile.inc
> ==============================================================================
> --- head/sys/boot/common/Makefile.inc Sun Aug 5 11:59:46 2012 (r239057)
> +++ head/sys/boot/common/Makefile.inc Sun Aug 5 12:15:15 2012 (r239058)
> @@ -1,6 +1,6 @@
> # $FreeBSD$
>
> -SRCS+= boot.c commands.c console.c devopen.c disk.c interp.c
> +SRCS+= boot.c commands.c console.c devopen.c interp.c
> SRCS+= interp_backslash.c interp_parse.c ls.c misc.c
> SRCS+= module.c panic.c
>
> @@ -24,6 +24,18 @@ SRCS+= load_elf64.c reloc_elf64.c
> SRCS+= dev_net.c
> .endif
>
> +.if !defined(LOADER_NO_DISK_SUPPORT)
> +SRCS+= disk.c part.c
> +CFLAGS+= -DLOADER_DISK_SUPPORT
> +.if !defined(LOADER_NO_GPT_SUPPORT)
> +SRCS+= crc32.c
> +CFLAGS+= -DLOADER_GPT_SUPPORT
> +.endif
> +.if !defined(LOADER_NO_MBR_SUPPORT)
> +CFLAGS+= -DLOADER_MBR_SUPPORT
> +.endif
> +.endif
> +
> .if defined(HAVE_BCACHE)
> SRCS+= bcache.c
> .endif
>
> Modified: head/sys/boot/common/disk.c
> ==============================================================================
> --- head/sys/boot/common/disk.c Sun Aug 5 11:59:46 2012 (r239057)
> +++ head/sys/boot/common/disk.c Sun Aug 5 12:15:15 2012 (r239058)
> @@ -1,5 +1,6 @@
> /*-
> * Copyright (c) 1998 Michael Smith <msmith at freebsd.org>
> + * Copyright (c) 2012 Andrey V. Elsukov <ae at FreeBSD.org>
> * All rights reserved.
> *
> * Redistribution and use in source and binary forms, with or without
> @@ -27,26 +28,11 @@
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD$");
>
> -/*
> - * MBR/GPT partitioned disk device handling.
> - *
> - * Ideas and algorithms from:
> - *
> - * - NetBSD libi386/biosdisk.c
> - * - FreeBSD biosboot/disk.c
> - *
> - */
> -
> +#include <sys/disk.h>
> #include <stand.h>
> -
> -#include <sys/diskmbr.h>
> -#include <sys/disklabel.h>
> -#include <sys/gpt.h>
> -
> #include <stdarg.h>
> -#include <uuid.h>
> -
> #include <bootstrap.h>
> +#include <part.h>
>
> #include "disk.h"
>
> @@ -56,53 +42,26 @@ __FBSDID("$FreeBSD$");
> # define DEBUG(fmt, args...)
> #endif
>
> -/*
> - * Search for a slice with the following preferences:
> - *
> - * 1: Active FreeBSD slice
> - * 2: Non-active FreeBSD slice
> - * 3: Active Linux slice
> - * 4: non-active Linux slice
> - * 5: Active FAT/FAT32 slice
> - * 6: non-active FAT/FAT32 slice
> - */
> -#define PREF_RAWDISK 0
> -#define PREF_FBSD_ACT 1
> -#define PREF_FBSD 2
> -#define PREF_LINUX_ACT 3
> -#define PREF_LINUX 4
> -#define PREF_DOS_ACT 5
> -#define PREF_DOS 6
> -#define PREF_NONE 7
> -
> -#ifdef LOADER_GPT_SUPPORT
> -
> -struct gpt_part {
> - int gp_index;
> - uuid_t gp_type;
> - uint64_t gp_start;
> - uint64_t gp_end;
> +struct open_disk {
> + struct ptable *table;
> + off_t mediasize;
> + u_int sectorsize;
> };
>
> -static uuid_t efi = GPT_ENT_TYPE_EFI;
> -static uuid_t freebsd_boot = GPT_ENT_TYPE_FREEBSD_BOOT;
> -static uuid_t freebsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
> -static uuid_t freebsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
> -static uuid_t freebsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
> -static uuid_t ms_basic_data = GPT_ENT_TYPE_MS_BASIC_DATA;
> -
> -#endif
> -
> -#if defined(LOADER_GPT_SUPPORT) || defined(LOADER_MBR_SUPPORT)
> +struct print_args {
> + struct disk_devdesc *dev;
> + const char *prefix;
> + int verbose;
> +};
>
> -/* Given a size in 512 byte sectors, convert it to a human-readable number. */
> +/* Convert size to a human-readable number. */
> static char *
> -display_size(uint64_t size)
> +display_size(uint64_t size, u_int sectorsize)
> {
> static char buf[80];
> char unit;
>
> - size /= 2;
> + size = size * sectorsize / 1024;
> unit = 'K';
> if (size >= 10485760000LL) {
> size /= 1073741824;
> @@ -114,687 +73,230 @@ display_size(uint64_t size)
> size /= 1024;
> unit = 'M';
> }
> - sprintf(buf, "%.6ld%cB", (long)size, unit);
> + sprintf(buf, "%ld%cB", (long)size, unit);
> return (buf);
> }
>
> -#endif
> -
> -#ifdef LOADER_MBR_SUPPORT
> -
> -static void
> -disk_checkextended(struct disk_devdesc *dev,
> - struct dos_partition *slicetab, int slicenum, int *nslicesp)
> -{
> - uint8_t buf[DISK_SECSIZE];
> - struct dos_partition *dp;
> - uint32_t base;
> - int rc, i, start, end;
> -
> - dp = &slicetab[slicenum];
> - start = *nslicesp;
> -
> - if (dp->dp_size == 0)
> - goto done;
> - if (dp->dp_typ != DOSPTYP_EXT)
> - goto done;
> - rc = dev->d_dev->dv_strategy(dev, F_READ, dp->dp_start, DISK_SECSIZE,
> - (char *) buf, NULL);
> - if (rc)
> - goto done;
> - if (buf[0x1fe] != 0x55 || buf[0x1ff] != 0xaa) {
> - DEBUG("no magic in extended table");
> - goto done;
> - }
> - base = dp->dp_start;
> - dp = (struct dos_partition *) &buf[DOSPARTOFF];
> - for (i = 0; i < NDOSPART; i++, dp++) {
> - if (dp->dp_size == 0)
> - continue;
> - if (*nslicesp == NEXTDOSPART)
> - goto done;
> - dp->dp_start += base;
> - bcopy(dp, &slicetab[*nslicesp], sizeof(*dp));
> - (*nslicesp)++;
> - }
> - end = *nslicesp;
> -
> - /*
> - * now, recursively check the slices we just added
> - */
> - for (i = start; i < end; i++)
> - disk_checkextended(dev, slicetab, i, nslicesp);
> -done:
> - return;
> -}
> -
> -static int
> -disk_readslicetab(struct disk_devdesc *dev,
> - struct dos_partition **slicetabp, int *nslicesp)
> -{
> - struct dos_partition *slicetab = NULL;
> - int nslices, i;
> - int rc;
> - uint8_t buf[DISK_SECSIZE];
> -
> - /*
> - * Find the slice in the DOS slice table.
> - */
> - rc = dev->d_dev->dv_strategy(dev, F_READ, 0, DISK_SECSIZE,
> - (char *) buf, NULL);
> - if (rc) {
> - DEBUG("error reading MBR");
> - return (rc);
> - }
> -
> - /*
> - * Check the slice table magic.
> - */
> - if (buf[0x1fe] != 0x55 || buf[0x1ff] != 0xaa) {
> - DEBUG("no slice table/MBR (no magic)");
> - return (rc);
> - }
> -
> - /*
> - * copy the partition table, then pick up any extended partitions.
> - */
> - slicetab = malloc(NEXTDOSPART * sizeof(struct dos_partition));
> - bcopy(buf + DOSPARTOFF, slicetab,
> - sizeof(struct dos_partition) * NDOSPART);
> - nslices = NDOSPART; /* extended slices start here */
> - for (i = 0; i < NDOSPART; i++)
> - disk_checkextended(dev, slicetab, i, &nslices);
> -
> - *slicetabp = slicetab;
> - *nslicesp = nslices;
> - return (0);
> -}
> -
> -/*
> - * Search for the best MBR slice (typically the first FreeBSD slice).
> - */
> -static int
> -disk_bestslice(struct dos_partition *slicetab, int nslices)
> -{
> - struct dos_partition *dp;
> - int pref, preflevel;
> - int i, prefslice;
> -
> - prefslice = 0;
> - preflevel = PREF_NONE;
> -
> - dp = &slicetab[0];
> - for (i = 0; i < nslices; i++, dp++) {
> - switch (dp->dp_typ) {
> - case DOSPTYP_386BSD: /* FreeBSD */
> - pref = dp->dp_flag & 0x80 ? PREF_FBSD_ACT : PREF_FBSD;
> - break;
> -
> - case DOSPTYP_LINUX:
> - pref = dp->dp_flag & 0x80 ? PREF_LINUX_ACT : PREF_LINUX;
> - break;
> -
> - case 0x01: /* DOS/Windows */
> - case 0x04:
> - case 0x06:
> - case 0x0b:
> - case 0x0c:
> - case 0x0e:
> - pref = dp->dp_flag & 0x80 ? PREF_DOS_ACT : PREF_DOS;
> - break;
> -
> - default:
> - pref = PREF_NONE;
> - }
> - if (pref < preflevel) {
> - preflevel = pref;
> - prefslice = i + 1;
> - }
> - }
> - return (prefslice);
> -}
> -
> static int
> -disk_openmbr(struct disk_devdesc *dev)
> -{
> - struct dos_partition *slicetab = NULL, *dptr;
> - int nslices, sector, slice;
> - int rc;
> - uint8_t buf[DISK_SECSIZE];
> - struct disklabel *lp;
> -
> - /*
> - * Following calculations attempt to determine the correct value
> - * for dev->d_offset by looking for the slice and partition specified,
> - * or searching for reasonable defaults.
> - */
> - rc = disk_readslicetab(dev, &slicetab, &nslices);
> - if (rc)
> - return (rc);
> -
> - /*
> - * if a slice number was supplied but not found, this is an error.
> - */
> - if (dev->d_slice > 0) {
> - slice = dev->d_slice - 1;
> - if (slice >= nslices) {
> - DEBUG("slice %d not found", slice);
> - rc = EPART;
> - goto out;
> - }
> - }
> -
> - /*
> - * Check for the historically bogus MBR found on true dedicated disks
> - */
> - if (slicetab[3].dp_typ == DOSPTYP_386BSD &&
> - slicetab[3].dp_start == 0 && slicetab[3].dp_size == 50000) {
> - sector = 0;
> - goto unsliced;
> - }
> -
> - /*
> - * Try to auto-detect the best slice; this should always give
> - * a slice number
> - */
> - if (dev->d_slice == 0) {
> - slice = disk_bestslice(slicetab, nslices);
> - if (slice == -1) {
> - rc = ENOENT;
> - goto out;
> - }
> - dev->d_slice = slice;
> - }
> -
> - /*
> - * Accept the supplied slice number unequivocally (we may be looking
> - * at a DOS partition).
> - * Note: we number 1-4, offsets are 0-3
> - */
> - dptr = &slicetab[dev->d_slice - 1];
> - sector = dptr->dp_start;
> - DEBUG("slice entry %d at %d, %d sectors",
> - dev->d_slice - 1, sector, dptr->dp_size);
> -
> -unsliced:
> - /*
> - * Now we have the slice offset, look for the partition in the
> - * disklabel if we have a partition to start with.
> - *
> - * XXX we might want to check the label checksum.
> - */
> - if (dev->d_partition < 0) {
> - /* no partition, must be after the slice */
> - DEBUG("opening raw slice");
> - dev->d_offset = sector;
> - rc = 0;
> - goto out;
> - }
> -
> - rc = dev->d_dev->dv_strategy(dev, F_READ, sector + LABELSECTOR,
> - DISK_SECSIZE, (char *) buf, NULL);
> - if (rc) {
> - DEBUG("error reading disklabel");
> - goto out;
> - }
> -
> - lp = (struct disklabel *) buf;
> -
> - if (lp->d_magic != DISKMAGIC) {
> - DEBUG("no disklabel");
> - rc = ENOENT;
> - goto out;
> - }
> - if (dev->d_partition >= lp->d_npartitions) {
> - DEBUG("partition '%c' exceeds partitions in table (a-'%c')",
> - 'a' + dev->d_partition,
> - 'a' + lp->d_npartitions);
> - rc = EPART;
> - goto out;
> - }
> -
> - dev->d_offset =
> - lp->d_partitions[dev->d_partition].p_offset -
> - lp->d_partitions[RAW_PART].p_offset +
> - sector;
> - rc = 0;
> -
> -out:
> - if (slicetab)
> - free(slicetab);
> - return (rc);
> -}
> -
> -/*
> - * Print out each valid partition in the disklabel of a FreeBSD slice.
> - * For size calculations, we assume a 512 byte sector size.
> - */
> -static void
> -disk_printbsdslice(struct disk_devdesc *dev, daddr_t offset,
> - char *prefix, int verbose)
> +ptblread(void *d, void *buf, size_t blocks, off_t offset)
> {
> - char line[80];
> - char buf[DISK_SECSIZE];
> - struct disklabel *lp;
> - int i, rc, fstype;
> -
> - /* read disklabel */
> - rc = dev->d_dev->dv_strategy(dev, F_READ, offset + LABELSECTOR,
> - DISK_SECSIZE, (char *) buf, NULL);
> - if (rc)
> - return;
> - lp =(struct disklabel *)(&buf[0]);
> - if (lp->d_magic != DISKMAGIC) {
> - sprintf(line, "%s: FFS bad disklabel\n", prefix);
> - pager_output(line);
> - return;
> - }
> + struct disk_devdesc *dev;
> + struct open_disk *od;
>
> - /* Print partitions */
> - for (i = 0; i < lp->d_npartitions; i++) {
> - /*
> - * For each partition, make sure we know what type of fs it
> - * is. If not, then skip it.
> - */
> - fstype = lp->d_partitions[i].p_fstype;
> - if (fstype != FS_BSDFFS &&
> - fstype != FS_SWAP &&
> - fstype != FS_VINUM)
> - continue;
> -
> - /* Only print out statistics in verbose mode */
> - if (verbose)
> - sprintf(line, " %s%c: %s %s (%d - %d)\n",
> - prefix, 'a' + i,
> - (fstype == FS_SWAP) ? "swap " :
> - (fstype == FS_VINUM) ? "vinum" :
> - "FFS ",
> - display_size(lp->d_partitions[i].p_size),
> - lp->d_partitions[i].p_offset,
> - (lp->d_partitions[i].p_offset
> - + lp->d_partitions[i].p_size));
> - else
> - sprintf(line, " %s%c: %s\n", prefix, 'a' + i,
> - (fstype == FS_SWAP) ? "swap" :
> - (fstype == FS_VINUM) ? "vinum" :
> - "FFS");
> - pager_output(line);
> - }
> + dev = (struct disk_devdesc *)d;
> + od = (struct open_disk *)dev->d_opendata;
> + return (dev->d_dev->dv_strategy(dev, F_READ, offset,
> + blocks * od->sectorsize, (char *)buf, NULL));
> }
>
> +#define PWIDTH 35
> static void
> -disk_printslice(struct disk_devdesc *dev, int slice,
> - struct dos_partition *dp, char *prefix, int verbose)
> +ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
> {
> - char stats[80];
> + struct print_args *pa, bsd;
> + struct open_disk *od;
> + struct ptable *table;
> char line[80];
>
> - if (verbose)
> - sprintf(stats, " %s (%d - %d)", display_size(dp->dp_size),
> - dp->dp_start, dp->dp_start + dp->dp_size);
> - else
> - stats[0] = '\0';
> -
> - switch (dp->dp_typ) {
> - case DOSPTYP_386BSD:
> - disk_printbsdslice(dev, (daddr_t)dp->dp_start,
> - prefix, verbose);
> - return;
> - case DOSPTYP_LINSWP:
> - sprintf(line, "%s: Linux swap%s\n", prefix, stats);
> - break;
> - case DOSPTYP_LINUX:
> - /*
> - * XXX
> - * read the superblock to confirm this is an ext2fs partition?
> - */
> - sprintf(line, "%s: ext2fs%s\n", prefix, stats);
> - break;
> - case 0x00: /* unused partition */
> - case DOSPTYP_EXT:
> - return;
> - case 0x01:
> - sprintf(line, "%s: FAT-12%s\n", prefix, stats);
> - break;
> - case 0x04:
> - case 0x06:
> - case 0x0e:
> - sprintf(line, "%s: FAT-16%s\n", prefix, stats);
> - break;
> - case 0x07:
> - sprintf(line, "%s: NTFS/HPFS%s\n", prefix, stats);
> - break;
> - case 0x0b:
> - case 0x0c:
> - sprintf(line, "%s: FAT-32%s\n", prefix, stats);
> - break;
> - default:
> - sprintf(line, "%s: Unknown fs: 0x%x %s\n", prefix, dp->dp_typ,
> - stats);
> - }
> + pa = (struct print_args *)arg;
> + od = (struct open_disk *)pa->dev->d_opendata;
> + sprintf(line, " %s%s: %s", pa->prefix, pname,
> + parttype2str(part->type));
> + if (pa->verbose)
> + sprintf(line, "%-*s%s", PWIDTH, line,
> + display_size(part->end - part->start + 1,
> + od->sectorsize));
> + strcat(line, "\n");
> pager_output(line);
> -}
> -
> -static int
> -disk_printmbr(struct disk_devdesc *dev, char *prefix, int verbose)
> -{
> - struct dos_partition *slicetab;
> - int nslices, i;
> - int rc;
> - char line[80];
> -
> - rc = disk_readslicetab(dev, &slicetab, &nslices);
> - if (rc)
> - return (rc);
> - for (i = 0; i < nslices; i++) {
> - sprintf(line, "%ss%d", prefix, i + 1);
> - disk_printslice(dev, i, &slicetab[i], line, verbose);
> - }
> - free(slicetab);
> - return (0);
> -}
> -
> -#endif
> -
> -#ifdef LOADER_GPT_SUPPORT
> -
> -static int
> -disk_readgpt(struct disk_devdesc *dev, struct gpt_part **gptp, int *ngptp)
> -{
> - struct dos_partition *dp;
> - struct gpt_hdr *hdr;
> - struct gpt_ent *ent;
> - struct gpt_part *gptab = NULL;
> - int entries_per_sec, rc, i, part;
> - daddr_t lba, elba;
> - uint8_t gpt[DISK_SECSIZE], tbl[DISK_SECSIZE];
> -
> - /*
> - * Following calculations attempt to determine the correct value
> - * for dev->d_offset by looking for the slice and partition specified,
> - * or searching for reasonable defaults.
> - */
> - rc = 0;
> -
> - /* First, read the MBR and see if we have a PMBR. */
> - rc = dev->d_dev->dv_strategy(dev, F_READ, 0, DISK_SECSIZE,
> - (char *) tbl, NULL);
> - if (rc) {
> - DEBUG("error reading MBR");
> - return (EIO);
> + if (part->type == PART_FREEBSD) {
> + /* Open slice with BSD label */
> + pa->dev->d_offset = part->start;
> + table = ptable_open(pa->dev, part->end - part->start + 1,
> + od->sectorsize, ptblread);
> + if (table == NULL)
> + return;
> + sprintf(line, " %s%s", pa->prefix, pname);
> + bsd.dev = pa->dev;
> + bsd.prefix = line;
> + bsd.verbose = pa->verbose;
> + ptable_iterate(table, &bsd, ptable_print);
> + ptable_close(table);
> }
> -
> - /* Check the slice table magic. */
> - if (tbl[0x1fe] != 0x55 || tbl[0x1ff] != 0xaa)
> - return (ENXIO);
> -
> - /* Check for GPT slice. */
> - part = 0;
> - dp = (struct dos_partition *)(tbl + DOSPARTOFF);
> - for (i = 0; i < NDOSPART; i++) {
> - if (dp[i].dp_typ == 0xee)
> - part++;
> - else if ((part != 1) && (dp[i].dp_typ != 0x00))
> - return (EINVAL);
> - }
> - if (part != 1)
> - return (EINVAL);
> -
> - /* Read primary GPT table header. */
> - rc = dev->d_dev->dv_strategy(dev, F_READ, 1, DISK_SECSIZE,
> - (char *) gpt, NULL);
> - if (rc) {
> - DEBUG("error reading GPT header");
> - return (EIO);
> - }
> - hdr = (struct gpt_hdr *)gpt;
> - if (bcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)) != 0 ||
> - hdr->hdr_lba_self != 1 || hdr->hdr_revision < 0x00010000 ||
> - hdr->hdr_entsz < sizeof(*ent) ||
> - DISK_SECSIZE % hdr->hdr_entsz != 0) {
> - DEBUG("Invalid GPT header\n");
> - return (EINVAL);
> - }
> -
> - /* Walk the partition table to count valid partitions. */
> - part = 0;
> - entries_per_sec = DISK_SECSIZE / hdr->hdr_entsz;
> - elba = hdr->hdr_lba_table + hdr->hdr_entries / entries_per_sec;
> - for (lba = hdr->hdr_lba_table; lba < elba; lba++) {
> - rc = dev->d_dev->dv_strategy(dev, F_READ, lba, DISK_SECSIZE,
> - (char *) tbl, NULL);
> - if (rc) {
> - DEBUG("error reading GPT table");
> - return (EIO);
> - }
> - for (i = 0; i < entries_per_sec; i++) {
> - ent = (struct gpt_ent *)(tbl + i * hdr->hdr_entsz);
> - if (uuid_is_nil(&ent->ent_type, NULL) ||
> - ent->ent_lba_start == 0 ||
> - ent->ent_lba_end < ent->ent_lba_start)
> - continue;
> - part++;
> - }
> - }
> -
> - /* Save the important information about all the valid partitions. */
> - if (part != 0) {
> - gptab = malloc(part * sizeof(struct gpt_part));
> - part = 0;
> - for (lba = hdr->hdr_lba_table; lba < elba; lba++) {
> - rc = dev->d_dev->dv_strategy(dev, F_READ, lba, DISK_SECSIZE,
> - (char *) tbl, NULL);
> - if (rc) {
> - DEBUG("error reading GPT table");
> - free(gptab);
> - return (EIO);
> - }
> - for (i = 0; i < entries_per_sec; i++) {
> - ent = (struct gpt_ent *)(tbl + i * hdr->hdr_entsz);
> - if (uuid_is_nil(&ent->ent_type, NULL) ||
> - ent->ent_lba_start == 0 ||
> - ent->ent_lba_end < ent->ent_lba_start)
> - continue;
> - gptab[part].gp_index = (lba - hdr->hdr_lba_table) *
> - entries_per_sec + i + 1;
> - gptab[part].gp_type = ent->ent_type;
> - gptab[part].gp_start = ent->ent_lba_start;
> - gptab[part].gp_end = ent->ent_lba_end;
> - part++;
> - }
> - }
> - }
> -
> - *gptp = gptab;
> - *ngptp = part;
> - return (0);
> }
> +#undef PWIDTH
>
> -static struct gpt_part *
> -disk_bestgpt(struct gpt_part *gpt, int ngpt)
> +void
> +disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
> {
> - struct gpt_part *gp, *prefpart;
> - int i, pref, preflevel;
> -
> - prefpart = NULL;
> - preflevel = PREF_NONE;
> + struct open_disk *od;
> + struct print_args pa;
>
> - gp = gpt;
> - for (i = 0; i < ngpt; i++, gp++) {
> - /* Windows. XXX: Also Linux. */
> - if (uuid_equal(&gp->gp_type, &ms_basic_data, NULL))
> - pref = PREF_DOS;
> - /* FreeBSD */
> - else if (uuid_equal(&gp->gp_type, &freebsd_ufs, NULL) ||
> - uuid_equal(&gp->gp_type, &freebsd_zfs, NULL))
> - pref = PREF_FBSD;
> - else
> - pref = PREF_NONE;
> - if (pref < preflevel) {
> - preflevel = pref;
> - prefpart = gp;
> - }
> - }
> - return (prefpart);
> + /* Disk should be opened */
> + od = (struct open_disk *)dev->d_opendata;
> + pa.dev = dev;
> + pa.prefix = prefix;
> + pa.verbose = verbose;
> + ptable_iterate(od->table, &pa, ptable_print);
> }
>
> -static int
> -disk_opengpt(struct disk_devdesc *dev)
> +int
> +disk_open(struct disk_devdesc *dev, off_t mediasize, u_int sectorsize)
> {
> - struct gpt_part *gpt = NULL, *gp;
> - int rc, ngpt, i;
> + struct open_disk *od;
> + struct ptable *table;
> + struct ptable_entry part;
> + int rc;
>
> - rc = disk_readgpt(dev, &gpt, &ngpt);
> - if (rc)
> - return (rc);
> -
> - /* Is this a request for the whole disk? */
> - if (dev->d_slice < 0) {
> - dev->d_offset = 0;
> - rc = 0;
> - goto out;
> + od = (struct open_disk *)malloc(sizeof(struct open_disk));
> + if (od == NULL) {
> + DEBUG("no memory");
> + return (ENOMEM);
> }
> -
> /*
> - * If a partition number was supplied, then the user is trying to use
> - * an MBR address rather than a GPT address, so fail.
> + * While we are reading disk metadata, make sure we do it relative
> + * to the start of the disk
> */
> - if (dev->d_partition != 0xff) {
> - rc = ENOENT;
> + rc = 0;
> + table = NULL;
> + dev->d_offset = 0;
> + dev->d_opendata = od;
> + od->mediasize = mediasize;
> + od->sectorsize = sectorsize;
> + DEBUG("open '%s', unit %d slice %d partition %d",
> + disk_fmtdev(dev), dev->d_unit, dev->d_slice, dev->d_partition);
> +
> + /* Determine disk layout. */
> + od->table = ptable_open(dev, mediasize / sectorsize, sectorsize,
> + ptblread);
> + if (od->table == NULL) {
> + DEBUG("Can't read partition table");
> + rc = ENXIO;
> goto out;
> }
> -
> - /* If a slice number was supplied but not found, this is an error. */
> - gp = NULL;
> if (dev->d_slice > 0) {
> - for (i = 0; i < ngpt; i++) {
> - if (gpt[i].gp_index == dev->d_slice) {
> - gp = &gpt[i];
> - break;
> - }
> - }
> - if (gp == NULL) {
> - DEBUG("partition %d not found", dev->d_slice);
> - rc = ENOENT;
> + /* Try to get information about partition */
> + rc = ptable_getpart(od->table, &part, dev->d_slice);
> + if (rc != 0) /* Partition doesn't exist */
> goto out;
> - }
> - }
> -
> - /* Try to auto-detect the best partition. */
> - if (dev->d_slice == 0) {
> - gp = disk_bestgpt(gpt, ngpt);
> - if (gp == NULL) {
> - rc = ENOENT;
> + dev->d_offset = part.start;
> + if (dev->d_partition == -1 ||
> + dev->d_partition == 255)
> + goto out; /* Nothing more to do */
> +
> + /* Try to read BSD label */
> + table = ptable_open(dev, part.end - part.start + 1,
> + od->sectorsize, ptblread);
> + if (table == NULL) {
> + DEBUG("Can't read BSD label");
> + rc = ENXIO;
> goto out;
> }
> - dev->d_slice = gp->gp_index;
> + rc = ptable_getpart(table, &part, dev->d_partition);
> + if (rc != 0)
> + goto out;
> + dev->d_offset += part.start;
> + } else if (dev->d_slice == 0) {
> + rc = ptable_getbestpart(od->table, &part);
> + if (rc != 0)
> + goto out;
> + /* Save the slice number of best partition to dev */
> + dev->d_slice = part.index;
> + dev->d_offset = part.start;
> }
> -
> - dev->d_offset = gp->gp_start;
> - rc = 0;
> -
> out:
> - if (gpt)
> - free(gpt);
> + if (table != NULL)
> + ptable_close(table);
> + if (rc != 0) {
> + if (od->table != NULL)
> + ptable_close(od->table);
> + free(od);
> + }
> return (rc);
> }
>
> -static void
> -disk_printgptpart(struct disk_devdesc *dev, struct gpt_part *gp,
> - char *prefix, int verbose)
> +int
> +disk_close(struct disk_devdesc *dev)
> {
> - char stats[80];
> - char line[96];
> -
> - if (verbose)
> - sprintf(stats, " %s",
> - display_size(gp->gp_end + 1 - gp->gp_start));
> - else
> - stats[0] = '\0';
> -
> - if (uuid_equal(&gp->gp_type, &efi, NULL))
> - sprintf(line, "%s: EFI %s\n", prefix, stats);
> - else if (uuid_equal(&gp->gp_type, &ms_basic_data, NULL))
> - sprintf(line, "%s: FAT/NTFS %s\n", prefix, stats);
> - else if (uuid_equal(&gp->gp_type, &freebsd_boot, NULL))
> - sprintf(line, "%s: FreeBSD boot%s\n", prefix, stats);
> - else if (uuid_equal(&gp->gp_type, &freebsd_ufs, NULL))
> - sprintf(line, "%s: FreeBSD UFS %s\n", prefix, stats);
> - else if (uuid_equal(&gp->gp_type, &freebsd_zfs, NULL))
> - sprintf(line, "%s: FreeBSD ZFS %s\n", prefix, stats);
> - else if (uuid_equal(&gp->gp_type, &freebsd_swap, NULL))
> - sprintf(line, "%s: FreeBSD swap%s\n", prefix, stats);
> - else
> - sprintf(line,
> - "%s: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x%s\n",
> - prefix,
> - gp->gp_type.time_low, gp->gp_type.time_mid,
> - gp->gp_type.time_hi_and_version,
> - gp->gp_type.clock_seq_hi_and_reserved,
> - gp->gp_type.clock_seq_low,
> - gp->gp_type.node[0],
> - gp->gp_type.node[1],
> - gp->gp_type.node[2],
> - gp->gp_type.node[3],
> - gp->gp_type.node[4],
> - gp->gp_type.node[5],
> - stats);
> - pager_output(line);
> -}
> + struct open_disk *od;
>
> -static int
> -disk_printgpt(struct disk_devdesc *dev, char *prefix, int verbose)
> -{
> - struct gpt_part *gpt = NULL;
> - int rc, ngpt, i;
> - char line[80];
> -
> - rc = disk_readgpt(dev, &gpt, &ngpt);
> - if (rc)
> - return (rc);
> - for (i = 0; i < ngpt; i++) {
> - sprintf(line, "%sp%d", prefix, i + 1);
> - disk_printgptpart(dev, &gpt[i], line, verbose);
> - }
> - free(gpt);
> + od = (struct open_disk *)dev->d_opendata;
> + ptable_close(od->table);
> + free(od);
> return (0);
> }
>
> -#endif
> -
> -int
> -disk_open(struct disk_devdesc *dev)
> +char*
> +disk_fmtdev(struct disk_devdesc *dev)
> {
> - int rc;
> -
> - rc = 0;
> - /*
> - * While we are reading disk metadata, make sure we do it relative
> - * to the start of the disk
> - */
> - dev->d_offset = 0;
> + static char buf[128];
> + char *cp;
>
> + cp = buf + sprintf(buf, "%s%d", dev->d_dev->dv_name, dev->d_unit);
> + if (dev->d_slice > 0) {
> #ifdef LOADER_GPT_SUPPORT
> - rc = disk_opengpt(dev);
> - if (rc == 0)
> - return (0);
> + if (dev->d_partition == 255) {
> + sprintf(cp, "p%d:", dev->d_slice);
> + return (buf);
> + } else
> #endif
> #ifdef LOADER_MBR_SUPPORT
> - rc = disk_openmbr(dev);
> + cp += sprintf(cp, "s%d", dev->d_slice);
> #endif
> -
> - return (rc);
> + if (dev->d_partition >= 0)
> + cp += sprintf(cp, "%c", dev->d_partition + 'a');
> + }
> + strcat(cp, ":");
> + return (buf);
> }
>
> -void
> -disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
> +int
> +disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
> {
> -
> + int unit, slice, partition;
> + const char *np;
> + char *cp;
> +
> + np = devspec;
> + unit = slice = partition = -1;
> + if (*np != '\0' && *np != ':') {
> + unit = strtol(np, &cp, 10);
> + if (cp == np)
> + return (EUNIT);
> #ifdef LOADER_GPT_SUPPORT
> - if (disk_printgpt(dev, prefix, verbose) == 0)
> - return;
> + if (*cp == 'p') {
> + np = cp + 1;
> + slice = strtol(np, &cp, 10);
> + if (np == cp)
> + return (ESLICE);
> + /* we don't support nested partitions on GPT */
> + if (*cp != '\0' && *cp != ':')
> + return (EINVAL);
> + partition = 255;
> + } else
> #endif
> #ifdef LOADER_MBR_SUPPORT
> - disk_printmbr(dev, prefix, verbose);
> + if (*cp == 's') {
> + np = cp + 1;
> + slice = strtol(np, &cp, 10);
> + if (np == cp)
> + return (ESLICE);
> + }
> #endif
> + if (*cp != '\0' && *cp != ':') {
> + partition = *cp - 'a';
> + if (partition < 0)
> + return (EPART);
> + cp++;
> + }
> + } else
> + return (EINVAL);
> +
> + if (*cp != '\0' && *cp != ':')
> + return (EINVAL);
> + dev->d_unit = unit;
> + dev->d_slice = slice;
> + dev->d_partition = partition;
> + if (path != NULL)
> + *path = (*cp == '\0') ? cp: cp + 1;
> + return (0);
> }
>
> Modified: head/sys/boot/common/disk.h
> ==============================================================================
> --- head/sys/boot/common/disk.h Sun Aug 5 11:59:46 2012 (r239057)
> +++ head/sys/boot/common/disk.h Sun Aug 5 12:15:15 2012 (r239058)
> @@ -27,8 +27,7 @@
> */
>
> /*
> - * Device descriptor for partitioned disks. We assume that all disk addresses
>
> *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-all
mailing list