Disklabel separation work - Generally shift all disklabel-specific
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 17 Jun 2007 23:50:16 +0000 (23:50 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 17 Jun 2007 23:50:16 +0000 (23:50 +0000)
procedures for the kernel proper to a new source file, subr_disklabel32.c.
Move the DTYPE_ and FS_ defines out of sys/disklabel.h and into a new
header files sys/dtype.h

Make adjustments to the uuids file, renaming "DragonFly Label" to
"DragonFly Label32" and creating a "DragonFly Label64" uuid.

32 files changed:
etc/defaults/uuids
lib/libc/gen/disklabel.c
lib/libc/gen/disktab.c
sbin/diskinfo/diskinfo.c
sbin/disklabel/disklabel.c
sbin/gpt/add.c
sbin/gpt/gpt.c
sbin/gpt/migrate.c
sbin/vinum/list.c
sys/boot/efi/libefi/devicename.c
sys/boot/pc32/boot2/boot2.c
sys/boot/pc32/libi386/biosdisk.c
sys/dev/disk/ccd/ccd.c
sys/dev/disk/fd/fd.c
sys/dev/raid/aac/aac_disk.c
sys/dev/raid/amr/amr_disk.c
sys/dev/raid/ida/ida_disk.c
sys/dev/raid/ips/ips_disk.c
sys/dev/raid/mlx/mlx_disk.c
sys/dev/raid/twe/twe_freebsd.c
sys/dev/raid/vinum/vinumhdr.h
sys/kern/subr_disk.c
sys/kern/subr_disklabel32.c [new file with mode: 0644]
sys/kern/subr_disklabel64.c [new file with mode: 0644]
sys/kern/subr_diskslice.c
sys/kern/vfs_conf.c
sys/platform/pc32/i386/autoconf.c
sys/platform/vkernel/i386/autoconf.c
sys/sys/disk.h
sys/sys/disklabel.h
sys/sys/disklabel32.h
sys/sys/dtype.h [new file with mode: 0644]

index 965cfcc..a2e6d83 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/etc/defaults/uuids,v 1.1 2007/06/17 08:17:11 dillon Exp $
+# $DragonFly: src/etc/defaults/uuids,v 1.2 2007/06/17 23:50:11 dillon Exp $
 #
 #
 # EFI
@@ -9,11 +9,13 @@ c12a7328-f81f-11d2-ba4b-00a0c93ec93b  "EFI System"
 #
 # DragonFly
 #
-9d087404-1ca5-11dc-8817-01301bb8a9f5   "DragonFly Label"
+9d087404-1ca5-11dc-8817-01301bb8a9f5   "DragonFly Label32"
 9d58fdbd-1ca5-11dc-8817-01301bb8a9f5   "DragonFly Swap"
 9d94ce7c-1ca5-11dc-8817-01301bb8a9f5   "DragonFly UFS1"
 9dd4478f-1ca5-11dc-8817-01301bb8a9f5   "DragonFly Vinum"
 dbd5211b-1ca5-11dc-8817-01301bb8a9f5   "DragonFly CCD"
+3d48ce54-1d16-11dc-8696-01301bb8a9f5   "DragonFly Label64"
+bd215ab2-1d16-11dc-8696-01301bb8a9f5   "DragonFly Legacy"
 #
 # FreeBSD
 #
index 077732c..391e835 100644 (file)
  *
  * @(#)disklabel.c     8.2 (Berkeley) 5/3/95
  * $FreeBSD: src/lib/libc/gen/disklabel.c,v 1.9.2.1 2001/03/05 08:40:47 obrien Exp $
- * $DragonFly: src/lib/libc/gen/disklabel.c,v 1.11 2007/05/19 00:51:56 dillon Exp $
+ * $DragonFly: src/lib/libc/gen/disklabel.c,v 1.12 2007/06/17 23:50:13 dillon Exp $
  */
 
 #include <sys/param.h>
 #define DKTYPENAMES
 #include <sys/disklabel.h>
+#include <sys/dtype.h>
 #include <vfs/ufs/dinode.h>
 #include <vfs/ufs/fs.h>
 
index 5fefa09..00c4087 100644 (file)
@@ -64,7 +64,7 @@
  * SUCH DAMAGE.
  */
 /*
- * $DragonFly: src/lib/libc/gen/disktab.c,v 1.10 2007/05/17 23:50:00 dillon Exp $
+ * $DragonFly: src/lib/libc/gen/disktab.c,v 1.11 2007/06/17 23:50:13 dillon Exp $
  * @(#)disklabel.c     8.2 (Berkeley) 5/3/95
  * $FreeBSD: src/lib/libc/gen/disklabel.c,v 1.9.2.1 2001/03/05 08:40:47 obrien
  */
@@ -72,6 +72,7 @@
 #include <sys/param.h>
 #define DKTYPENAMES
 #include <sys/disklabel.h>
+#include <sys/dtype.h>
 #include <vfs/ufs/dinode.h>
 #include <vfs/ufs/fs.h>
 
index bd11c24..920f7e7 100644 (file)
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sbin/diskinfo/diskinfo.c,v 1.3 2007/06/17 03:51:12 dillon Exp $
+ * $DragonFly: src/sbin/diskinfo/diskinfo.c,v 1.4 2007/06/17 23:50:15 dillon Exp $
  */
 
 #define DKTYPENAMES
 #include <sys/types.h>
 #include <sys/fcntl.h>
-#include <sys/disklabel.h>
+#include <sys/dtype.h>
 #include <sys/diskslice.h>
 #include <stdio.h>
 #include <stdlib.h>
index 1c65911..e56a67c 100644 (file)
@@ -37,7 +37,7 @@
  * @(#)disklabel.c     1.2 (Symmetric) 11/28/85
  * @(#)disklabel.c      8.2 (Berkeley) 1/7/94
  * $FreeBSD: src/sbin/disklabel/disklabel.c,v 1.28.2.15 2003/01/24 16:18:16 des Exp $
- * $DragonFly: src/sbin/disklabel/disklabel.c,v 1.19 2007/06/17 03:51:13 dillon Exp $
+ * $DragonFly: src/sbin/disklabel/disklabel.c,v 1.20 2007/06/17 23:50:15 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -48,6 +48,7 @@
 #include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/diskmbr.h>
+#include <sys/dtype.h>
 #include <disktab.h>
 
 #include <vfs/ufs/dinode.h>
index 8aaa4d9..cc01ef2 100644 (file)
@@ -24,7 +24,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sbin/gpt/add.c,v 1.15 2006/10/04 18:20:25 marcel Exp $
- * $DragonFly: src/sbin/gpt/add.c,v 1.3 2007/06/17 08:34:59 dillon Exp $
+ * $DragonFly: src/sbin/gpt/add.c,v 1.4 2007/06/17 23:50:15 dillon Exp $
  */
 
 #include <sys/types.h>
@@ -196,11 +196,11 @@ cmd_add(int argc, char *argv[])
        if (argc == optind)
                usage_add();
 
-       /* Create UFS partitions by default. */
+       /* Create DragonFly 64 bit label partitions by default. */
        if (uuid_is_nil(&type, NULL)) {
                uint32_t status;
 
-               uuid_name_lookup(&type, "DragonFly Label", &status);
+               uuid_name_lookup(&type, "DragonFly Label64", &status);
                if (status != uuid_s_ok)
                        usage_add();
        }
index b2f5bc8..26fb20d 100644 (file)
@@ -26,7 +26,7 @@
  * CRC32 code derived from work by Gary S. Brown.
  *
  * $FreeBSD: src/sbin/gpt/gpt.c,v 1.16 2006/07/07 02:44:23 marcel Exp $
- * $DragonFly: src/sbin/gpt/gpt.c,v 1.3 2007/06/17 08:34:59 dillon Exp $
+ * $DragonFly: src/sbin/gpt/gpt.c,v 1.4 2007/06/17 23:50:15 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -272,7 +272,7 @@ parse_uuid(const char *s, uuid_t *uuid)
        switch (*s) {
        case 'd':
                if (strcmp(s, "dfly") == 0 || strcmp(s, "dragonfly") == 0) {
-                       s = "DragonFly Label";
+                       s = "DragonFly Label64";
                        /* fall through to lookup at end */
                }
                break;
index 456ca32..772ba71 100644 (file)
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sbin/gpt/migrate.c,v 1.16 2005/09/01 02:42:52 marcel Exp $
- * $DragonFly: src/sbin/gpt/migrate.c,v 1.1 2007/06/16 22:29:27 dillon Exp $
+ * $DragonFly: src/sbin/gpt/migrate.c,v 1.2 2007/06/17 23:50:15 dillon Exp $
  */
 
 #include <sys/types.h>
 #include <sys/disklabel.h>
+#include <sys/dtype.h>
 
 #include <err.h>
 #include <stddef.h>
index 2cd8820..1a12e07 100644 (file)
@@ -37,7 +37,7 @@
  *
  * $Id: list.c,v 1.25 2000/12/20 03:38:43 grog Exp grog $
  * $FreeBSD: src/sbin/vinum/list.c,v 1.25.2.4 2001/05/28 05:58:04 grog Exp $
- * $DragonFly: src/sbin/vinum/list.c,v 1.8 2007/06/07 22:57:49 corecode Exp $
+ * $DragonFly: src/sbin/vinum/list.c,v 1.9 2007/06/17 23:50:15 dillon Exp $
  */
 
 #define _KERNEL_STRUCTURES
@@ -55,6 +55,7 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/utsname.h>
+#include <sys/disklabel.h>
 #include <dev/raid/vinum/vinumhdr.h>
 #include "vext.h"
 #include <dev/raid/vinum/request.h>
index 7833282..504d41d 100644 (file)
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/boot/efi/libefi/devicename.c,v 1.2 2001/09/07 08:49:47 dfr Exp $
- * $DragonFly: src/sys/boot/efi/libefi/devicename.c,v 1.1 2003/11/10 06:08:33 dillon Exp $
+ * $DragonFly: src/sys/boot/efi/libefi/devicename.c,v 1.2 2007/06/17 23:50:15 dillon Exp $
  */
 
 #include <stand.h>
 #include <string.h>
-#include <sys/disklabel.h>
 #include "bootstrap.h"
 
 #include <efi.h>
index 9cd56fd..d727c17 100644 (file)
  * purpose.
  *
  * $FreeBSD: src/sys/boot/i386/boot2/boot2.c,v 1.64 2003/08/25 23:28:31 obrien Exp $
- * $DragonFly: src/sys/boot/pc32/boot2/boot2.c,v 1.14 2005/05/25 06:22:22 y0netan1 Exp $
+ * $DragonFly: src/sys/boot/pc32/boot2/boot2.c,v 1.15 2007/06/17 23:50:15 dillon Exp $
  */
 #include <sys/param.h>
 #include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/diskmbr.h>
+#include <sys/dtype.h>
 #include <sys/dirent.h>
 #include <machine/bootinfo.h>
 #include <machine/elf.h>
index 229e811..ff114fb 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/boot/i386/libi386/biosdisk.c,v 1.45 2004/09/21 06:46:44 wes Exp $
- * $DragonFly: src/sys/boot/pc32/libi386/biosdisk.c,v 1.10 2006/09/10 01:26:31 dillon Exp $
+ * $DragonFly: src/sys/boot/pc32/libi386/biosdisk.c,v 1.11 2007/06/17 23:50:15 dillon Exp $
  */
 
 /*
@@ -41,6 +41,7 @@
 
 #include <sys/disklabel.h>
 #include <sys/diskmbr.h>
+#include <sys/dtype.h>
 #include <machine/bootinfo.h>
 
 #include <stdarg.h>
index ce18d99..143fe63 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.45 2007/06/17 03:51:14 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.46 2007/06/17 23:50:15 dillon Exp $
  */
 /*
  * Copyright (c) 1995 Jason R. Thorpe.
  * @(#)cd.c    8.2 (Berkeley) 11/16/93
  * $FreeBSD: src/sys/dev/ccd/ccd.c,v 1.73.2.1 2001/09/11 09:49:52 kris Exp $
  * $NetBSD: ccd.c,v 1.22 1995/12/08 19:13:26 thorpej Exp $
- * $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.45 2007/06/17 03:51:14 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.46 2007/06/17 23:50:15 dillon Exp $
  */
 
 /*
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/disk.h>
+#include <sys/dtype.h>
 #include <sys/diskslice.h>
 #include <sys/devicestat.h>
 #include <sys/fcntl.h>
index 4600de9..0e5f471 100644 (file)
@@ -51,7 +51,7 @@
  *
  *     from:   @(#)fd.c        7.4 (Berkeley) 5/25/91
  * $FreeBSD: src/sys/isa/fd.c,v 1.176.2.8 2002/05/15 21:56:14 joerg Exp $
- * $DragonFly: src/sys/dev/disk/fd/fd.c,v 1.39 2007/05/21 04:22:23 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/fd/fd.c,v 1.40 2007/06/17 23:50:15 dillon Exp $
  *
  */
 
@@ -65,7 +65,6 @@
 #include <sys/buf.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
-#include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/disk.h>
 #include <sys/devicestat.h>
index ff542c4..5bc7507 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/aac/aac_disk.c,v 1.3.2.8 2003/01/11 18:39:39 scottl Exp $
- *     $DragonFly: src/sys/dev/raid/aac/aac_disk.c,v 1.17 2007/05/15 00:01:04 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/aac/aac_disk.c,v 1.18 2007/06/17 23:50:16 dillon Exp $
  */
 
 #include "opt_aac.h"
@@ -42,6 +42,7 @@
 #include <sys/conf.h>
 #include <sys/devicestat.h>
 #include <sys/disk.h>
+#include <sys/dtype.h>
 #include <sys/rman.h>
 
 #include <vm/vm.h>
index e62e9d1..0bf0fed 100644 (file)
@@ -54,7 +54,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/amr/amr_disk.c,v 1.5.2.5 2002/12/20 15:12:04 emoore Exp $
- * $DragonFly: src/sys/dev/raid/amr/amr_disk.c,v 1.14 2007/05/15 00:01:04 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/amr/amr_disk.c,v 1.15 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -70,6 +70,7 @@
 #include <sys/conf.h>
 #include <sys/devicestat.h>
 #include <sys/disk.h>
+#include <sys/dtype.h>
 #include <sys/rman.h>
 
 #include <vm/vm.h>
index 3a2fc20..ad74225 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ida/ida_disk.c,v 1.12.2.6 2001/11/27 20:21:02 ps Exp $
- * $DragonFly: src/sys/dev/raid/ida/ida_disk.c,v 1.15 2007/05/15 00:01:04 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/ida/ida_disk.c,v 1.16 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -42,6 +42,7 @@
 #include <sys/cons.h>
 #include <sys/devicestat.h>
 #include <sys/disk.h>
+#include <sys/dtype.h>
 #include <sys/rman.h>
 #include <sys/thread2.h>
 
index ae281c9..a870595 100644 (file)
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ips/ips_disk.c,v 1.4 2003/09/22 04:59:07 njl Exp $
- * $DragonFly: src/sys/dev/raid/ips/ips_disk.c,v 1.12 2007/05/15 00:01:04 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/ips/ips_disk.c,v 1.13 2007/06/17 23:50:16 dillon Exp $
  */
 
 #include <sys/devicestat.h>
 #include <dev/raid/ips/ips.h>
 #include <dev/raid/ips/ips_disk.h>
 #include <sys/stat.h>
+#include <sys/dtype.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
index ae801d8..b7d06ba 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/mlx/mlx_disk.c,v 1.8.2.4 2001/06/25 04:37:51 msmith Exp $
- * $DragonFly: src/sys/dev/raid/mlx/mlx_disk.c,v 1.12 2007/05/15 00:01:04 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/mlx/mlx_disk.c,v 1.13 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -39,6 +39,7 @@
 #include <sys/conf.h>
 #include <sys/devicestat.h>
 #include <sys/disk.h>
+#include <sys/dtype.h>
 #include <sys/rman.h>
 
 #include "mlx_compat.h"
index 19de76e..5380e91 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/twe/twe_freebsd.c,v 1.2.2.9 2004/06/11 18:57:31 vkashyap Exp $
- * $DragonFly: src/sys/dev/raid/twe/twe_freebsd.c,v 1.26 2007/05/15 00:01:04 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/twe/twe_freebsd.c,v 1.27 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -39,6 +39,7 @@
 #include <dev/raid/twe/twe_tables.h>
 #include <dev/raid/twe/tweio.h>
 #include <dev/raid/twe/twevar.h>
+#include <sys/dtype.h>
 
 static devclass_t      twe_devclass;
 
index 943fa78..ffb3d95 100644 (file)
@@ -38,7 +38,7 @@
 /*
  * $Id: vinumhdr.h,v 1.18 2001/01/04 00:14:14 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinumhdr.h,v 1.16.2.1 2001/03/13 02:59:43 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinumhdr.h,v 1.12 2007/05/16 05:20:21 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinumhdr.h,v 1.13 2007/06/17 23:50:16 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -60,8 +60,8 @@
 #include <sys/uio.h>
 #include <sys/namei.h>
 #include <sys/stat.h>
-#include <sys/disklabel.h>
 #include <sys/diskslice.h>
+#include <sys/dtype.h>
 #include <sys/syslog.h>
 #include <sys/fcntl.h>
 #include <sys/queue.h>
index 048b696..3321a91 100644 (file)
@@ -77,7 +77,7 @@
  *     @(#)ufs_disksubr.c      8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/subr_disk.c,v 1.20.2.6 2001/10/05 07:14:57 peter Exp $
  * $FreeBSD: src/sys/ufs/ufs/ufs_disksubr.c,v 1.44.2.3 2001/03/05 05:42:19 obrien Exp $
- * $DragonFly: src/sys/kern/subr_disk.c,v 1.36 2007/06/17 03:51:10 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_disk.c,v 1.37 2007/06/17 23:50:16 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -87,7 +87,6 @@
 #include <sys/sysctl.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
-#include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/disk.h>
 #include <sys/malloc.h>
@@ -602,164 +601,6 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
        TAILQ_INSERT_AFTER(&bioq->queue, bq, bio, bio_act);
 }
 
-
-/*
- * Attempt to read a disk label from a device using the indicated strategy
- * routine.  The label must be partly set up before this: secpercyl, secsize
- * and anything required in the strategy routine (e.g., dummy bounds for the
- * partition containing the label) must be filled in before calling us.
- * Returns NULL on success and an error string on failure.
- */
-char *
-readdisklabel(cdev_t dev, struct disklabel *lp)
-{
-       struct buf *bp;
-       struct disklabel *dlp;
-       char *msg = NULL;
-
-       bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
-       bp->b_bcount = lp->d_secsize;
-       bp->b_flags &= ~B_INVAL;
-       bp->b_cmd = BUF_CMD_READ;
-       dev_dstrategy(dev, &bp->b_bio1);
-       if (biowait(bp))
-               msg = "I/O error";
-       else for (dlp = (struct disklabel *)bp->b_data;
-           dlp <= (struct disklabel *)((char *)bp->b_data +
-           lp->d_secsize - sizeof(*dlp));
-           dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
-               if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
-                       if (msg == NULL)
-                               msg = "no disk label";
-               } else if (dlp->d_npartitions > MAXPARTITIONS ||
-                          dkcksum(dlp) != 0)
-                       msg = "disk label corrupted";
-               else {
-                       *lp = *dlp;
-                       msg = NULL;
-                       break;
-               }
-       }
-       bp->b_flags |= B_INVAL | B_AGE;
-       brelse(bp);
-       return (msg);
-}
-
-/*
- * Check new disk label for sensibility before setting it.
- */
-int
-setdisklabel(struct disklabel *olp, struct disklabel *nlp, u_int32_t *openmask)
-{
-       struct partition *opp, *npp;
-       int i;
-
-       /*
-        * Check it is actually a disklabel we are looking at.
-        */
-       if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
-           dkcksum(nlp) != 0)
-               return (EINVAL);
-
-       /*
-        * For each partition that we think is open, check the new disklabel
-        * for compatibility.  Ignore special partitions (>= 128).
-        */
-       i = 0;
-       while (i < 128) {
-               if (openmask[i >> 5] == 0) {
-                       i += 32;
-                       continue;
-               }
-               if ((openmask[i >> 5] & (1 << (i & 31))) == 0) {
-                       ++i;
-                       continue;
-               }
-               if (nlp->d_npartitions <= i)
-                       return (EBUSY);
-               opp = &olp->d_partitions[i];
-               npp = &nlp->d_partitions[i];
-               if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
-                       return (EBUSY);
-               /*
-                * Copy internally-set partition information
-                * if new label doesn't include it.             XXX
-                * (If we are using it then we had better stay the same type)
-                * This is possibly dubious, as someone else noted (XXX)
-                */
-               if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
-                       npp->p_fstype = opp->p_fstype;
-                       npp->p_fsize = opp->p_fsize;
-                       npp->p_frag = opp->p_frag;
-                       npp->p_cpg = opp->p_cpg;
-               }
-               ++i;
-       }
-       nlp->d_checksum = 0;
-       nlp->d_checksum = dkcksum(nlp);
-       *olp = *nlp;
-       return (0);
-}
-
-/*
- * Write disk label back to device after modification.
- */
-int
-writedisklabel(cdev_t dev, struct disklabel *lp)
-{
-       struct buf *bp;
-       struct disklabel *dlp;
-       int error = 0;
-
-       if (lp->d_partitions[RAW_PART].p_offset != 0)
-               return (EXDEV);                 /* not quite right */
-       bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
-       bp->b_bcount = lp->d_secsize;
-#if 1
-       /*
-        * We read the label first to see if it's there,
-        * in which case we will put ours at the same offset into the block..
-        * (I think this is stupid [Julian])
-        * Note that you can't write a label out over a corrupted label!
-        * (also stupid.. how do you write the first one? by raw writes?)
-        */
-       bp->b_flags &= ~B_INVAL;
-       bp->b_cmd = BUF_CMD_READ;
-       dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART), &bp->b_bio1);
-       error = biowait(bp);
-       if (error)
-               goto done;
-       for (dlp = (struct disklabel *)bp->b_data;
-           dlp <= (struct disklabel *)
-             ((char *)bp->b_data + lp->d_secsize - sizeof(*dlp));
-           dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
-               if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
-                   dkcksum(dlp) == 0) {
-                       *dlp = *lp;
-                       bp->b_cmd = BUF_CMD_WRITE;
-                       dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART), &bp->b_bio1);
-                       error = biowait(bp);
-                       goto done;
-               }
-       }
-       error = ESRCH;
-done:
-#else
-       bzero(bp->b_data, lp->d_secsize);
-       dlp = (struct disklabel *)bp->b_data;
-       *dlp = *lp;
-       bp->b_flags &= ~B_INVAL;
-       bp->b_cmd = BUF_CMD_WRITE;
-       BUF_STRATEGY(bp, 1);
-       error = biowait(bp);
-#endif
-       bp->b_flags |= B_INVAL | B_AGE;
-       brelse(bp);
-       return (error);
-}
-
 /*
  * Disk error is the preface to plaintive error messages
  * about failing disk transfers.  It prints messages of the form
diff --git a/sys/kern/subr_disklabel32.c b/sys/kern/subr_disklabel32.c
new file mode 100644 (file)
index 0000000..6ece8d9
--- /dev/null
@@ -0,0 +1,589 @@
+/*
+ * Copyright (c) 2003-2007 The DragonFly Project.  All rights reserved.
+ * 
+ * This code is derived from software contributed to The DragonFly Project
+ * by Matthew Dillon <dillon@backplane.com>
+ * 
+ * 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.
+ * 3. Neither the name of The DragonFly Project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific, prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``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
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS 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.
+ * 
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * Copyright (c) 1982, 1986, 1988, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Copyright (c) 1994 Bruce D. Evans.
+ * All rights reserved.
+ *
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
+ *
+ *     @(#)ufs_disksubr.c      8.5 (Berkeley) 1/21/94
+ * $FreeBSD: src/sys/kern/subr_disk.c,v 1.20.2.6 2001/10/05 07:14:57 peter Exp $
+ * $FreeBSD: src/sys/ufs/ufs/ufs_disksubr.c,v 1.44.2.3 2001/03/05 05:42:19 obrien Exp $
+ * $DragonFly: src/sys/kern/subr_disklabel32.c,v 1.1 2007/06/17 23:50:16 dillon Exp $
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/sysctl.h>
+#include <sys/buf.h>
+#include <sys/conf.h>
+#include <sys/disklabel.h>
+#include <sys/diskslice.h>
+#include <sys/disk.h>
+#include <sys/dtype.h>         /* DTYPE_* constants */
+#include <sys/sysctl.h>
+#include <machine/md_var.h>
+#include <sys/ctype.h>
+#include <sys/syslog.h>
+#include <sys/device.h>
+#include <sys/msgport.h>
+#include <sys/msgport2.h>
+#include <sys/buf2.h>
+
+#include <vfs/ufs/dinode.h>    /* XXX used only for fs.h */
+#include <vfs/ufs/fs.h>                /* XXX used only to get BBSIZE/SBSIZE */
+
+static void partition_info(const char *sname, int part, struct partition *pp);
+static void slice_info(const char *sname, struct diskslice *sp);
+
+/*
+ * Retrieve the partition start and extent, in blocks.  Return 0 on success,
+ * EINVAL on error.
+ */
+int
+getpartbounds(struct disklabel *lp, u_int32_t part,
+             u_int64_t *start, u_int64_t *blocks)
+{
+       struct partition *pp;
+
+       if (part >= lp->d_npartitions)
+               return (EINVAL);
+       pp = &lp->d_partitions[part];
+       *blocks = pp->p_size;
+       *start = pp->p_offset;
+       return(0);
+}
+
+int
+getpartfstype(struct disklabel *lp, u_int32_t part)
+{
+       struct partition *pp;
+
+       if (part >= lp->d_npartitions)
+               return (0);
+       pp = &lp->d_partitions[part];
+       return(pp->p_fstype);
+}
+
+u_int32_t
+getnumparts(struct disklabel *lp)
+{
+       return(lp->d_npartitions);
+}
+
+/*
+ * Attempt to read a disk label from a device using the indicated strategy
+ * routine.  The label must be partly set up before this: secpercyl, secsize
+ * and anything required in the strategy routine (e.g., dummy bounds for the
+ * partition containing the label) must be filled in before calling us.
+ * Returns NULL on success and an error string on failure.
+ */
+char *
+readdisklabel(cdev_t dev, struct disklabel *lp)
+{
+       struct buf *bp;
+       struct disklabel *dlp;
+       char *msg = NULL;
+
+       bp = geteblk((int)lp->d_secsize);
+       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
+       bp->b_bcount = lp->d_secsize;
+       bp->b_flags &= ~B_INVAL;
+       bp->b_cmd = BUF_CMD_READ;
+       dev_dstrategy(dev, &bp->b_bio1);
+       if (biowait(bp))
+               msg = "I/O error";
+       else for (dlp = (struct disklabel *)bp->b_data;
+           dlp <= (struct disklabel *)((char *)bp->b_data +
+           lp->d_secsize - sizeof(*dlp));
+           dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
+               if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
+                       if (msg == NULL)
+                               msg = "no disk label";
+               } else if (dlp->d_npartitions > MAXPARTITIONS ||
+                          dkcksum(dlp) != 0)
+                       msg = "disk label corrupted";
+               else {
+                       *lp = *dlp;
+                       msg = NULL;
+                       break;
+               }
+       }
+       bp->b_flags |= B_INVAL | B_AGE;
+       brelse(bp);
+       return (msg);
+}
+
+/*
+ * Check new disk label for sensibility before setting it.
+ */
+int
+setdisklabel(struct disklabel *olp, struct disklabel *nlp,
+            struct diskslice *sp, u_int32_t *openmask)
+{
+       struct partition *opp, *npp;
+       int part;
+       int i;
+
+       /*
+        * Check it is actually a disklabel we are looking at.
+        */
+       if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
+           dkcksum(nlp) != 0)
+               return (EINVAL);
+
+       /*
+        * For each partition that we think is open, check the new disklabel
+        * for compatibility.  Ignore special partitions (>= 128).
+        */
+       i = 0;
+       while (i < 128) {
+               if (openmask[i >> 5] == 0) {
+                       i += 32;
+                       continue;
+               }
+               if ((openmask[i >> 5] & (1 << (i & 31))) == 0) {
+                       ++i;
+                       continue;
+               }
+               if (nlp->d_npartitions <= i)
+                       return (EBUSY);
+               opp = &olp->d_partitions[i];
+               npp = &nlp->d_partitions[i];
+               if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
+                       return (EBUSY);
+               /*
+                * Copy internally-set partition information
+                * if new label doesn't include it.             XXX
+                * (If we are using it then we had better stay the same type)
+                * This is possibly dubious, as someone else noted (XXX)
+                */
+               if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
+                       npp->p_fstype = opp->p_fstype;
+                       npp->p_fsize = opp->p_fsize;
+                       npp->p_frag = opp->p_frag;
+                       npp->p_cpg = opp->p_cpg;
+               }
+               ++i;
+       }
+       nlp->d_checksum = 0;
+       nlp->d_checksum = dkcksum(nlp);
+       *olp = *nlp;
+
+       if (olp->d_partitions[RAW_PART].p_offset)
+               return (EXDEV);
+       if (olp->d_secperunit > sp->ds_size)
+               return (ENOSPC);
+       for (part = 0; part < olp->d_npartitions; ++part) {
+               if (olp->d_partitions[part].p_size > sp->ds_size)
+                       return(ENOSPC);
+       }
+       return (0);
+}
+
+/*
+ * Write disk label back to device after modification.
+ */
+int
+writedisklabel(cdev_t dev, struct disklabel *lp)
+{
+       struct buf *bp;
+       struct disklabel *dlp;
+       int error = 0;
+
+       if (lp->d_partitions[RAW_PART].p_offset != 0)
+               return (EXDEV);                 /* not quite right */
+       bp = geteblk((int)lp->d_secsize);
+       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
+       bp->b_bcount = lp->d_secsize;
+#if 1
+       /*
+        * We read the label first to see if it's there,
+        * in which case we will put ours at the same offset into the block..
+        * (I think this is stupid [Julian])
+        * Note that you can't write a label out over a corrupted label!
+        * (also stupid.. how do you write the first one? by raw writes?)
+        */
+       bp->b_flags &= ~B_INVAL;
+       bp->b_cmd = BUF_CMD_READ;
+       dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART), &bp->b_bio1);
+       error = biowait(bp);
+       if (error)
+               goto done;
+       for (dlp = (struct disklabel *)bp->b_data;
+           dlp <= (struct disklabel *)
+             ((char *)bp->b_data + lp->d_secsize - sizeof(*dlp));
+           dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
+               if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
+                   dkcksum(dlp) == 0) {
+                       *dlp = *lp;
+                       bp->b_cmd = BUF_CMD_WRITE;
+                       dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART), &bp->b_bio1);
+                       error = biowait(bp);
+                       goto done;
+               }
+       }
+       error = ESRCH;
+done:
+#else
+       bzero(bp->b_data, lp->d_secsize);
+       dlp = (struct disklabel *)bp->b_data;
+       *dlp = *lp;
+       bp->b_flags &= ~B_INVAL;
+       bp->b_cmd = BUF_CMD_WRITE;
+       BUF_STRATEGY(bp, 1);
+       error = biowait(bp);
+#endif
+       bp->b_flags |= B_INVAL | B_AGE;
+       brelse(bp);
+       return (error);
+}
+
+/*
+ * Create a disklabel based on a disk_info structure, initializing
+ * the appropriate fields and creating a raw partition that covers the
+ * whole disk.
+ *
+ * If a diskslice is passed, the label is truncated to the slice
+ */
+struct disklabel *
+clone_label(struct disk_info *info, struct diskslice *sp)
+{
+       struct disklabel *lp1;
+
+       lp1 = kmalloc(sizeof *lp1, M_DEVBUF, M_WAITOK | M_ZERO);
+       lp1->d_nsectors = info->d_secpertrack;
+       lp1->d_ntracks = info->d_nheads;
+       lp1->d_secpercyl = info->d_secpercyl;
+       lp1->d_secsize = info->d_media_blksize;
+
+       if (sp)
+               lp1->d_secperunit = (u_int)sp->ds_size;
+       else
+               lp1->d_secperunit = (u_int)info->d_media_blocks;
+
+       if (lp1->d_typename[0] == '\0')
+               strncpy(lp1->d_typename, "amnesiac", sizeof(lp1->d_typename));
+       if (lp1->d_packname[0] == '\0')
+               strncpy(lp1->d_packname, "fictitious", sizeof(lp1->d_packname));
+       if (lp1->d_nsectors == 0)
+               lp1->d_nsectors = 32;
+       if (lp1->d_ntracks == 0)
+               lp1->d_ntracks = 64;
+       lp1->d_secpercyl = lp1->d_nsectors * lp1->d_ntracks;
+       lp1->d_ncylinders = lp1->d_secperunit / lp1->d_secpercyl;
+       if (lp1->d_rpm == 0)
+               lp1->d_rpm = 3600;
+       if (lp1->d_interleave == 0)
+               lp1->d_interleave = 1;
+       if (lp1->d_npartitions < RAW_PART + 1)
+               lp1->d_npartitions = MAXPARTITIONS;
+       if (lp1->d_bbsize == 0)
+               lp1->d_bbsize = BBSIZE;
+       if (lp1->d_sbsize == 0)
+               lp1->d_sbsize = SBSIZE;
+
+       /*
+        * Used by various devices to create a compatibility slice which
+        * allows us to mount root from devices which do not have a
+        * disklabel.  Particularly: CDs.
+        */
+       lp1->d_partitions[RAW_PART].p_size = lp1->d_secperunit;
+       if (info->d_dsflags & DSO_COMPATPARTA) {
+               lp1->d_partitions[0].p_size = lp1->d_secperunit;
+               lp1->d_partitions[0].p_fstype = FS_OTHER;
+       }
+       lp1->d_magic = DISKMAGIC;
+       lp1->d_magic2 = DISKMAGIC;
+       lp1->d_checksum = dkcksum(lp1);
+       return (lp1);
+}
+
+void
+makevirginlabel(struct disklabel *lp, struct diskslices *ssp,
+               struct diskslice *sp, struct disk_info *info)
+{
+       struct partition *pp;
+
+       if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label) {
+               bcopy(ssp->dss_slices[WHOLE_DISK_SLICE].ds_label, lp,
+                     sizeof(*lp));
+       } else {
+               bzero(lp, sizeof(*lp));
+       }
+       lp->d_magic = DISKMAGIC;
+       lp->d_magic2 = DISKMAGIC;
+
+       lp->d_npartitions = MAXPARTITIONS;
+       if (lp->d_interleave == 0)
+               lp->d_interleave = 1;
+       if (lp->d_rpm == 0)
+               lp->d_rpm = 3600;
+       if (lp->d_nsectors == 0)        /* sectors per track */
+               lp->d_nsectors = 32;
+       if (lp->d_ntracks == 0)         /* heads */
+               lp->d_ntracks = 64;
+       lp->d_ncylinders = 0;
+       lp->d_bbsize = BBSIZE;
+       lp->d_sbsize = SBSIZE;
+
+       /*
+        * If the slice or GPT partition is really small we could
+        * wind up with an absurd calculation for ncylinders.
+        */
+       while (lp->d_ncylinders < 4) {
+               if (lp->d_ntracks > 1)
+                       lp->d_ntracks >>= 1;
+               else if (lp->d_nsectors > 1)
+                       lp->d_nsectors >>= 1;
+               else
+                       break;
+               lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
+               lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
+       }
+
+       /*
+        * Set or Modify the partition sizes to accomodate the slice,
+        * since we started with a copy of the virgin label stored
+        * in the whole-disk-slice and we are probably not a
+        * whole-disk slice.
+        */
+       lp->d_secperunit = sp->ds_size;
+       pp = &lp->d_partitions[RAW_PART];
+       pp->p_offset = 0;
+       pp->p_size = lp->d_secperunit;
+       if (info->d_dsflags & DSO_COMPATPARTA) {
+               pp = &lp->d_partitions[0];
+               pp->p_offset = 0;
+               pp->p_size = lp->d_secperunit;
+               pp->p_fstype = FS_OTHER;
+       }
+       lp->d_checksum = 0;
+       lp->d_checksum = dkcksum(lp);
+}
+
+char *
+fixlabel(const char *sname, struct diskslice *sp, struct disklabel *lp, int writeflag)
+{
+       u_int64_t start;
+       u_int64_t end;
+       u_int64_t offset;
+       int part;
+       struct partition *pp;
+       int warned;
+
+       /* These errors "can't happen" so don't bother reporting details. */
+       if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
+               return ("fixlabel: invalid magic");
+       if (dkcksum(lp) != 0)
+               return ("fixlabel: invalid checksum");
+
+       pp = &lp->d_partitions[RAW_PART];
+
+       /*
+        * What a mess.  For ages old backwards compatibility the disklabel
+        * on-disk stores absolute offsets instead of slice-relative offsets.
+        * So fix it up when reading, writing, or snooping.
+        *
+        * The in-core label is always slice-relative.
+        */
+       if (writeflag) {
+               start = 0;
+               offset = sp->ds_offset;
+       } else {
+               start = sp->ds_offset;
+               offset = -sp->ds_offset;
+       }
+       if (pp->p_offset != start) {
+               if (sname != NULL) {
+                       kprintf(
+"%s: rejecting BSD label: raw partition offset != slice offset\n",
+                              sname);
+                       slice_info(sname, sp);
+                       partition_info(sname, RAW_PART, pp);
+               }
+               return ("fixlabel: raw partition offset != slice offset");
+       }
+       if (pp->p_size != sp->ds_size) {
+               if (sname != NULL) {
+                       kprintf("%s: raw partition size != slice size\n", sname);
+                       slice_info(sname, sp);
+                       partition_info(sname, RAW_PART, pp);
+               }
+               if (pp->p_size > sp->ds_size) {
+                       if (sname == NULL)
+                               return ("fixlabel: raw partition size > slice size");
+                       kprintf("%s: truncating raw partition\n", sname);
+                       pp->p_size = sp->ds_size;
+               }
+       }
+       end = start + sp->ds_size;
+       if (start > end)
+               return ("fixlabel: slice wraps");
+       if (lp->d_secpercyl <= 0)
+               return ("fixlabel: d_secpercyl <= 0");
+       pp -= RAW_PART;
+       warned = FALSE;
+       for (part = 0; part < lp->d_npartitions; part++, pp++) {
+               if (pp->p_offset != 0 || pp->p_size != 0) {
+                       if (pp->p_offset < start
+                           || pp->p_offset + pp->p_size > end
+                           || pp->p_offset + pp->p_size < pp->p_offset) {
+                               if (sname != NULL) {
+                                       kprintf(
+"%s: rejecting partition in BSD label: it isn't entirely within the slice\n",
+                                              sname);
+                                       if (!warned) {
+                                               slice_info(sname, sp);
+                                               warned = TRUE;
+                                       }
+                                       partition_info(sname, part, pp);
+                               }
+                               /* XXX else silently discard junk. */
+                               bzero(pp, sizeof *pp);
+                       } else {
+                               pp->p_offset += offset;
+                       }
+               }
+       }
+       lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
+       lp->d_secperunit = sp->ds_size;
+       lp->d_checksum = 0;
+       lp->d_checksum = dkcksum(lp);
+       return (NULL);
+}
+
+void
+adjust_label_reserved(struct diskslices *ssp, int slice, struct diskslice *sp)
+{
+       struct disklabel *lp = sp->ds_label;
+
+       /*
+        * If the slice is not the whole-disk slice, setup the reserved
+        * area(s).
+        *
+        * The reserved area for the original bsd disklabel, inclusive of
+        * the label and space for boot2, is 15 sectors.  If you've
+        * noticed people traditionally skipping 16 sectors its because
+        * the sector numbers start at the beginning of the slice rather
+        * then the beginning of the disklabel and traditional dos slices
+        * reserve a sector at the beginning for the boot code.
+        *
+        * NOTE! With the traditional bsdlabel, the first N bytes of boot2
+        * overlap with the disklabel.  The disklabel program checks that
+        * they are 0.
+        *
+        * When clearing a label, the bsdlabel reserved area is reset.
+        */
+       if (slice != WHOLE_DISK_SLICE) {
+               if (lp) {
+                       /*
+                        * BSD uses in-band labels, meaning the label itself
+                        * is accessible from partitions within the label.
+                        * We must reserved the area taken up by the label
+                        * itself to prevent mistakes from wiping it.
+                        */
+                       sp->ds_reserved = SBSIZE / ssp->dss_secsize;
+               } else {
+                       sp->ds_reserved = 0;
+               }
+       }
+}
+
+static void
+partition_info(const char *sname, int part, struct partition *pp)
+{
+       kprintf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,
+               (u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),
+               (u_long)pp->p_size);
+}
+
+static void
+slice_info(const char *sname, struct diskslice *sp)
+{
+       kprintf("%s: start %llu, end %llu, size %llu\n", sname,
+              sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
+}
+
diff --git a/sys/kern/subr_disklabel64.c b/sys/kern/subr_disklabel64.c
new file mode 100644 (file)
index 0000000..71f10ab
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
+ * 
+ * This code is derived from software contributed to The DragonFly Project
+ * by Matthew Dillon <dillon@backplane.com>
+ * 
+ * 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.
+ * 3. Neither the name of The DragonFly Project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific, prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``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
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS 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.
+ * 
+ * $DragonFly: src/sys/kern/subr_disklabel64.c,v 1.1 2007/06/17 23:50:16 dillon Exp $
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/conf.h>
+#include <sys/disklabel.h>
+#include <sys/diskslice.h>
+#include <sys/disk.h>
+#include <sys/buf2.h>
+
index 55beb12..42c61d9 100644 (file)
@@ -44,7 +44,7 @@
  *     from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
  *     from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
  * $FreeBSD: src/sys/kern/subr_diskslice.c,v 1.82.2.6 2001/07/24 09:49:41 dd Exp $
- * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.44 2007/06/17 09:56:19 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.45 2007/06/17 23:50:16 dillon Exp $
  */
 
 #include <sys/param.h>
 #include <vfs/ufs/dinode.h>    /* XXX used only for fs.h */
 #include <vfs/ufs/fs.h>                /* XXX used only to get BBSIZE/SBSIZE */
 
-#define TRACE(str)     do { if (ds_debug) kprintf str; } while (0)
-
-typedef        u_char  bool_t;
-
-static volatile bool_t ds_debug;
-
-static struct disklabel *clone_label (struct disk_info *info,
-                                       struct diskslice *sp);
 static void dsiodone (struct bio *bio);
-static char *fixlabel (const char *sname, struct diskslice *sp,
-                          struct disklabel *lp, int writeflag);
 static int  dsreadandsetlabel(cdev_t dev, u_int flags,
                           struct diskslices *ssp, struct diskslice *sp,
                           struct disk_info *info);
 static void free_ds_label (struct diskslices *ssp, int slice);
-static void partition_info (const char *sname, int part, struct partition *pp);
-static void slice_info (const char *sname, struct diskslice *sp);
 static void set_ds_label (struct diskslices *ssp, int slice,
                              struct disklabel *lp);
 static void set_ds_wlabel (struct diskslices *ssp, int slice, int wlabel);
 
-/*
- * Create a disklabel based on a disk_info structure, initializing
- * the appropriate fields and creating a raw partition that covers the
- * whole disk.
- *
- * If a diskslice is passed, the label is truncated to the slice
- */
-static struct disklabel *
-clone_label(struct disk_info *info, struct diskslice *sp)
-{
-       struct disklabel *lp1;
-
-       lp1 = kmalloc(sizeof *lp1, M_DEVBUF, M_WAITOK | M_ZERO);
-       lp1->d_nsectors = info->d_secpertrack;
-       lp1->d_ntracks = info->d_nheads;
-       lp1->d_secpercyl = info->d_secpercyl;
-       lp1->d_secsize = info->d_media_blksize;
-
-       if (sp)
-               lp1->d_secperunit = (u_int)sp->ds_size;
-       else
-               lp1->d_secperunit = (u_int)info->d_media_blocks;
-
-       if (lp1->d_typename[0] == '\0')
-               strncpy(lp1->d_typename, "amnesiac", sizeof(lp1->d_typename));
-       if (lp1->d_packname[0] == '\0')
-               strncpy(lp1->d_packname, "fictitious", sizeof(lp1->d_packname));
-       if (lp1->d_nsectors == 0)
-               lp1->d_nsectors = 32;
-       if (lp1->d_ntracks == 0)
-               lp1->d_ntracks = 64;
-       lp1->d_secpercyl = lp1->d_nsectors * lp1->d_ntracks;
-       lp1->d_ncylinders = lp1->d_secperunit / lp1->d_secpercyl;
-       if (lp1->d_rpm == 0)
-               lp1->d_rpm = 3600;
-       if (lp1->d_interleave == 0)
-               lp1->d_interleave = 1;
-       if (lp1->d_npartitions < RAW_PART + 1)
-               lp1->d_npartitions = MAXPARTITIONS;
-       if (lp1->d_bbsize == 0)
-               lp1->d_bbsize = BBSIZE;
-       if (lp1->d_sbsize == 0)
-               lp1->d_sbsize = SBSIZE;
-
-       /*
-        * Used by various devices to create a compatibility slice which
-        * allows us to mount root from devices which do not have a
-        * disklabel.  Particularly: CDs.
-        */
-       lp1->d_partitions[RAW_PART].p_size = lp1->d_secperunit;
-       if (info->d_dsflags & DSO_COMPATPARTA) {
-               lp1->d_partitions[0].p_size = lp1->d_secperunit;
-               lp1->d_partitions[0].p_fstype = FS_OTHER;
-       }
-       lp1->d_magic = DISKMAGIC;
-       lp1->d_magic2 = DISKMAGIC;
-       lp1->d_checksum = dkcksum(lp1);
-       return (lp1);
-}
-
 /*
  * Determine the size of the transfer, and make sure it is
  * within the boundaries of the partition. Adjust transfer
@@ -277,28 +205,19 @@ doshift:
                endsecno = sp->ds_size;
                slicerel_secno = secno;
                snoop = 1;
-       } else if ((lp = sp->ds_label) && part < lp->d_npartitions) {
+       } else if ((lp = sp->ds_label) != NULL) {
                /*
-                * A disklabel is present and a partition is explicitly being
-                * accessed (verses a whole-slice).  Snooping of the
-                * partition is not supported even if the disklabel is
-                * accessible.  Of course, the reserved area is still
-                * write protected.
+                * A label is present, extract the partition.  Snooping of
+                * the disklabel is not supported even if accessible.  Of
+                * course, the reserved area is still write protected.
                 */
-               struct partition *pp;
-
-               pp = &lp->d_partitions[dkpart(dev)];
-               endsecno = pp->p_size;
-               slicerel_secno = pp->p_offset + secno;
+               if (getpartbounds(lp, part, &slicerel_secno, &endsecno)) {
+                       kprintf("dscheck(%s): partition %d out of bounds\n",
+                               devtoname(dev), part);
+                       goto bad;
+               }
+               slicerel_secno += secno;
                snoop = 0;
-       } else if (lp) {
-               /*
-                * Partition out of bounds
-                */
-               kprintf("dscheck(%s): partition out of bounds %d/%d\n",
-                       devtoname(dev),
-                       part, lp->d_npartitions);
-               goto bad;
        } else {
                /*
                 * Attempt to access partition when no disklabel present
@@ -475,7 +394,6 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
        int slice;
        struct diskslice *sp;
        struct diskslices *ssp;
-       struct partition *pp;
 
        slice = dkslice(dev);
        part = dkpart(dev);
@@ -497,60 +415,7 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                }
 
                lp = (struct disklabel *)data;
-               if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label) {
-                       *lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
-               } else {
-                       bzero(lp, sizeof(struct disklabel));
-               }
-               lp->d_magic = DISKMAGIC;
-               lp->d_magic2 = DISKMAGIC;
-
-               lp->d_npartitions = MAXPARTITIONS;
-               if (lp->d_interleave == 0)
-                       lp->d_interleave = 1;
-               if (lp->d_rpm == 0)
-                       lp->d_rpm = 3600;
-               if (lp->d_nsectors == 0)        /* sectors per track */
-                       lp->d_nsectors = 32;
-               if (lp->d_ntracks == 0)         /* heads */
-                       lp->d_ntracks = 64;
-               lp->d_ncylinders = 0;
-               lp->d_bbsize = BBSIZE;
-               lp->d_sbsize = SBSIZE;
-
-               /*
-                * If the slice or GPT partition is really small we could
-                * wind up with an absurd calculation for ncylinders.
-                */
-               while (lp->d_ncylinders < 4) {
-                       if (lp->d_ntracks > 1)
-                               lp->d_ntracks >>= 1;
-                       else if (lp->d_nsectors > 1)
-                               lp->d_nsectors >>= 1;
-                       else
-                               break;
-                       lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
-                       lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
-               }
-
-               /*
-                * Set or Modify the partition sizes to accomodate the slice,
-                * since we started with a copy of the virgin label stored
-                * in the whole-disk-slice and we are probably not a
-                * whole-disk slice.
-                */
-               lp->d_secperunit = sp->ds_size;
-               pp = &lp->d_partitions[RAW_PART];
-               pp->p_offset = 0;
-               pp->p_size = lp->d_secperunit;
-               if (info->d_dsflags & DSO_COMPATPARTA) {
-                       pp = &lp->d_partitions[0];
-                       pp->p_offset = 0;
-                       pp->p_size = lp->d_secperunit;
-                       pp->p_fstype = FS_OTHER;
-               }
-               lp->d_checksum = 0;
-               lp->d_checksum = dkcksum(lp);
+               makevirginlabel(lp, ssp, sp, info);
                return (0);
 
        case DIOCGDINFO:
@@ -608,26 +473,26 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
 
                        if (slice != WHOLE_DISK_SLICE &&
                            part != WHOLE_SLICE_PART) {
-                               struct partition *p;
-
-                               if (lp == NULL || part >= lp->d_npartitions)
+                               u_int64_t start;
+                               u_int64_t blocks;
+                               if (lp == NULL)
                                        return(EINVAL);
-
-                               p = &lp->d_partitions[part];
-                               dpart->fstype = p->p_fstype;
-                               dpart->media_offset += (u_int64_t)p->p_offset *
+                               if (getpartbounds(lp, part, &start, &blocks))
+                                       return(EINVAL);
+                               dpart->fstype = getpartfstype(lp, part);
+                               dpart->media_offset += start *
                                                       info->d_media_blksize;
-                               dpart->media_size = (u_int64_t)p->p_size *
+                               dpart->media_size = blocks *
                                                    info->d_media_blksize;
-                               dpart->media_blocks = (u_int64_t)p->p_size;
+                               dpart->media_blocks = blocks;
 
                                /*
                                 * partition starting sector (p_offset)
                                 * requires slice's reserved areas to be
                                 * adjusted.
                                 */
-                               if (dpart->reserved_blocks > p->p_offset)
-                                       dpart->reserved_blocks -= p->p_offset;
+                               if (dpart->reserved_blocks > start)
+                                       dpart->reserved_blocks -= start;
                                else
                                        dpart->reserved_blocks = 0;
                        }
@@ -676,30 +541,9 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                        bzero(openmask, sizeof(openmask));
                } else {
                        bcopy(sp->ds_openmask, openmask, sizeof(openmask));
-#if 0
-                       /* no longer supported, s0 is a real slice for GPT */
-                       if (slice == COMPATIBILITY_SLICE) {
-                               dssetmaskfrommask(&ssp->dss_slices[
-                                                 ssp->dss_first_bsd_slice],
-                                                 openmask);
-                       } else if (slice == ssp->dss_first_bsd_slice) {
-                               dssetmaskfrommask(&ssp->dss_slices[
-                                                 COMPATIBILITY_SLICE],
-                                                 openmask);
-                       }
-#endif
-               }
-               error = setdisklabel(lp, (struct disklabel *)data, openmask);
-               /* XXX why doesn't setdisklabel() check this? */
-               if (error == 0 && lp->d_partitions[RAW_PART].p_offset != 0)
-                       error = EXDEV;
-               if (error == 0) {
-                       if (lp->d_secperunit > sp->ds_size)
-                               error = ENOSPC;
-                       for (part = 0; part < lp->d_npartitions; part++)
-                               if (lp->d_partitions[part].p_size > sp->ds_size)
-                                       error = ENOSPC;
                }
+               error = setdisklabel(lp, (struct disklabel *)data,
+                                    sp, openmask);
                if (error != 0) {
                        kfree(lp, M_DEVBUF);
                        return (error);
@@ -849,7 +693,6 @@ int
 dsisopen(struct diskslices *ssp)
 {
        int slice;
-       int j;
 
        if (ssp == NULL)
                return (0);
@@ -964,7 +807,7 @@ dsopen(cdev_t dev, int mode, u_int flags,
 {
        cdev_t dev1;
        int error;
-       bool_t need_init;
+       int need_init;
        struct diskslice *sp;
        struct diskslices *ssp;
        int slice;
@@ -1004,7 +847,6 @@ dsopen(cdev_t dev, int mode, u_int flags,
                *sspp = dsmakeslicestruct(BASE_SLICE, info);
 
                if ((flags & DSO_ONESLICE) == 0) {
-                       TRACE(("mbrinit\n"));
                        error = mbrinit(dev, info, sspp);
                        if (error != 0) {
                                dsgone(sspp);
@@ -1111,7 +953,7 @@ dsopen(cdev_t dev, int mode, u_int flags,
         * table need exist.
         */
        if (part != WHOLE_SLICE_PART && slice != WHOLE_DISK_SLICE) {
-               if (sp->ds_label == NULL || part >= sp->ds_label->d_npartitions)
+               if (sp->ds_label == NULL || part >= getnumparts(sp->ds_label))
                        return (EINVAL);
        }
        dssetmask(sp, part);
@@ -1162,8 +1004,6 @@ dsreadandsetlabel(cdev_t dev, u_int flags,
        }
        if (msg == NULL)
                msg = fixlabel(sname, sp, lp1, FALSE);
-       if (msg == NULL && lp1->d_secsize != info->d_media_blksize)
-               msg = "inconsistent sector size";
        if (msg != NULL) {
                if (sp->ds_type == DOSPTYP_386BSD /* XXX */)
                        log(LOG_WARNING, "%s: cannot find label (%s)\n",
@@ -1183,6 +1023,8 @@ dssize(cdev_t dev, struct diskslices **sspp)
        int part;
        int slice;
        struct diskslices *ssp;
+       u_int64_t start;
+       u_int64_t blocks;
 
        slice = dkslice(dev);
        part = dkpart(dev);
@@ -1197,7 +1039,9 @@ dssize(cdev_t dev, struct diskslices **sspp)
        lp = ssp->dss_slices[slice].ds_label;
        if (lp == NULL)
                return (-1);
-       return ((int64_t)lp->d_partitions[part].p_size);
+       if (getpartbounds(lp, part, &start, &blocks))
+               return (-1);
+       return ((int64_t)blocks);
 }
 
 static void
@@ -1214,180 +1058,18 @@ free_ds_label(struct diskslices *ssp, int slice)
        set_ds_label(ssp, slice, (struct disklabel *)NULL);
 }
 
-static char *
-fixlabel(const char *sname, struct diskslice *sp, struct disklabel *lp, int writeflag)
-{
-       u_int64_t start;
-       u_int64_t end;
-       u_int64_t offset;
-       int part;
-       struct partition *pp;
-       bool_t warned;
-
-       /* These errors "can't happen" so don't bother reporting details. */
-       if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
-               return ("fixlabel: invalid magic");
-       if (dkcksum(lp) != 0)
-               return ("fixlabel: invalid checksum");
-
-       pp = &lp->d_partitions[RAW_PART];
-
-       /*
-        * What a mess.  For ages old backwards compatibility the disklabel
-        * on-disk stores absolute offsets instead of slice-relative offsets.
-        * So fix it up when reading, writing, or snooping.
-        *
-        * The in-core label is always slice-relative.
-        */
-       if (writeflag) {
-               start = 0;
-               offset = sp->ds_offset;
-       } else {
-               start = sp->ds_offset;
-               offset = -sp->ds_offset;
-       }
-       if (pp->p_offset != start) {
-               if (sname != NULL) {
-                       kprintf(
-"%s: rejecting BSD label: raw partition offset != slice offset\n",
-                              sname);
-                       slice_info(sname, sp);
-                       partition_info(sname, RAW_PART, pp);
-               }
-               return ("fixlabel: raw partition offset != slice offset");
-       }
-       if (pp->p_size != sp->ds_size) {
-               if (sname != NULL) {
-                       kprintf("%s: raw partition size != slice size\n", sname);
-                       slice_info(sname, sp);
-                       partition_info(sname, RAW_PART, pp);
-               }
-               if (pp->p_size > sp->ds_size) {
-                       if (sname == NULL)
-                               return ("fixlabel: raw partition size > slice size");
-                       kprintf("%s: truncating raw partition\n", sname);
-                       pp->p_size = sp->ds_size;
-               }
-       }
-       end = start + sp->ds_size;
-       if (start > end)
-               return ("fixlabel: slice wraps");
-       if (lp->d_secpercyl <= 0)
-               return ("fixlabel: d_secpercyl <= 0");
-       pp -= RAW_PART;
-       warned = FALSE;
-       for (part = 0; part < lp->d_npartitions; part++, pp++) {
-               if (pp->p_offset != 0 || pp->p_size != 0) {
-                       if (pp->p_offset < start
-                           || pp->p_offset + pp->p_size > end
-                           || pp->p_offset + pp->p_size < pp->p_offset) {
-                               if (sname != NULL) {
-                                       kprintf(
-"%s: rejecting partition in BSD label: it isn't entirely within the slice\n",
-                                              sname);
-                                       if (!warned) {
-                                               slice_info(sname, sp);
-                                               warned = TRUE;
-                                       }
-                                       partition_info(sname, part, pp);
-                               }
-                               /* XXX else silently discard junk. */
-                               bzero(pp, sizeof *pp);
-                       } else {
-                               pp->p_offset += offset;
-                       }
-               }
-       }
-       lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
-       lp->d_secperunit = sp->ds_size;
-       lp->d_checksum = 0;
-       lp->d_checksum = dkcksum(lp);
-       return (NULL);
-}
-
-static void
-partition_info(const char *sname, int part, struct partition *pp)
-{
-       kprintf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,
-              (u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),
-              (u_long)pp->p_size);
-}
-
-static void
-slice_info(const char *sname, struct diskslice *sp)
-{
-       kprintf("%s: start %llu, end %llu, size %llu\n", sname,
-              sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
-}
-
 static void
 set_ds_label(struct diskslices *ssp, int slice, struct disklabel *lp)
 {
-       struct diskslice *sp1 = &ssp->dss_slices[slice];
-#if 0
-       struct diskslice *sp2;
-
-       if (slice == COMPATIBILITY_SLICE)
-               sp2 = &ssp->dss_slices[ssp->dss_first_bsd_slice];
-       else if (slice == ssp->dss_first_bsd_slice)
-               sp2 = &ssp->dss_slices[COMPATIBILITY_SLICE];
-       else
-               sp2 = NULL;
-#endif
-       sp1->ds_label = lp;
-#if 0
-       if (sp2)
-               sp2->ds_label = lp;
-#endif
+       struct diskslice *sp = &ssp->dss_slices[slice];
 
-       /*
-        * If the slice is not the whole-disk slice, setup the reserved
-        * area(s).
-        *
-        * The reserved area for the original bsd disklabel, inclusive of
-        * the label and space for boot2, is 15 sectors.  If you've
-        * noticed people traditionally skipping 16 sectors its because
-        * the sector numbers start at the beginning of the slice rather
-        * then the beginning of the disklabel and traditional dos slices
-        * reserve a sector at the beginning for the boot code.
-        *
-        * NOTE! With the traditional bsdlabel, the first N bytes of boot2
-        * overlap with the disklabel.  The disklabel program checks that
-        * they are 0.
-        *
-        * When clearing a label, the bsdlabel reserved area is reset.
-        */
-       if (slice != WHOLE_DISK_SLICE) {
-               if (lp) {
-                       /*
-                        * BSD uses in-band labels, meaning the label itself
-                        * is accessible from partitions within the label.
-                        * We must reserved the area taken up by the label
-                        * itself to prevent mistakes from wiping it.
-                        */
-                       sp1->ds_reserved = SBSIZE / ssp->dss_secsize;
-#if 0
-                       if (sp2)
-                               sp2->ds_reserved = sp1->ds_reserved;
-#endif
-               } else {
-                       sp1->ds_reserved = 0;
-#if 0
-                       if (sp2)
-                               sp2->ds_reserved = sp1->ds_reserved;
-#endif
-               }
-       }
+       sp->ds_label = lp;
+       adjust_label_reserved(ssp, slice, sp);
 }
 
 static void
 set_ds_wlabel(struct diskslices *ssp, int slice, int wlabel)
 {
        ssp->dss_slices[slice].ds_wlabel = wlabel;
-#if 0
-       if (slice == COMPATIBILITY_SLICE)
-               ssp->dss_slices[ssp->dss_first_bsd_slice].ds_wlabel = wlabel;
-       else if (slice == ssp->dss_first_bsd_slice)
-               ssp->dss_slices[COMPATIBILITY_SLICE].ds_wlabel = wlabel;
-#endif
 }
+
index 92be9a3..9c299f9 100644 (file)
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/kern/vfs_conf.c,v 1.49.2.5 2003/01/07 11:56:53 joerg Exp $
- *     $DragonFly: src/sys/kern/vfs_conf.c,v 1.31 2007/05/27 18:37:23 dillon Exp $
+ *     $DragonFly: src/sys/kern/vfs_conf.c,v 1.32 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -54,7 +54,6 @@
 #include <sys/malloc.h>
 #include <sys/reboot.h>
 #include <sys/diskslice.h>
-#include <sys/disklabel.h>
 #include <sys/conf.h>
 #include <sys/cons.h>
 #include <sys/device.h>
index 07c7fd6..a2c1f75 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)autoconf.c    7.1 (Berkeley) 5/9/91
  * $FreeBSD: src/sys/i386/i386/autoconf.c,v 1.146.2.2 2001/06/07 06:05:58 dd Exp $
- * $DragonFly: src/sys/platform/pc32/i386/autoconf.c,v 1.37 2007/05/08 02:31:42 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/autoconf.c,v 1.38 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -61,7 +61,6 @@
 #include <sys/bootmaj.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
-#include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/reboot.h>
 #include <sys/kernel.h>
@@ -286,18 +285,8 @@ setroot(void)
                return;
        }
 
-       /*
-        * XXX kludge for inconsistent unit numbering and lack of slice
-        * support for floppies.
-        */
-       if (majdev == FD_CDEV_MAJOR) {
-               slice = COMPATIBILITY_SLICE;
-               part = RAW_PART;
-               mindev = unit << FDUNITSHIFT;
-       } else {
-               part = B_PARTITION(bootdev);
-               mindev = dkmakeminor(unit, slice, part);
-       }
+       part = B_PARTITION(bootdev);
+       mindev = dkmakeminor(unit, slice, part);
        newrootdev = udev2dev(makeudev(majdev, mindev), 0);
        if (!dev_is_good(newrootdev))
                return;
index 6a21946..2699639 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)autoconf.c    7.1 (Berkeley) 5/9/91
  * $FreeBSD: src/sys/i386/i386/autoconf.c,v 1.146.2.2 2001/06/07 06:05:58 dd Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/autoconf.c,v 1.12 2007/06/07 23:45:52 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/autoconf.c,v 1.13 2007/06/17 23:50:16 dillon Exp $
  */
 
 /*
@@ -62,7 +62,6 @@
 #include <sys/bus.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
-#include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/reboot.h>
 #include <sys/kernel.h>
index 7d02b7d..810334f 100644 (file)
@@ -39,7 +39,7 @@
  * ----------------------------------------------------------------------------
  *
  * $FreeBSD: src/sys/sys/disk.h,v 1.16.2.3 2001/06/20 16:11:01 scottl Exp $
- * $DragonFly: src/sys/sys/disk.h,v 1.16 2007/05/19 02:39:04 dillon Exp $
+ * $DragonFly: src/sys/sys/disk.h,v 1.17 2007/06/17 23:50:12 dillon Exp $
  */
 
 #ifndef _SYS_DISK_H_
@@ -52,9 +52,6 @@
 #ifndef _SYS_DISKSLICE_H_
 #include <sys/diskslice.h>
 #endif
-#ifndef _SYS_DISKLABEL_H_
-#include <sys/disklabel.h>
-#endif
 #ifndef _SYS_QUEUE_H_
 #include <sys/queue.h>
 #endif
index cda63f7..7dc749e 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
  * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
- * $DragonFly: src/sys/sys/disklabel.h,v 1.25 2007/06/13 20:58:38 dillon Exp $
+ * $DragonFly: src/sys/sys/disklabel.h,v 1.26 2007/06/17 23:50:12 dillon Exp $
  */
 
 #ifndef _SYS_DISKLABEL_H_
@@ -179,98 +179,6 @@ dkcksum(struct disklabel *lp)
        .set    d_end_,276              /* size of disk label */
 #endif /* LOCORE */
 
-/* d_type values: */
-#define        DTYPE_SMD               1               /* SMD, XSMD; VAX hp/up */
-#define        DTYPE_MSCP              2               /* MSCP */
-#define        DTYPE_DEC               3               /* other DEC (rk, rl) */
-#define        DTYPE_SCSI              4               /* SCSI */
-#define        DTYPE_ESDI              5               /* ESDI interface */
-#define        DTYPE_ST506             6               /* ST506 etc. */
-#define        DTYPE_HPIB              7               /* CS/80 on HP-IB */
-#define        DTYPE_HPFL              8               /* HP Fiber-link */
-#define        DTYPE_FLOPPY            10              /* floppy */
-#define        DTYPE_CCD               11              /* concatenated disk */
-#define        DTYPE_VINUM             12              /* vinum volume */
-#define        DTYPE_DOC2K             13              /* Msys DiskOnChip */
-
-#ifdef DKTYPENAMES
-static const char *dktypenames[] = {
-       "unknown",
-       "SMD",
-       "MSCP",
-       "old DEC",
-       "SCSI",
-       "ESDI",
-       "ST506",
-       "HP-IB",
-       "HP-FL",
-       "type 9",
-       "floppy",
-       "CCD",
-       "Vinum",
-       "DOC2K",
-       NULL
-};
-#define DKMAXTYPES     (sizeof(dktypenames) / sizeof(dktypenames[0]) - 1)
-#endif
-
-/*
- * Filesystem type and version.
- * Used to interpret other filesystem-specific
- * per-partition information.
- */
-#define        FS_UNUSED       0               /* unused */
-#define        FS_SWAP         1               /* swap */
-#define        FS_V6           2               /* Sixth Edition */
-#define        FS_V7           3               /* Seventh Edition */
-#define        FS_SYSV         4               /* System V */
-#define        FS_V71K         5               /* V7 with 1K blocks (4.1, 2.9) */
-#define        FS_V8           6               /* Eighth Edition, 4K blocks */
-#define        FS_BSDFFS       7               /* 4.2BSD fast file system */
-#define        FS_MSDOS        8               /* MSDOS file system */
-#define        FS_BSDLFS       9               /* 4.4BSD log-structured file system */
-#define        FS_OTHER        10              /* in use, but unknown/unsupported */
-#define        FS_HPFS         11              /* OS/2 high-performance file system */
-#define        FS_ISO9660      12              /* ISO 9660, normally CD-ROM */
-#define        FS_BOOT         13              /* partition contains bootstrap */
-#define        FS_VINUM        14              /* Vinum drive partition */
-#define        FS_RAID         15
-#define FS_RESERVED16  16
-#define FS_RESERVED17  17
-#define FS_RESERVED18  18
-#define FS_CCD         19              /* CCD drive partition */
-#define FS_RESERVED20  20
-#define FS_JFS2                21
-
-#ifdef DKTYPENAMES
-static const char *fstypenames[] = {
-       "unused",
-       "swap",
-       "Version 6",
-       "Version 7",
-       "System V",
-       "4.1BSD",
-       "Eighth Edition",
-       "4.2BSD",
-       "MSDOS",
-       "4.4LFS",
-       "unknown",
-       "HPFS",
-       "ISO9660",
-       "boot",
-       "vinum",
-       "raid",
-       "?",
-       "?",
-       "?",
-       "ccd",
-       "?",    /* don't use in case freebsd reassigns jfs / bug in freebsd */
-       "jfs",
-       NULL
-};
-#define FSMAXTYPES     (sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)
-#endif
-
 #ifndef LOCORE
 
 /*
@@ -283,10 +191,24 @@ static const char *fstypenames[] = {
 
 #ifdef _KERNEL
 
+struct diskslice;
+struct diskslices;
+struct disk_info;
+
 char   *readdisklabel (cdev_t dev, struct disklabel *lp);
 int    setdisklabel (struct disklabel *olp, struct disklabel *nlp,
-                         u_int32_t *openmask);
+                   struct diskslice *sp, u_int32_t *openmask);
 int    writedisklabel (cdev_t dev, struct disklabel *lp);
+struct disklabel *clone_label(struct disk_info *info, struct diskslice *sp);
+char *fixlabel(const char *sname, struct diskslice *sp,
+               struct disklabel *lp, int writeflag);
+void adjust_label_reserved(struct diskslices *ssp, int slice, struct diskslice *sp);
+int getpartbounds(struct disklabel *lp, u_int32_t part,
+                   u_int64_t *start, u_int64_t *blocks);
+int getpartfstype(struct disklabel *lp, u_int32_t part);
+u_int32_t getnumparts(struct disklabel *lp);
+void makevirginlabel(struct disklabel *lp, struct diskslices *ssp,
+                   struct diskslice *sp, struct disk_info *info);
 
 #endif /* _KERNEL */
 
index f7ed786..4b8710d 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
  * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
- * $DragonFly: src/sys/sys/disklabel32.h,v 1.25 2007/06/13 20:58:38 dillon Exp $
+ * $DragonFly: src/sys/sys/disklabel32.h,v 1.26 2007/06/17 23:50:12 dillon Exp $
  */
 
 #ifndef _SYS_DISKLABEL_H_
@@ -179,98 +179,6 @@ dkcksum(struct disklabel *lp)
        .set    d_end_,276              /* size of disk label */
 #endif /* LOCORE */
 
-/* d_type values: */
-#define        DTYPE_SMD               1               /* SMD, XSMD; VAX hp/up */
-#define        DTYPE_MSCP              2               /* MSCP */
-#define        DTYPE_DEC               3               /* other DEC (rk, rl) */
-#define        DTYPE_SCSI              4               /* SCSI */
-#define        DTYPE_ESDI              5               /* ESDI interface */
-#define        DTYPE_ST506             6               /* ST506 etc. */
-#define        DTYPE_HPIB              7               /* CS/80 on HP-IB */
-#define        DTYPE_HPFL              8               /* HP Fiber-link */
-#define        DTYPE_FLOPPY            10              /* floppy */
-#define        DTYPE_CCD               11              /* concatenated disk */
-#define        DTYPE_VINUM             12              /* vinum volume */
-#define        DTYPE_DOC2K             13              /* Msys DiskOnChip */
-
-#ifdef DKTYPENAMES
-static const char *dktypenames[] = {
-       "unknown",
-       "SMD",
-       "MSCP",
-       "old DEC",
-       "SCSI",
-       "ESDI",
-       "ST506",
-       "HP-IB",
-       "HP-FL",
-       "type 9",
-       "floppy",
-       "CCD",
-       "Vinum",
-       "DOC2K",
-       NULL
-};
-#define DKMAXTYPES     (sizeof(dktypenames) / sizeof(dktypenames[0]) - 1)
-#endif
-
-/*
- * Filesystem type and version.
- * Used to interpret other filesystem-specific
- * per-partition information.
- */
-#define        FS_UNUSED       0               /* unused */
-#define        FS_SWAP         1               /* swap */
-#define        FS_V6           2               /* Sixth Edition */
-#define        FS_V7           3               /* Seventh Edition */
-#define        FS_SYSV         4               /* System V */
-#define        FS_V71K         5               /* V7 with 1K blocks (4.1, 2.9) */
-#define        FS_V8           6               /* Eighth Edition, 4K blocks */
-#define        FS_BSDFFS       7               /* 4.2BSD fast file system */
-#define        FS_MSDOS        8               /* MSDOS file system */
-#define        FS_BSDLFS       9               /* 4.4BSD log-structured file system */
-#define        FS_OTHER        10              /* in use, but unknown/unsupported */
-#define        FS_HPFS         11              /* OS/2 high-performance file system */
-#define        FS_ISO9660      12              /* ISO 9660, normally CD-ROM */
-#define        FS_BOOT         13              /* partition contains bootstrap */
-#define        FS_VINUM        14              /* Vinum drive partition */
-#define        FS_RAID         15
-#define FS_RESERVED16  16
-#define FS_RESERVED17  17
-#define FS_RESERVED18  18
-#define FS_CCD         19              /* CCD drive partition */
-#define FS_RESERVED20  20
-#define FS_JFS2                21
-
-#ifdef DKTYPENAMES
-static const char *fstypenames[] = {
-       "unused",
-       "swap",
-       "Version 6",
-       "Version 7",
-       "System V",
-       "4.1BSD",
-       "Eighth Edition",
-       "4.2BSD",
-       "MSDOS",
-       "4.4LFS",
-       "unknown",
-       "HPFS",
-       "ISO9660",
-       "boot",
-       "vinum",
-       "raid",
-       "?",
-       "?",
-       "?",
-       "ccd",
-       "?",    /* don't use in case freebsd reassigns jfs / bug in freebsd */
-       "jfs",
-       NULL
-};
-#define FSMAXTYPES     (sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)
-#endif
-
 #ifndef LOCORE
 
 /*
@@ -283,10 +191,24 @@ static const char *fstypenames[] = {
 
 #ifdef _KERNEL
 
+struct diskslice;
+struct diskslices;
+struct disk_info;
+
 char   *readdisklabel (cdev_t dev, struct disklabel *lp);
 int    setdisklabel (struct disklabel *olp, struct disklabel *nlp,
-                         u_int32_t *openmask);
+                   struct diskslice *sp, u_int32_t *openmask);
 int    writedisklabel (cdev_t dev, struct disklabel *lp);
+struct disklabel *clone_label(struct disk_info *info, struct diskslice *sp);
+char *fixlabel(const char *sname, struct diskslice *sp,
+               struct disklabel *lp, int writeflag);
+void adjust_label_reserved(struct diskslices *ssp, int slice, struct diskslice *sp);
+int getpartbounds(struct disklabel *lp, u_int32_t part,
+                   u_int64_t *start, u_int64_t *blocks);
+int getpartfstype(struct disklabel *lp, u_int32_t part);
+u_int32_t getnumparts(struct disklabel *lp);
+void makevirginlabel(struct disklabel *lp, struct diskslices *ssp,
+                   struct diskslice *sp, struct disk_info *info);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/dtype.h b/sys/sys/dtype.h
new file mode 100644 (file)
index 0000000..9a33cf5
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 1987, 1988, 1993
+ *     The Regents of the University of California.  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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
+ *
+ *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
+ * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
+ * $DragonFly: src/sys/sys/dtype.h,v 1.1 2007/06/17 23:50:12 dillon Exp $
+ */
+
+#ifndef _SYS_DTYPE_H_
+#define        _SYS_DTYPE_H_
+
+#ifndef _SYS_TYPES_H_
+#include <sys/types.h>
+#endif
+
+/* d_type values: */
+#define        DTYPE_SMD               1               /* SMD, XSMD; VAX hp/up */
+#define        DTYPE_MSCP              2               /* MSCP */
+#define        DTYPE_DEC               3               /* other DEC (rk, rl) */
+#define        DTYPE_SCSI              4               /* SCSI */
+#define        DTYPE_ESDI              5               /* ESDI interface */
+#define        DTYPE_ST506             6               /* ST506 etc. */
+#define        DTYPE_HPIB              7               /* CS/80 on HP-IB */
+#define        DTYPE_HPFL              8               /* HP Fiber-link */
+#define        DTYPE_FLOPPY            10              /* floppy */
+#define        DTYPE_CCD               11              /* concatenated disk */
+#define        DTYPE_VINUM             12              /* vinum volume */
+#define        DTYPE_DOC2K             13              /* Msys DiskOnChip */
+
+#ifdef DKTYPENAMES
+static const char *dktypenames[] = {
+       "unknown",
+       "SMD",
+       "MSCP",
+       "old DEC",
+       "SCSI",
+       "ESDI",
+       "ST506",
+       "HP-IB",
+       "HP-FL",
+       "type 9",
+       "floppy",
+       "CCD",
+       "Vinum",
+       "DOC2K",
+       NULL
+};
+#define DKMAXTYPES     (sizeof(dktypenames) / sizeof(dktypenames[0]) - 1)
+#endif
+
+/*
+ * Filesystem type and version.
+ * Used to interpret other filesystem-specific
+ * per-partition information.
+ */
+#define        FS_UNUSED       0               /* unused */
+#define        FS_SWAP         1               /* swap */
+#define        FS_V6           2               /* Sixth Edition */
+#define        FS_V7           3               /* Seventh Edition */
+#define        FS_SYSV         4               /* System V */
+#define        FS_V71K         5               /* V7 with 1K blocks (4.1, 2.9) */
+#define        FS_V8           6               /* Eighth Edition, 4K blocks */
+#define        FS_BSDFFS       7               /* 4.2BSD fast file system */
+#define        FS_MSDOS        8               /* MSDOS file system */
+#define        FS_BSDLFS       9               /* 4.4BSD log-structured file system */
+#define        FS_OTHER        10              /* in use, but unknown/unsupported */
+#define        FS_HPFS         11              /* OS/2 high-performance file system */
+#define        FS_ISO9660      12              /* ISO 9660, normally CD-ROM */
+#define        FS_BOOT         13              /* partition contains bootstrap */
+#define        FS_VINUM        14              /* Vinum drive partition */
+#define        FS_RAID         15
+#define FS_RESERVED16  16
+#define FS_RESERVED17  17
+#define FS_RESERVED18  18
+#define FS_CCD         19              /* CCD drive partition */
+#define FS_RESERVED20  20
+#define FS_JFS2                21
+
+#ifdef DKTYPENAMES
+static const char *fstypenames[] = {
+       "unused",
+       "swap",
+       "Version 6",
+       "Version 7",
+       "System V",
+       "4.1BSD",
+       "Eighth Edition",
+       "4.2BSD",
+       "MSDOS",
+       "4.4LFS",
+       "unknown",
+       "HPFS",
+       "ISO9660",
+       "boot",
+       "vinum",
+       "raid",
+       "?",
+       "?",
+       "?",
+       "ccd",
+       "?",    /* don't use in case freebsd reassigns jfs / bug in freebsd */
+       "jfs",
+       NULL
+};
+#define FSMAXTYPES     (sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)
+#endif
+
+#endif /* SYS_DTYPE_H_ */