Move all the code related to handling the current 32 bit disklabel
authorMatthew Dillon <dillon@dragonflybsd.org>
Mon, 18 Jun 2007 05:13:43 +0000 (05:13 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Mon, 18 Jun 2007 05:13:43 +0000 (05:13 +0000)
to subr_disklabel32.c.  Move the header file from sys/disklabel.h to
sys/disklabel32.h.  Rename all the related structures and constants
and retire 'struct disklabel'.

Redo the sys/disklabel.h header file to implement a generic disklabel
abstraction.  Modify kern/subr_diskslice.c to use this abstraction, with
some shims for the ops dispatch at the moment which will be cleaned up later.

Adjust all auxillary code that directly accesses 32 bit disklabels to use
the new structure and constant names.

Remove the snoop-adjust code.  The kernel would snoop reads and writes to
the disklabel area via the raw slice device (e.g. ad0s1) and convert the
disklabel from the in-core format to the on-disk format and vise-versa.
The reads and writes made by disklabel -r and the kernel's own internal
readdisklabel and writedisklabel code used the snooping.

Rearrange the kernel's internal code to manually convert the disklabel when
reading and writing.  Rearrange the /sbin/disklabel program to do the same
when the -r option is used.  Have the disklabel program also check which
DragonFly OS it is running under so it can be run on older systems.  Note
that the disklabel binary prior to these changes will NOT operate on the
disklabel properly if running on a NEW kernel.

Introduce skeleton files for 64 bit disklabel support.

23 files changed:
include/disktab.h
lib/libc/gen/disklabel.c
lib/libc/gen/getdiskbyname.3
lib/libstand/stand.h
sbin/disklabel/disklabel.8
sbin/disklabel/disklabel.c
sbin/gpt/migrate.c
sbin/vinum/list.c
sys/boot/efi/libefi/devicename.c
sys/boot/ia64/libski/devicename.c
sys/boot/pc32/boot2/boot2.c
sys/boot/pc32/libi386/biosdisk.c
sys/boot/pc32/libi386/devicename.c
sys/conf/files
sys/kern/subr_disklabel32.c
sys/kern/subr_diskslice.c
sys/sys/disklabel.h
sys/sys/disklabel32.h
sys/sys/disklabel64.h [new file with mode: 0644]
sys/sys/diskslice.h
sys/sys/ndisklabel.h [deleted file]
sys/sys/odisklabel.h [deleted file]
sys/sys/param.h

index eefa5ef..93b200c 100644 (file)
@@ -31,7 +31,7 @@
  * SUCH DAMAGE.
  *
  * @(#)disktab.h       8.1 (Berkeley) 6/2/93
- * $DragonFly: src/include/disktab.h,v 1.3 2007/05/17 23:49:58 dillon Exp $
+ * $DragonFly: src/include/disktab.h,v 1.4 2007/06/18 05:13:33 dillon Exp $
  */
 
 #ifndef        _DISKTAB_H_
@@ -103,9 +103,9 @@ struct      disktab {
 
 #ifndef _KERNEL
 __BEGIN_DECLS
-struct disklabel;
+struct disklabel32;
 struct disktab *getdisktabbyname (const char *);
-struct disklabel *getdiskbyname (const char *);
+struct disklabel32 *getdiskbyname (const char *);
 __END_DECLS
 #endif
 
index 391e835..ac529bb 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.12 2007/06/17 23:50:13 dillon Exp $
+ * $DragonFly: src/lib/libc/gen/disklabel.c,v 1.13 2007/06/18 05:13:34 dillon Exp $
  */
 
 #include <sys/param.h>
 #define DKTYPENAMES
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/dtype.h>
 #include <vfs/ufs/dinode.h>
 #include <vfs/ufs/fs.h>
 
 static int     gettype (const char *, const char **);
 
-struct disklabel *
+struct disklabel32 *
 getdiskbyname(const char *name)
 {
-       static struct   disklabel disk;
-       struct  disklabel *dp = &disk;
-       struct partition *pp;
+       static struct disklabel32 disk;
+       struct  disklabel32 *dp = &disk;
+       struct partition32 *pp;
        char    *buf;
        char    *db_array[2] = { _PATH_DISKTAB, 0 };
        char    *cp, *cq;       /* can't be register */
@@ -108,7 +108,7 @@ getdiskbyname(const char *name)
        strcpy(ptype, "tx");
        max = 'a' - 1;
        pp = &dp->d_partitions[0];
-       for (p = 'a'; p < 'a' + MAXPARTITIONS; p++, pp++) {
+       for (p = 'a'; p < 'a' + MAXPARTITIONS32; p++, pp++) {
                long l;
                psize[1] = pbsize[1] = pfsize[1] = poffset[1] = ptype[1] = p;
                if (cgetnum(buf, psize, &l) == -1)
@@ -135,12 +135,12 @@ getdiskbyname(const char *name)
        dp->d_npartitions = max + 1 - 'a';
        strcpy(psize, "dx");
        dx = dp->d_drivedata;
-       for (p = '0'; p < '0' + NDDATA; p++, dx++) {
+       for (p = '0'; p < '0' + NDDATA32; p++, dx++) {
                psize[1] = p;
                getnumdflt(*dx, psize, 0);
        }
-       dp->d_magic = DISKMAGIC;
-       dp->d_magic2 = DISKMAGIC;
+       dp->d_magic = DISKMAGIC32;
+       dp->d_magic2 = DISKMAGIC32;
        free(buf);
        return (dp);
 }
index c091614..15e87d5 100644 (file)
@@ -31,7 +31,7 @@
 .\"
 .\"     @(#)getdiskbyname.3    8.1 (Berkeley) 6/4/93
 .\" $FreeBSD: src/lib/libc/gen/getdiskbyname.3,v 1.3.2.4 2001/12/14 18:33:51 ru Exp $
-.\" $DragonFly: src/lib/libc/gen/getdiskbyname.3,v 1.3 2007/05/17 23:53:44 dillon Exp $
+.\" $DragonFly: src/lib/libc/gen/getdiskbyname.3,v 1.4 2007/06/18 05:13:34 dillon Exp $
 .\"
 .Dd June 4, 1993
 .Dt GETDISKBYNAME 3
@@ -43,8 +43,8 @@
 .Lb libc
 .Sh SYNOPSIS
 .In disktab.h
-.In sys/disklabel.h
-.Ft struct disklabel *
+.In sys/disklabel32.h
+.Ft struct disklabel32 *
 .Fn getdiskbyname "const char *name"
 .Sh DESCRIPTION
 The
index 201dbb1..ea80e60 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/lib/libstand/stand.h,v 1.18.2.8 2002/06/17 11:22:39 sobomax Exp $
- * $DragonFly: src/lib/libstand/stand.h,v 1.8 2005/12/11 02:27:26 swildner Exp $
+ * $DragonFly: src/lib/libstand/stand.h,v 1.9 2007/06/18 05:13:37 dillon Exp $
  * From        $NetBSD: stand.h,v 1.22 1997/06/26 19:17:40 drochner Exp $      
  */
 
@@ -251,8 +251,8 @@ extern void *reallocf(void *, size_t);
 extern void    mallocstats(void);
 
 /* disklabel support (undocumented, may be junk) */
-struct         disklabel;
-extern char    *getdisklabel(const char *, struct disklabel *);
+struct         disklabel32;
+extern char    *getdisklabel32(const char *, struct disklabel32 *);
 
 extern int     printf(const char *, ...);
 extern void    vprintf(const char *, __va_list);
index 719b14a..0c20c80 100644 (file)
@@ -34,7 +34,7 @@
 .\"
 .\"    @(#)disklabel.8 8.2 (Berkeley) 4/19/94
 .\" $FreeBSD: src/sbin/disklabel/disklabel.8,v 1.15.2.22 2003/04/17 17:56:34 trhodes Exp $
-.\" $DragonFly: src/sbin/disklabel/disklabel.8,v 1.13 2007/05/17 08:19:01 swildner Exp $
+.\" $DragonFly: src/sbin/disklabel/disklabel.8,v 1.14 2007/06/18 05:13:38 dillon Exp $
 .\"
 .Dd January 21, 2007
 .Dt DISKLABEL 8
@@ -94,6 +94,9 @@
 .Oc
 .Ar disk Ar protofile
 .Oo Ar disktype/auto Oc
+.Nm
+.Fl f Ar slice_start_lba
+.Oo Ar options Oc
 .Sh DESCRIPTION
 The
 .Nm
@@ -712,6 +715,21 @@ The asterisk
 .Pq Ql *
 indicates that the partition does not begin or end exactly on a
 cylinder boundary.
+.Pp
+.Dx
+no longer snoop-adjusts the on-disklabel when reading or writing
+raw labels.
+.Nm
+is now responsible for adjusting the label when operating in raw mode.
+Traditional (32 bit BSD) disklabels store offsets as absolute block numbers
+rather than slice-relative block numbers.
+If
+.Nm
+is unable to issue the DIOCGPART ioctl to get slice information it will 
+refuse to read or write the label in raw mode.
+The
+.Fl f
+option may be used to force the operation by supplying a manual offset.
 .Sh EXAMPLES
 .Dl "disklabel da0s1"
 .Pp
index e56a67c..eb0bd3b 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.20 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sbin/disklabel/disklabel.c,v 1.21 2007/06/18 05:13:38 dillon Exp $
  */
 
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #define DKTYPENAMES
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
+#include <sys/disklabel64.h>
 #include <sys/diskslice.h>
 #include <sys/diskmbr.h>
 #include <sys/dtype.h>
+#include <sys/sysctl.h>
 #include <disktab.h>
 
 #include <vfs/ufs/dinode.h>
 
 #define        NUMBOOT 2
 
-void   makelabel(const char *, const char *, struct disklabel *);
-int    writelabel(int, const char *, struct disklabel *);
+void   makelabel(const char *, const char *, struct disklabel32 *);
+int    writelabel(int, const char *, struct disklabel32 *);
 void   l_perror(const char *);
-struct disklabel *readlabel(int);
-struct disklabel *makebootarea(char *, struct disklabel *, int);
-void   display(FILE *, const struct disklabel *);
-int    edit(struct disklabel *, int);
+struct disklabel32 *readlabel(int);
+struct disklabel32 *makebootarea(char *, struct disklabel32 *, int);
+void   display(FILE *, const struct disklabel32 *);
+int    edit(struct disklabel32 *, int);
 int    editit(void);
 char   *skip(char *);
 char   *word(char *);
-int    getasciilabel(FILE *, struct disklabel *);
-int    getasciipartspec(char *, struct disklabel *, int, int);
-int    checklabel(struct disklabel *);
-void   setbootflag(struct disklabel *);
+int    getasciilabel(FILE *, struct disklabel32 *);
+int    getasciipartspec(char *, struct disklabel32 *, int, int);
+int    checklabel(struct disklabel32 *);
+void   setbootflag(struct disklabel32 *);
 void   Warning(const char *, ...) __printflike(1, 2);
 void   usage(void);
 int    checkoldboot(int, const char *);
-struct disklabel *getvirginlabel(void);
-struct disklabel *getdisklabelfromdisktab(const char *name);
+const char *fixlabel(int, struct disklabel32 *, int);
+struct disklabel32 *getvirginlabel(void);
+struct disklabel32 *getdisklabelfromdisktab(const char *name);
 
 #define        DEFEDITOR       _PATH_VI
 #define        streq(a,b)      (strcmp(a,b) == 0)
@@ -118,7 +121,7 @@ char        *specname;
 char   tmpfil[] = PATH_TMPFILE;
 
 char   namebuf[BBSIZE], *np = namebuf;
-struct disklabel lab;
+struct disklabel32 lab;
 char   bootarea[BBSIZE];
 
 #define MAX_PART ('z')
@@ -143,18 +146,20 @@ enum      {
 
 int    rflag;
 int    disable_write;   /* set to disable writing to disk label */
+int    forceflag;
+u_int32_t slice_start_lba;
 
 #ifdef DEBUG
 int    debug;
-#define OPTIONS        "BNRWb:denrs:w"
+#define OPTIONS        "BNRWb:def:nrs:w"
 #else
-#define OPTIONS        "BNRWb:enrs:w"
+#define OPTIONS        "BNRWb:ef:nrs:w"
 #endif
 
 int
 main(int argc, char *argv[])
 {
-       struct disklabel *lp;
+       struct disklabel32 *lp;
        FILE *t;
        int ch, f = 0, flag, error = 0;
        char *name = 0;
@@ -168,6 +173,11 @@ main(int argc, char *argv[])
                        case 'b':
                                xxboot = optarg;
                                break;
+
+                       case 'f':
+                               forceflag = 1;
+                               slice_start_lba = strtoul(optarg, NULL, 0);
+                               break;
 #if NUMBOOT > 1
                        case 's':
                                bootxx = optarg;
@@ -327,7 +337,7 @@ main(int argc, char *argv[])
 #if NUMBOOT > 0
        case WRITEBOOT:
        {
-               struct disklabel tlab;
+               struct disklabel32 tlab;
 
                lp = readlabel(f);
                tlab = *lp;
@@ -350,9 +360,9 @@ main(int argc, char *argv[])
  * if specified.
  */
 void
-makelabel(const char *type, const char *name, struct disklabel *lp)
+makelabel(const char *type, const char *name, struct disklabel32 *lp)
 {
-       struct disklabel *dp;
+       struct disklabel32 *dp;
 
        if (strcmp(type, "auto") == 0)
                dp = getvirginlabel();
@@ -370,10 +380,9 @@ makelabel(const char *type, const char *name, struct disklabel *lp)
 }
 
 int
-writelabel(int f, const char *boot, struct disklabel *lp)
+writelabel(int f, const char *boot, struct disklabel32 *lp)
 {
-       int yes = 1;
-       int no = 0;
+       const char *msg;
        int flag;
        int r;
 
@@ -386,10 +395,10 @@ writelabel(int f, const char *boot, struct disklabel *lp)
                if (checkoldboot(f, boot))
                        errx(4, "Will not overwrite old bootblocks w/ label, install new boot blocks first!");
                setbootflag(lp);
-               lp->d_magic = DISKMAGIC;
-               lp->d_magic2 = DISKMAGIC;
+               lp->d_magic = DISKMAGIC32;
+               lp->d_magic2 = DISKMAGIC32;
                lp->d_checksum = 0;
-               lp->d_checksum = dkcksum(lp);
+               lp->d_checksum = dkcksum32(lp);
                if (rflag) {
                        /*
                         * First set the kernel disk label,
@@ -399,7 +408,7 @@ writelabel(int f, const char *boot, struct disklabel *lp)
                         * may prevent us from changing the current (in-core)
                         * label.
                         */
-                       if (ioctl(f, DIOCSDINFO, lp) < 0 &&
+                       if (ioctl(f, DIOCSDINFO32, lp) < 0 &&
                                errno != ENODEV && errno != ENOTTY) {
                                l_perror("ioctl DIOCSDINFO");
                                return (1);
@@ -413,7 +422,13 @@ writelabel(int f, const char *boot, struct disklabel *lp)
                        flag = 1;
                        if (ioctl(f, DIOCWLABEL, &flag) < 0)
                                warn("ioctl DIOCWLABEL");
+                       msg = fixlabel(f, lp, 1);
+                       if (msg) {
+                               warn(msg);
+                               return (1);
+                       }
                        r = write(f, boot, lp->d_bbsize);
+                       fixlabel(f, lp, 0);
                        if (r != ((ssize_t)lp->d_bbsize)) {
                                warn("write");
                                return (1);
@@ -423,9 +438,9 @@ writelabel(int f, const char *boot, struct disklabel *lp)
                         * Output the remainder of the disklabel
                         */
                        if (bootbuf) {
-                               ioctl(f, DIOCSETSNOOP, &yes);
+                               fixlabel(f, lp, 1);
                                r = write(f, bootbuf, bootsize);
-                               ioctl(f, DIOCSETSNOOP, &no);
+                               fixlabel(f, lp, 0);
                                if (r != bootsize) {
                                        warn("write");
                                        return(1);
@@ -434,7 +449,7 @@ writelabel(int f, const char *boot, struct disklabel *lp)
 #endif
                        flag = 0;
                        ioctl(f, DIOCWLABEL, &flag);
-               } else if (ioctl(f, DIOCWDINFO, lp) < 0) {
+               } else if (ioctl(f, DIOCWDINFO32, lp) < 0) {
                        l_perror("ioctl DIOCWDINFO");
                        return (1);
                }
@@ -476,35 +491,35 @@ l_perror(const char *s)
  * Fetch disklabel for disk.
  * Use ioctl to get label unless -r flag is given.
  */
-struct disklabel *
+struct disklabel32 *
 readlabel(int f)
 {
-       struct disklabel *lp;
+       const char *msg;
+       struct disklabel32 *lp;
        int r;
-       int yes = 1;
-       int no = 0;
 
        if (rflag) {
-               if (ioctl(f, DIOCSETSNOOP, &yes) < 0)
-                       printf("BAD SNOOP\n");
                r = read(f, bootarea, BBSIZE);
-               ioctl(f, DIOCSETSNOOP, &no);
                if (r < BBSIZE)
                        err(4, "%s", specname);
-               for (lp = (struct disklabel *)bootarea;
-                   lp <= (struct disklabel *)(bootarea + BBSIZE - sizeof(*lp));
-                   lp = (struct disklabel *)((char *)lp + 16))
-                       if (lp->d_magic == DISKMAGIC &&
-                           lp->d_magic2 == DISKMAGIC)
+               for (lp = (struct disklabel32 *)bootarea;
+                   lp <= (struct disklabel32 *)(bootarea + BBSIZE - sizeof(*lp));
+                   lp = (struct disklabel32 *)((char *)lp + 16)) {
+                       if (lp->d_magic == DISKMAGIC32 &&
+                           lp->d_magic2 == DISKMAGIC32)
                                break;
-               if (lp > (struct disklabel *)(bootarea+BBSIZE-sizeof(*lp)) ||
-                   lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC ||
-                   dkcksum(lp) != 0)
-                       errx(1,
-           "bad pack magic number (label is damaged, or pack is unlabeled)");
+               }
+               if (lp > (struct disklabel32 *)(bootarea+BBSIZE-sizeof(*lp)) ||
+                   lp->d_magic != DISKMAGIC32 || lp->d_magic2 != DISKMAGIC32 ||
+                   dkcksum32(lp) != 0) {
+                       errx(1, "bad pack magic number (label is damaged, "
+                               "or pack is unlabeled)");
+               }
+               if ((msg = fixlabel(f, lp, 0)) != NULL)
+                       errx(1, msg);
        } else {
                lp = &lab;
-               if (ioctl(f, DIOCGDINFO, lp) < 0)
+               if (ioctl(f, DIOCGDINFO32, lp) < 0)
                        err(4, "ioctl DIOCGDINFO");
        }
        return (lp);
@@ -514,10 +529,10 @@ readlabel(int f)
  * Construct a bootarea (d_bbsize bytes) in the specified buffer ``boot''
  * Returns a pointer to the disklabel portion of the bootarea.
  */
-struct disklabel *
-makebootarea(char *boot, struct disklabel *dp, int f)
+struct disklabel32 *
+makebootarea(char *boot, struct disklabel32 *dp, int f)
 {
-       struct disklabel *lp;
+       struct disklabel32 *lp;
        char *p;
        int b;
 #if NUMBOOT > 0
@@ -534,8 +549,8 @@ makebootarea(char *boot, struct disklabel *dp, int f)
                dp->d_secsize = DEV_BSIZE;
                dp->d_bbsize = BBSIZE;
        }
-       lp = (struct disklabel *)
-               (boot + (LABELSECTOR * dp->d_secsize) + LABELOFFSET);
+       lp = (struct disklabel32 *)
+               (boot + (LABELSECTOR32 * dp->d_secsize) + LABELOFFSET32);
        bzero((char *)lp, sizeof *lp);
 #if NUMBOOT > 0
        /*
@@ -656,17 +671,17 @@ makebootarea(char *boot, struct disklabel *dp, int f)
         * Make sure no part of the bootstrap is written in the area
         * reserved for the label.
         */
-       for (p = (char *)lp; p < (char *)lp + sizeof(struct disklabel); p++)
+       for (p = (char *)lp; p < (char *)lp + sizeof(struct disklabel32); p++)
                if (*p)
                        errx(2, "bootstrap doesn't leave room for disk label");
        return (lp);
 }
 
 void
-display(FILE *f, const struct disklabel *lp)
+display(FILE *f, const struct disklabel32 *lp)
 {
        int i, j;
-       const struct partition *pp;
+       const struct partition32 *pp;
 
        fprintf(f, "# %s:\n", specname);
        if (lp->d_type < DKMAXTYPES)
@@ -694,7 +709,7 @@ display(FILE *f, const struct disklabel *lp)
        fprintf(f, "track-to-track seek: %ld\t# milliseconds\n",
            (u_long)lp->d_trkseek);
        fprintf(f, "drivedata: ");
-       for (i = NDDATA - 1; i >= 0; i--) {
+       for (i = NDDATA32 - 1; i >= 0; i--) {
                if (lp->d_drivedata[i])
                        break;
        }
@@ -726,10 +741,10 @@ display(FILE *f, const struct disklabel *lp)
 }
 
 int
-edit(struct disklabel *lp, int f)
+edit(struct disklabel32 *lp, int f)
 {
        int c, fd;
-       struct disklabel label;
+       struct disklabel32 label;
        FILE *fp;
 
        if ((fd = mkstemp(tmpfil)) == -1 ||
@@ -836,7 +851,7 @@ word(char *cp)
  * and fill in lp.
  */
 int
-getasciilabel(FILE *f, struct disklabel *lp)
+getasciilabel(FILE *f, struct disklabel32 *lp)
 {
        char *cp;
        const char **cpp;
@@ -907,17 +922,17 @@ getasciilabel(FILE *f, struct disklabel *lp)
                        continue;
                }
                if (streq(cp, "drivedata")) {
-                       for (i = 0; (cp = tp) && *cp != '\0' && i < NDDATA;) {
+                       for (i = 0; (cp = tp) && *cp != '\0' && i < NDDATA32;) {
                                lp->d_drivedata[i++] = strtoul(cp, NULL, 10);
                                tp = word(cp);
                        }
                        continue;
                }
                if (sscanf(cp, "%lu partitions", &v) == 1) {
-                       if (v == 0 || v > MAXPARTITIONS) {
+                       if (v == 0 || v > MAXPARTITIONS32) {
                                fprintf(stderr,
                                    "line %d: bad # of partitions\n", lineno);
-                               lp->d_npartitions = MAXPARTITIONS;
+                               lp->d_npartitions = MAXPARTITIONS32;
                                errors++;
                        } else
                                lp->d_npartitions = v;
@@ -1105,9 +1120,9 @@ getasciilabel(FILE *f, struct disklabel *lp)
  * Return 0 on success, 1 on failure.
  */
 int
-getasciipartspec(char *tp, struct disklabel *lp, int part, int lineno)
+getasciipartspec(char *tp, struct disklabel32 *lp, int part, int lineno)
 {
-       struct partition *pp;
+       struct partition32 *pp;
        char *cp;
        const char **cpp;
        u_long v;
@@ -1184,16 +1199,16 @@ getasciipartspec(char *tp, struct disklabel *lp, int part, int lineno)
  * derived fields according to supplied values.
  */
 int
-checklabel(struct disklabel *lp)
+checklabel(struct disklabel32 *lp)
 {
-       struct partition *pp;
+       struct partition32 *pp;
        int i, errors = 0;
        char part;
        u_long total_size, total_percent, current_offset;
        int seen_default_offset;
        int hog_part;
        int j;
-       struct partition *pp2;
+       struct partition32 *pp2;
 
        if (lp->d_secsize == 0) {
                fprintf(stderr, "sector size 0\n");
@@ -1227,9 +1242,9 @@ checklabel(struct disklabel *lp)
                errors++;
        } else if (lp->d_sbsize % lp->d_secsize)
                Warning("super block size %% sector-size != 0");
-       if (lp->d_npartitions > MAXPARTITIONS)
+       if (lp->d_npartitions > MAXPARTITIONS32)
                Warning("number of partitions (%lu) > MAXPARTITIONS (%d)",
-                   (u_long)lp->d_npartitions, MAXPARTITIONS);
+                   (u_long)lp->d_npartitions, MAXPARTITIONS32);
 
        /* first allocate space to the partitions, then offsets */
        total_size = 0; /* in sectors */
@@ -1449,12 +1464,12 @@ checklabel(struct disklabel *lp)
  *
  * The device name must be given in its "canonical" form.
  */
-static struct disklabel dlab;
+static struct disklabel32 dlab;
 
-struct disklabel *
+struct disklabel32 *
 getvirginlabel(void)
 {
-       struct disklabel *dl = &dlab;
+       struct disklabel32 *dl = &dlab;
        char nambuf[BBSIZE];
        int f;
 
@@ -1472,8 +1487,8 @@ getvirginlabel(void)
         * Try to use the new get-virgin-label ioctl.  If it fails,
         * fallback to the old get-disdk-info ioctl.
         */
-       if (ioctl(f, DIOCGDVIRGIN, dl) < 0) {
-               if (ioctl(f, DIOCGDINFO, dl) < 0) {
+       if (ioctl(f, DIOCGDVIRGIN32, dl) < 0) {
+               if (ioctl(f, DIOCGDINFO32, dl) < 0) {
                        warn("ioctl DIOCGDINFO");
                        close(f);
                        return (NULL);
@@ -1483,16 +1498,16 @@ getvirginlabel(void)
        return (dl);
 }
 
-struct disklabel *
+struct disklabel32 *
 getdisklabelfromdisktab(const char *name)
 {
        struct disktab *dt;
-       struct disklabel *dl = &dlab;
+       struct disklabel32 *dl = &dlab;
        int i;
 
        if ((dt = getdisktabbyname(name)) == NULL)
                return(NULL);
-       dl->d_magic = DISKMAGIC;
+       dl->d_magic = DISKMAGIC32;
        dl->d_type = dt->d_typeid;
        dl->d_subtype = 0;
        dl->d_secsize = dt->d_media_blksize;
@@ -1507,12 +1522,12 @@ getdisklabelfromdisktab(const char *name)
        dl->d_cylskew = dt->d_cylskew;
        dl->d_headswitch = dt->d_headswitch;
        dl->d_trkseek = dt->d_trkseek;
-       dl->d_magic2 = DISKMAGIC;
+       dl->d_magic2 = DISKMAGIC32;
        dl->d_npartitions = dt->d_npartitions;
        dl->d_bbsize = dt->d_bbsize;
        dl->d_sbsize = dt->d_sbsize;
        for (i = 0; i < dt->d_npartitions; ++i) {
-               struct partition *dlp = &dl->d_partitions[i];
+               struct partition32 *dlp = &dl->d_partitions[i];
                struct dt_partition *dtp = &dt->d_partitions[i];
 
                dlp->p_size     = dtp->p_size;
@@ -1531,9 +1546,9 @@ getdisklabelfromdisktab(const char *name)
  * clobber bootstrap code.
  */
 void
-setbootflag(struct disklabel *lp)
+setbootflag(struct disklabel32 *lp)
 {
-       struct partition *pp;
+       struct partition32 *pp;
        int i, errors = 0;
        char part;
        u_long boffset;
@@ -1603,6 +1618,104 @@ checkoldboot(int f, const char *bootbuffer)
        return(0);
 }
 
+/*
+ * Traditional 32 bit disklabels actually use absolute sector numbers on
+ * disk, NOT slice relative sector numbres.   The OS hides this from us
+ * when we use DIOC ioctls to access the label, but newer versions of
+ * Dragonfly no longer adjusts the disklabel when snooping reads or writes
+ * so we have to figure it out ourselves.
+ */
+const char *
+fixlabel(int f, struct disklabel32 *lp, int writeadj)
+{
+       const char *msg = NULL;
+       struct partinfo info;
+       struct partition32 *pp;
+       u_int64_t start;
+       u_int64_t end;
+       u_int64_t offset;
+       int part;
+       int rev;
+       int rev_len = sizeof(rev);
+
+       if (sysctlbyname("kern.osrevision", &rev, &rev_len, NULL, 0) < 0) {
+               errx(1, "Cannot use raw mode on non-DragonFly systems\n");
+       }
+       if (rev < 200701) {
+               warnx("Warning running new disklabel on old DragonFly systems,\n"
+                     "assuming the disk layer will fixup the label.\n");
+               sleep(3);
+               return(NULL);
+       }
+
+       pp = &lp->d_partitions[RAW_PART];
+
+       if (forceflag) {
+               info.media_offset = slice_start_lba * lp->d_secsize;
+               info.media_blocks = pp->p_size;
+               info.media_blksize = lp->d_secsize;
+       } else if (ioctl(f, DIOCGPART, &info) < 0) {
+               msg = "Unable to extract the slice starting LBA, "
+                     "you must use the -f <slice_start_lba> option\n"
+                     "to specify it manually, or perhaps try without "
+                     "using -r and let the kernel deal with it\n";
+               return(msg);
+       }
+
+       if (lp->d_magic != DISKMAGIC32 || lp->d_magic2 != DISKMAGIC32)
+               return ("fixlabel: invalid magic");
+       if (dkcksum32(lp) != 0)
+               return ("fixlabel: invalid checksum");
+
+       /*
+        * 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 (writeadj) {
+               /*
+                * incore -> disk
+                */
+               start = 0;
+               offset = info.media_offset / info.media_blksize;
+       } else {
+               /*
+                * disk -> incore
+                */
+               start = info.media_offset / info.media_blksize;
+               offset = -info.media_offset / info.media_blksize;
+       }
+       if (pp->p_offset != start)
+               return ("fixlabel: raw partition offset != slice offset");
+       if (pp->p_size != info.media_blocks) {
+               if (pp->p_size > info.media_blocks)
+                       return ("fixlabel: raw partition size > slice size");
+       }
+       end = start + info.media_blocks;
+       if (start > end)
+               return ("fixlabel: slice wraps");
+       if (lp->d_secpercyl <= 0)
+               return ("fixlabel: d_secpercyl <= 0");
+       pp -= RAW_PART;
+       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) {
+                               /* XXX else silently discard junk. */
+                               bzero(pp, sizeof *pp);
+                       } else {
+                               pp->p_offset += offset;
+                       }
+               }
+       }
+       lp->d_checksum = 0;
+       lp->d_checksum = dkcksum32(lp);
+       return (NULL);
+}
+
 void
 usage(void)
 {
index 772ba71..93ea6ac 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.2 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sbin/gpt/migrate.c,v 1.3 2007/06/18 05:13:39 dillon Exp $
  */
 
 #include <sys/types.h>
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/dtype.h>
 
 #include <err.h>
@@ -68,15 +68,15 @@ static struct gpt_ent*
 migrate_disklabel(int fd, off_t start, struct gpt_ent *ent)
 {
        char *buf;
-       struct disklabel *dl;
+       struct disklabel32 *dl;
        off_t ofs, rawofs;
        int i;
 
-       buf = gpt_read(fd, start + LABELSECTOR, 1);
-       dl = (void*)(buf + LABELOFFSET);
+       buf = gpt_read(fd, start + LABELSECTOR32, 1);
+       dl = (void*)(buf + LABELOFFSET32);
 
-       if (le32toh(dl->d_magic) != DISKMAGIC ||
-           le32toh(dl->d_magic2) != DISKMAGIC) {
+       if (le32toh(dl->d_magic) != DISKMAGIC32 ||
+           le32toh(dl->d_magic2) != DISKMAGIC32) {
                warnx("%s: warning: FreeBSD slice without disklabel",
                    device_name);
                return (ent);
index 1a12e07..10ee31c 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.9 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sbin/vinum/list.c,v 1.10 2007/06/18 05:13:41 dillon Exp $
  */
 
 #define _KERNEL_STRUCTURES
@@ -55,7 +55,7 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/utsname.h>
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <dev/raid/vinum/vinumhdr.h>
 #include "vext.h"
 #include <dev/raid/vinum/request.h>
@@ -1279,7 +1279,7 @@ dumpconfig(char *part)
     int partition;                                         /* UNIX partition */
     int slice;
     int founddrive;                                        /* flag when we find a vinum drive */
-    struct disklabel label;                                /* label of this drive */
+    struct disklabel32 label;                              /* label of this drive */
     int driveno;                                           /* fd of drive */
     int found;
     u_int64_t drivelength;
@@ -1301,7 +1301,7 @@ dumpconfig(char *part)
                fprintf(stderr, "Can't open %s: %s (%d)\n", partname, strerror(errno), errno);
            continue;
        }
-       if (ioctl(driveno, DIOCGDINFO, &label) < 0) {
+       if (ioctl(driveno, DIOCGDINFO32, &label) < 0) {
            fprintf(stderr, "Can't get label from %s: %s (%d)\n", partname, strerror(errno), errno);
            continue;
        }
@@ -1332,7 +1332,7 @@ dumpconfig(char *part)
                fprintf(stderr, "Can't open %s: %s (%d)\n", partname, strerror(errno), errno);
            return;
        }
-       if (ioctl(driveno, DIOCGDINFO, &label) < 0) {
+       if (ioctl(driveno, DIOCGDINFO32, &label) < 0) {
            fprintf(stderr, "Can't get label from %s: %s (%d)\n", partname, strerror(errno), errno);
            return;
        }
index 504d41d..8ecc8eb 100644 (file)
@@ -24,7 +24,7 @@
  * 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.2 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sys/boot/efi/libefi/devicename.c,v 1.3 2007/06/18 05:13:41 dillon Exp $
  */
 
 #include <stand.h>
@@ -133,7 +133,7 @@ efi_parsedev(struct efi_devdesc **dev, const char *devspec, const char **path)
                        }
                        if (*cp && (*cp != ':')) {
                                partition = *cp - 'a';          /* get a partition number */
-                               if ((partition < 0) || (partition >= MAXPARTITIONS)) {
+                               if ((partition < 0) || (partition >= MAXPARTITIONS32)) {
                                        err = EPART;
                                        goto fail;
                                }
index 9e8df7b..11aa5cc 100644 (file)
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/boot/ia64/libski/devicename.c,v 1.2 2003/09/08 09:11:32 obrien Exp $
- * $DragonFly: src/sys/boot/ia64/libski/devicename.c,v 1.1 2003/11/10 06:08:37 dillon Exp $
+ * $DragonFly: src/sys/boot/ia64/libski/devicename.c,v 1.2 2007/06/18 05:13:41 dillon Exp $
  */
 
 #include <stand.h>
 #include <string.h>
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include "bootstrap.h"
 #include "libski.h"
 
@@ -131,7 +131,7 @@ ski_parsedev(struct ski_devdesc **dev, const char *devspec, const char **path)
                        }
                        if (*cp && (*cp != ':')) {
                                partition = *cp - 'a';          /* get a partition number */
-                               if ((partition < 0) || (partition >= MAXPARTITIONS)) {
+                               if ((partition < 0) || (partition >= MAXPARTITIONS32)) {
                                        err = EPART;
                                        goto fail;
                                }
index d727c17..e283e7f 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.15 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sys/boot/pc32/boot2/boot2.c,v 1.16 2007/06/18 05:13:42 dillon Exp $
  */
 #include <sys/param.h>
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/diskslice.h>
 #include <sys/diskmbr.h>
 #include <sys/dtype.h>
@@ -517,7 +517,7 @@ static int
 dskread(void *buf, unsigned lba, unsigned nblk)
 {
     struct dos_partition *dp;
-    struct disklabel *d;
+    struct disklabel32 *d;
     char *sec;
     unsigned sl, i;
 
@@ -549,10 +549,10 @@ dskread(void *buf, unsigned lba, unsigned nblk)
            }
            dsk.start = dp->dp_start;
        }
-       if (drvread(sec, dsk.start + LABELSECTOR, 1))
+       if (drvread(sec, dsk.start + LABELSECTOR32, 1))
                return -1;
-       d = (void *)(sec + LABELOFFSET);
-       if (d->d_magic != DISKMAGIC || d->d_magic2 != DISKMAGIC) {
+       d = (void *)(sec + LABELOFFSET32);
+       if (d->d_magic != DISKMAGIC32 || d->d_magic2 != DISKMAGIC32) {
            if (dsk.part != RAW_PART) {
                printf(INVALID_S, "label");
                return -1;
index ff114fb..6346366 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.11 2007/06/17 23:50:15 dillon Exp $
+ * $DragonFly: src/sys/boot/pc32/libi386/biosdisk.c,v 1.12 2007/06/18 05:13:42 dillon Exp $
  */
 
 /*
@@ -39,7 +39,7 @@
 
 #include <stand.h>
 
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/diskmbr.h>
 #include <sys/dtype.h>
 #include <machine/bootinfo.h>
@@ -82,7 +82,7 @@ struct open_disk {
 #define BD_FLOPPY              0x0004
 #define BD_LABELOK             0x0008
 #define BD_PARTTABOK           0x0010
-    struct disklabel           od_disklabel;
+    struct disklabel32         od_disklabel;
     int                                od_nslices;     /* slice count */
     struct dos_partition       od_slicetab[NEXTDOSPART];
 };
@@ -370,14 +370,14 @@ bd_printbsdslice(struct open_disk *od, daddr_t offset, char *prefix,
 {
     char               line[80];
     char               buf[BIOSDISK_SECSIZE];
-    struct disklabel   *lp;
+    struct disklabel32 *lp;
     int                        i;
 
     /* read disklabel */
-    if (bd_read(od, offset + LABELSECTOR, 1, buf))
+    if (bd_read(od, offset + LABELSECTOR32, 1, buf))
        return;
-    lp =(struct disklabel *)(&buf[0]);
-    if (lp->d_magic != DISKMAGIC) {
+    lp =(struct disklabel32 *)(&buf[0]);
+    if (lp->d_magic != DISKMAGIC32) {
        sprintf(line, "%s: FFS  bad disklabel\n", prefix);
        pager_output(line);
        return;
@@ -453,7 +453,7 @@ static int
 bd_opendisk(struct open_disk **odp, struct i386_devdesc *dev)
 {
     struct dos_partition       *dptr;
-    struct disklabel           *lp;
+    struct disklabel32         *lp;
     struct open_disk           *od;
     int                                sector, slice, i;
     int                                error;
@@ -610,17 +610,17 @@ bd_opendisk(struct open_disk **odp, struct i386_devdesc *dev)
        DEBUG("opening raw slice");
     } else {
        
-       if (bd_read(od, sector + LABELSECTOR, 1, buf)) {
+       if (bd_read(od, sector + LABELSECTOR32, 1, buf)) {
            DEBUG("error reading disklabel");
            error = EIO;
            goto out;
        }
-       DEBUG("copy %d bytes of label from %p to %p", sizeof(struct disklabel), buf + LABELOFFSET, &od->od_disklabel);
-       bcopy(buf + LABELOFFSET, &od->od_disklabel, sizeof(struct disklabel));
+       DEBUG("copy %d bytes of label from %p to %p", sizeof(struct disklabel32), buf + LABELOFFSET32, &od->od_disklabel);
+       bcopy(buf + LABELOFFSET32, &od->od_disklabel, sizeof(struct disklabel32));
        lp = &od->od_disklabel;
        od->od_flags |= BD_LABELOK;
 
-       if (lp->d_magic != DISKMAGIC) {
+       if (lp->d_magic != DISKMAGIC32) {
            DEBUG("no disklabel");
            error = ENOENT;
            goto out;
index c921b05..7160b14 100644 (file)
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/boot/i386/libi386/devicename.c,v 1.6 2003/08/25 23:28:31 obrien Exp $
- * $DragonFly: src/sys/boot/pc32/libi386/devicename.c,v 1.3 2003/11/10 06:08:36 dillon Exp $
+ * $DragonFly: src/sys/boot/pc32/libi386/devicename.c,v 1.4 2007/06/18 05:13:42 dillon Exp $
  */
 
 #include <stand.h>
 #include <string.h>
-#include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include "bootstrap.h"
 #include "libi386.h"
 
@@ -130,7 +130,7 @@ i386_parsedev(struct i386_devdesc **dev, const char *devspec, const char **path)
            }
            if (*cp && (*cp != ':')) {
                partition = *cp - 'a';          /* get a partition number */
-               if ((partition < 0) || (partition >= MAXPARTITIONS)) {
+               if ((partition < 0) || (partition >= MAXPARTITIONS32)) {
                    err = EPART;
                    goto fail;
                }
index 903fb18..06f0ef0 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/sys/conf/files,v 1.340.2.137 2003/06/04 17:10:30 sam Exp $
-# $DragonFly: src/sys/conf/files,v 1.163 2007/06/17 20:33:14 swildner Exp $
+# $DragonFly: src/sys/conf/files,v 1.164 2007/06/18 05:13:32 dillon Exp $
 #
 # The long compile-with and dependency lines are required because of
 # limitations in config: backslash-newline doesn't work in strings, and
@@ -579,6 +579,8 @@ kern/subr_autoconf.c        standard
 kern/subr_bus.c                standard
 kern/subr_devstat.c    standard
 kern/subr_disk.c       standard
+kern/subr_disklabel32.c        standard
+kern/subr_disklabel64.c        standard
 kern/subr_diskslice.c  standard
 kern/subr_eventhandler.c       standard
 kern/subr_kcore.c      standard
index 6ece8d9..3b3f49e 100644 (file)
@@ -89,7 +89,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_disklabel32.c,v 1.1 2007/06/17 23:50:16 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_disklabel32.c,v 1.2 2007/06/18 05:13:42 dillon Exp $
  */
 
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/diskslice.h>
 #include <sys/disk.h>
 #include <sys/dtype.h>         /* DTYPE_* constants */
 #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 partition_info(const char *sname, int part, struct partition32 *pp);
 static void slice_info(const char *sname, struct diskslice *sp);
+static const char *l32_fixlabel(const char *sname, struct diskslice *sp,
+                               disklabel_t lpx, int writeflag);
 
 /*
  * 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)
+static int
+l32_getpartbounds(disklabel_t lp, u_int32_t part,
+                 u_int64_t *start, u_int64_t *blocks)
 {
-       struct partition *pp;
+       struct partition32 *pp;
 
-       if (part >= lp->d_npartitions)
+       if (part >= lp.lab32->d_npartitions)
                return (EINVAL);
-       pp = &lp->d_partitions[part];
+       pp = &lp.lab32->d_partitions[part];
        *blocks = pp->p_size;
        *start = pp->p_offset;
        return(0);
 }
 
-int
-getpartfstype(struct disklabel *lp, u_int32_t part)
+static int
+l32_getpartfstype(disklabel_t lp, u_int32_t part)
 {
-       struct partition *pp;
+       struct partition32 *pp;
 
-       if (part >= lp->d_npartitions)
+       if (part >= lp.lab32->d_npartitions)
                return (0);
-       pp = &lp->d_partitions[part];
+       pp = &lp.lab32->d_partitions[part];
        return(pp->p_fstype);
 }
 
-u_int32_t
-getnumparts(struct disklabel *lp)
+static u_int32_t
+l32_getnumparts(disklabel_t lp)
 {
-       return(lp->d_npartitions);
+       return(lp.lab32->d_npartitions);
 }
 
 /*
@@ -160,34 +163,43 @@ getnumparts(struct disklabel *lp)
  * 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)
+static const char *
+l32_readdisklabel(cdev_t dev, struct diskslice *sp, disklabel_t *lpp,
+               struct disk_info *info)
 {
+       disklabel_t lpx;
        struct buf *bp;
-       struct disklabel *dlp;
-       char *msg = NULL;
+       struct disklabel32 *dlp;
+       const char *msg = NULL;
+       int secsize = info->d_media_blksize;
 
-       bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
-       bp->b_bcount = lp->d_secsize;
+       bp = geteblk(secsize);
+       bp->b_bio1.bio_offset = (off_t)LABELSECTOR32 * secsize;
+       bp->b_bcount = 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) {
+       else for (dlp = (struct disklabel32 *)bp->b_data;
+           dlp <= (struct disklabel32 *)((char *)bp->b_data +
+           secsize - sizeof(*dlp));
+           dlp = (struct disklabel32 *)((char *)dlp + sizeof(long))) {
+               if (dlp->d_magic != DISKMAGIC32 ||
+                   dlp->d_magic2 != DISKMAGIC32) {
                        if (msg == NULL)
                                msg = "no disk label";
                } else if (dlp->d_npartitions > MAXPARTITIONS ||
-                          dkcksum(dlp) != 0)
+                          dkcksum32(dlp) != 0) {
                        msg = "disk label corrupted";
-               else {
-                       *lp = *dlp;
-                       msg = NULL;
+               } else {
+                       lpx.lab32 = dlp;
+                       msg = l32_fixlabel(NULL, sp, lpx, FALSE);
+                       if (msg == NULL) {
+                               (*lpp).lab32 = kmalloc(sizeof(*dlp),
+                                                      M_DEVBUF, M_WAITOK|M_ZERO);
+                               *(*lpp).lab32 = *dlp;
+                       }
                        break;
                }
        }
@@ -199,19 +211,23 @@ readdisklabel(cdev_t dev, struct disklabel *lp)
 /*
  * Check new disk label for sensibility before setting it.
  */
-int
-setdisklabel(struct disklabel *olp, struct disklabel *nlp,
-            struct diskslice *sp, u_int32_t *openmask)
+static int
+l32_setdisklabel(disklabel_t olpx, disklabel_t nlpx,
+                struct diskslice *sp, u_int32_t *openmask)
 {
-       struct partition *opp, *npp;
+       struct disklabel32 *olp, *nlp;
+       struct partition32 *opp, *npp;
        int part;
        int i;
 
+       olp = olpx.lab32;
+       nlp = nlpx.lab32;
+
        /*
         * Check it is actually a disklabel we are looking at.
         */
-       if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
-           dkcksum(nlp) != 0)
+       if (nlp->d_magic != DISKMAGIC32 || nlp->d_magic2 != DISKMAGIC32 ||
+           dkcksum32(nlp) != 0)
                return (EINVAL);
 
        /*
@@ -249,7 +265,7 @@ setdisklabel(struct disklabel *olp, struct disklabel *nlp,
                ++i;
        }
        nlp->d_checksum = 0;
-       nlp->d_checksum = dkcksum(nlp);
+       nlp->d_checksum = dkcksum32(nlp);
        *olp = *nlp;
 
        if (olp->d_partitions[RAW_PART].p_offset)
@@ -266,17 +282,21 @@ setdisklabel(struct disklabel *olp, struct disklabel *nlp,
 /*
  * Write disk label back to device after modification.
  */
-int
-writedisklabel(cdev_t dev, struct disklabel *lp)
+static int
+l32_writedisklabel(cdev_t dev, struct diskslice *sp, disklabel_t lpx)
 {
+       struct disklabel32 *lp;
+       struct disklabel32 *dlp;
        struct buf *bp;
-       struct disklabel *dlp;
+       const char *msg;
        int error = 0;
 
+       lp = lpx.lab32;
+
        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_bio1.bio_offset = (off_t)LABELSECTOR32 * lp->d_secsize;
        bp->b_bcount = lp->d_secsize;
 #if 1
        /*
@@ -292,16 +312,23 @@ writedisklabel(cdev_t dev, struct disklabel *lp)
        error = biowait(bp);
        if (error)
                goto done;
-       for (dlp = (struct disklabel *)bp->b_data;
-           dlp <= (struct disklabel *)
+       for (dlp = (struct disklabel32 *)bp->b_data;
+           dlp <= (struct disklabel32 *)
              ((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 = (struct disklabel32 *)((char *)dlp + sizeof(long))) {
+               if (dlp->d_magic == DISKMAGIC32 &&
+                   dlp->d_magic2 == DISKMAGIC32 && dkcksum32(dlp) == 0) {
                        *dlp = *lp;
-                       bp->b_cmd = BUF_CMD_WRITE;
-                       dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART), &bp->b_bio1);
-                       error = biowait(bp);
+                       lpx.lab32 = dlp;
+                       msg = l32_fixlabel(NULL, sp, lpx, TRUE);
+                       if (msg) {
+                               error = EINVAL;
+                       } else {
+                               bp->b_cmd = BUF_CMD_WRITE;
+                               dev_dstrategy(dkmodpart(dev, WHOLE_SLICE_PART),
+                                             &bp->b_bio1);
+                               error = biowait(bp);
+                       }
                        goto done;
                }
        }
@@ -309,7 +336,7 @@ writedisklabel(cdev_t dev, struct disklabel *lp)
 done:
 #else
        bzero(bp->b_data, lp->d_secsize);
-       dlp = (struct disklabel *)bp->b_data;
+       dlp = (struct disklabel32 *)bp->b_data;
        *dlp = *lp;
        bp->b_flags &= ~B_INVAL;
        bp->b_cmd = BUF_CMD_WRITE;
@@ -328,73 +355,76 @@ done:
  *
  * If a diskslice is passed, the label is truncated to the slice
  */
-struct disklabel *
-clone_label(struct disk_info *info, struct diskslice *sp)
+static disklabel_t
+l32_clone_label(struct disk_info *info, struct diskslice *sp)
 {
-       struct disklabel *lp1;
+       struct disklabel32 *lp;
+       disklabel_t res;
 
-       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;
+       lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK | M_ZERO);
+       lp->d_nsectors = info->d_secpertrack;
+       lp->d_ntracks = info->d_nheads;
+       lp->d_secpercyl = info->d_secpercyl;
+       lp->d_secsize = info->d_media_blksize;
 
        if (sp)
-               lp1->d_secperunit = (u_int)sp->ds_size;
+               lp->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;
+               lp->d_secperunit = (u_int)info->d_media_blocks;
+
+       if (lp->d_typename[0] == '\0')
+               strncpy(lp->d_typename, "amnesiac", sizeof(lp->d_typename));
+       if (lp->d_packname[0] == '\0')
+               strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
+       if (lp->d_nsectors == 0)
+               lp->d_nsectors = 32;
+       if (lp->d_ntracks == 0)
+               lp->d_ntracks = 64;
+       lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
+       lp->d_ncylinders = lp->d_secperunit / lp->d_secpercyl;
+       if (lp->d_rpm == 0)
+               lp->d_rpm = 3600;
+       if (lp->d_interleave == 0)
+               lp->d_interleave = 1;
+       if (lp->d_npartitions < RAW_PART + 1)
+               lp->d_npartitions = MAXPARTITIONS;
+       if (lp->d_bbsize == 0)
+               lp->d_bbsize = BBSIZE;
+       if (lp->d_sbsize == 0)
+               lp->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;
+       lp->d_partitions[RAW_PART].p_size = lp->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;
+               lp->d_partitions[0].p_size = lp->d_secperunit;
+               lp->d_partitions[0].p_fstype = FS_OTHER;
        }
-       lp1->d_magic = DISKMAGIC;
-       lp1->d_magic2 = DISKMAGIC;
-       lp1->d_checksum = dkcksum(lp1);
-       return (lp1);
+       lp->d_magic = DISKMAGIC32;
+       lp->d_magic2 = DISKMAGIC32;
+       lp->d_checksum = dkcksum32(lp);
+       res.lab32 = lp;
+       return (res);
 }
 
-void
-makevirginlabel(struct disklabel *lp, struct diskslices *ssp,
-               struct diskslice *sp, struct disk_info *info)
+static void
+l32_makevirginlabel(disklabel_t lpx, struct diskslices *ssp,
+                   struct diskslice *sp, struct disk_info *info)
 {
-       struct partition *pp;
+       struct disklabel32 *lp = lpx.lab32;
+       struct partition32 *pp;
 
-       if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label) {
-               bcopy(ssp->dss_slices[WHOLE_DISK_SLICE].ds_label, lp,
-                     sizeof(*lp));
+       if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label.opaque) {
+               bcopy(ssp->dss_slices[WHOLE_DISK_SLICE].ds_label.opaque, lp,
+                     sizeof(struct disklabel32));
        } else {
                bzero(lp, sizeof(*lp));
        }
-       lp->d_magic = DISKMAGIC;
-       lp->d_magic2 = DISKMAGIC;
+       lp->d_magic = DISKMAGIC32;
+       lp->d_magic2 = DISKMAGIC32;
 
        lp->d_npartitions = MAXPARTITIONS;
        if (lp->d_interleave == 0)
@@ -441,23 +471,27 @@ makevirginlabel(struct disklabel *lp, struct diskslices *ssp,
                pp->p_fstype = FS_OTHER;
        }
        lp->d_checksum = 0;
-       lp->d_checksum = dkcksum(lp);
+       lp->d_checksum = dkcksum32(lp);
 }
 
-char *
-fixlabel(const char *sname, struct diskslice *sp, struct disklabel *lp, int writeflag)
+static const char *
+l32_fixlabel(const char *sname, struct diskslice *sp,
+            disklabel_t lpx, int writeflag)
 {
+       struct disklabel32 *lp;
+       struct partition32 *pp;
        u_int64_t start;
        u_int64_t end;
        u_int64_t offset;
        int part;
-       struct partition *pp;
        int warned;
 
+       lp = lpx.lab32;
+
        /* These errors "can't happen" so don't bother reporting details. */
-       if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
+       if (lp->d_magic != DISKMAGIC32 || lp->d_magic2 != DISKMAGIC32)
                return ("fixlabel: invalid magic");
-       if (dkcksum(lp) != 0)
+       if (dkcksum32(lp) != 0)
                return ("fixlabel: invalid checksum");
 
        pp = &lp->d_partitions[RAW_PART];
@@ -531,14 +565,15 @@ fixlabel(const char *sname, struct diskslice *sp, struct disklabel *lp, int writ
        lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
        lp->d_secperunit = sp->ds_size;
        lp->d_checksum = 0;
-       lp->d_checksum = dkcksum(lp);
+       lp->d_checksum = dkcksum32(lp);
        return (NULL);
 }
 
-void
-adjust_label_reserved(struct diskslices *ssp, int slice, struct diskslice *sp)
+static void
+l32_adjust_label_reserved(struct diskslices *ssp, int slice,
+                         struct diskslice *sp)
 {
-       struct disklabel *lp = sp->ds_label;
+       struct disklabel32 *lp = sp->ds_label.lab32;
 
        /*
         * If the slice is not the whole-disk slice, setup the reserved
@@ -573,7 +608,7 @@ adjust_label_reserved(struct diskslices *ssp, int slice, struct diskslice *sp)
 }
 
 static void
-partition_info(const char *sname, int part, struct partition *pp)
+partition_info(const char *sname, int part, struct partition32 *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),
@@ -587,3 +622,17 @@ slice_info(const char *sname, struct diskslice *sp)
               sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
 }
 
+struct disklabel_ops disklabel32_ops = {
+       .labelsect = LABELSECTOR32,
+       .labelsize = sizeof(struct disklabel32),
+       .op_readdisklabel = l32_readdisklabel,
+       .op_setdisklabel = l32_setdisklabel,
+       .op_writedisklabel = l32_writedisklabel,
+       .op_clone_label = l32_clone_label,
+       .op_adjust_label_reserved = l32_adjust_label_reserved,
+       .op_getpartbounds = l32_getpartbounds,
+       .op_getpartfstype = l32_getpartfstype,
+       .op_getnumparts = l32_getnumparts,
+       .op_makevirginlabel = l32_makevirginlabel
+};
+
index 42c61d9..c2fd6a1 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.45 2007/06/17 23:50:16 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.46 2007/06/18 05:13:42 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -52,6 +52,7 @@
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/disklabel.h>
+#include <sys/disklabel32.h>
 #include <sys/diskslice.h>
 #include <sys/disk.h>
 #include <sys/diskmbr.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 dsiodone (struct bio *bio);
 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 set_ds_label (struct diskslices *ssp, int slice,
-                             struct disklabel *lp);
+static void set_ds_label (struct diskslices *ssp, int slice, disklabel_t lp);
 static void set_ds_wlabel (struct diskslices *ssp, int slice, int wlabel);
 
+#define ops    (&disklabel32_ops)
+
 /*
  * Determine the size of the transfer, and make sure it is
  * within the boundaries of the partition. Adjust transfer
@@ -96,8 +97,7 @@ dscheck(cdev_t dev, struct bio *bio, struct diskslices *ssp)
 {
        struct buf *bp = bio->bio_buf;
        struct bio *nbio;
-       struct disklabel *lp;
-       char *msg;
+       disklabel_t lp;
        long nsec;
        u_int64_t secno;
        u_int64_t endsecno;
@@ -107,7 +107,6 @@ dscheck(cdev_t dev, struct bio *bio, struct diskslices *ssp)
        u_int32_t slice;
        int shift;
        int mask;
-       int snoop;
 
        slice = dkslice(dev);
        part  = dkpart(dev);
@@ -156,9 +155,7 @@ doshift:
        if (slice == WHOLE_DISK_SLICE) {
                /*
                 * Labels have not been allowed on whole-disks for a while.
-                * This really puts the nail in the coffin... no disk
-                * snooping will occur even if you tried to write a label
-                * without a slice structure.
+                * This really puts the nail in the coffin.
                 *
                 * Accesses to the WHOLE_DISK_SLICE do not use a disklabel
                 * and partition numbers are special-cased.  Currently numbers
@@ -170,7 +167,7 @@ doshift:
                 * sector size for the special raw access may not be the
                 * same as the nominal sector size for the device.
                 */
-               lp = NULL;
+               lp.opaque = NULL;
                if (part < 128) {
                        kprintf("dscheck(%s): illegal partition number (%d) "
                                "for WHOLE_DISK_SLICE access\n",
@@ -189,35 +186,26 @@ doshift:
                 */
                endsecno = sp->ds_size;
                slicerel_secno = secno;
-               snoop = 0;
        } else if (part == WHOLE_SLICE_PART) {
                /* 
-                * We are accessing a slice.  Enable snooping of the bsd
-                * label.  Note that snooping only occurs if ds_reserved
-                * is also non-zero.  ds_reserved will be non-zero if
-                * an in-core label is present or snooping has been
-                * explicitly requested via an ioctl().
-                *
                 * NOTE! opens on a whole-slice partition will not attempt
                 * to read a disklabel in, so there may not be an in-core
                 * disklabel even if there is one on the disk.
                 */
                endsecno = sp->ds_size;
                slicerel_secno = secno;
-               snoop = 1;
-       } else if ((lp = sp->ds_label) != NULL) {
+       } else if ((lp = sp->ds_label).opaque != NULL) {
                /*
                 * 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.
                 */
-               if (getpartbounds(lp, part, &slicerel_secno, &endsecno)) {
+               if (ops->op_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 {
                /*
                 * Attempt to access partition when no disklabel present
@@ -281,42 +269,6 @@ doshift:
        nbio = push_bio(bio);
        nbio->bio_offset = (off_t)(sp->ds_offset + slicerel_secno) * 
                           ssp->dss_secsize;
-
-       /*
-        * Snoop reads and writes to the label area - only done if
-        * snoop is non-zero, ds_reserved is non-zero, and the
-        * read covers the label sector.
-        */
-       if (snoop && slicerel_secno < sp->ds_reserved &&
-           slicerel_secno <= LABELSECTOR &&
-           nsec && slicerel_secno + nsec > LABELSECTOR) {
-               /* 
-                * Set up our own callback on I/O completion to handle
-                * undoing the fixup we did for the write as well as
-                * doing the fixup for a read.
-                *
-                * Set info2.offset to the offset within the buffer containing
-                * the start of the label.
-                */
-               nbio->bio_done = dsiodone;
-               nbio->bio_caller_info1.ptr = sp;
-               nbio->bio_caller_info2.offset =
-                       (LABELSECTOR - slicerel_secno) * ssp->dss_secsize;
-               if (bp->b_cmd != BUF_CMD_READ) {
-                       msg = fixlabel(
-                               NULL, sp,
-                              (struct disklabel *)
-                              (bp->b_data + (int)nbio->bio_caller_info2.offset),
-                              TRUE);
-                       if (msg != NULL) {
-                               kprintf("dscheck(%s): %s\n", 
-                                   devtoname(dev), msg);
-                               bp->b_error = EROFS;
-                               pop_bio(nbio);
-                               goto error;
-                       }
-               }
-       }
        return (nbio);
 
 bad_bcount:
@@ -386,10 +338,10 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
        struct diskslices **sspp, struct disk_info *info)
 {
        int error;
-       struct disklabel *lp;
+       disklabel_t lp;
+       disklabel_t lptmp;
        int old_wlabel;
        u_int32_t openmask[DKMAXPARTITIONS/(sizeof(u_int32_t)*8)];
-       u_int64_t old_reserved;
        int part;
        int slice;
        struct diskslice *sp;
@@ -404,7 +356,7 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
        lp = sp->ds_label;
 
        switch (cmd) {
-       case DIOCGDVIRGIN:
+       case DIOCGDVIRGIN32:
                /*
                 * You can only retrieve a virgin disklabel on the whole
                 * disk slice or whole-slice partition.
@@ -414,11 +366,11 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                        return(EINVAL);
                }
 
-               lp = (struct disklabel *)data;
-               makevirginlabel(lp, ssp, sp, info);
+               lp.opaque = data;
+               ops->op_makevirginlabel(lp, ssp, sp, info);
                return (0);
 
-       case DIOCGDINFO:
+       case DIOCGDINFO32:
                /*
                 * You can only retrieve a disklabel on the whole
                 * slice partition.
@@ -436,12 +388,12 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                    (info->d_dsflags & DSO_COMPATLABEL) == 0) {
                        return (ENODEV);
                }
-               if (sp->ds_label == NULL) {
+               if (sp->ds_label.opaque == NULL) {
                        error = dsreadandsetlabel(dev, info->d_dsflags,
                                                  ssp, sp, info);
                }
                if (error == 0)
-                       *(struct disklabel *)data = *sp->ds_label;
+                       bcopy(sp->ds_label.opaque, data, ops->labelsize);
                return (error);
 
        case DIOCGPART:
@@ -456,7 +408,8 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                         *
                         * We ignore any error.
                         */
-                       if (sp->ds_label == NULL && part == WHOLE_SLICE_PART &&
+                       if (sp->ds_label.opaque == NULL &&
+                           part == WHOLE_SLICE_PART &&
                            slice != WHOLE_DISK_SLICE) {
                                dsreadandsetlabel(dev, info->d_dsflags,
                                                  ssp, sp, info);
@@ -475,11 +428,11 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                            part != WHOLE_SLICE_PART) {
                                u_int64_t start;
                                u_int64_t blocks;
-                               if (lp == NULL)
+                               if (lp.opaque == NULL)
                                        return(EINVAL);
-                               if (getpartbounds(lp, part, &start, &blocks))
+                               if (ops->op_getpartbounds(lp, part, &start, &blocks))
                                        return(EINVAL);
-                               dpart->fstype = getpartfstype(lp, part);
+                               dpart->fstype = ops->op_getpartfstype(lp, part);
                                dpart->media_offset += start *
                                                       info->d_media_blksize;
                                dpart->media_size = blocks *
@@ -512,7 +465,7 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                                 (char *)ssp);
                return (0);
 
-       case DIOCSDINFO:
+       case DIOCSDINFO32:
                /*
                 * You can write a disklabel on the whole disk slice or
                 * whole-slice partition.
@@ -532,20 +485,20 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
 
                if (!(flags & FWRITE))
                        return (EBADF);
-               lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK);
-               if (sp->ds_label == NULL)
-                       bzero(lp, sizeof *lp);
+               lp.opaque = kmalloc(ops->labelsize, M_DEVBUF, M_WAITOK);
+               if (sp->ds_label.opaque == NULL)
+                       bzero(lp.opaque, ops->labelsize);
                else
-                       bcopy(sp->ds_label, lp, sizeof *lp);
-               if (sp->ds_label == NULL) {
+                       bcopy(sp->ds_label.opaque, lp.opaque, ops->labelsize);
+               if (sp->ds_label.opaque == NULL) {
                        bzero(openmask, sizeof(openmask));
                } else {
                        bcopy(sp->ds_openmask, openmask, sizeof(openmask));
                }
-               error = setdisklabel(lp, (struct disklabel *)data,
-                                    sp, openmask);
+               lptmp.opaque = data;
+               error = ops->op_setdisklabel(lp, lptmp, sp, openmask);
                if (error != 0) {
-                       kfree(lp, M_DEVBUF);
+                       kfree(lp.opaque, M_DEVBUF);
                        return (error);
                }
                free_ds_label(ssp, slice);
@@ -588,11 +541,8 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                 * complete, then lock out future accesses and opens.
                 */
                *sspp = NULL;
-               lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK);
-               *lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
                error = dsopen(dev, S_IFCHR, ssp->dss_oflags, sspp, info);
                if (error != 0) {
-                       kfree(lp, M_DEVBUF);
                        *sspp = ssp;
                        return (error);
                }
@@ -611,19 +561,17 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                                               S_IFCHR, ssp->dss_oflags, sspp,
                                               info);
                                if (error != 0) {
-                                       kfree(lp, M_DEVBUF);
                                        *sspp = ssp;
                                        return (EBUSY);
                                }
                        }
                }
 
-               kfree(lp, M_DEVBUF);
                dsgone(&ssp);
                return (0);
 
-       case DIOCWDINFO:
-               error = dsioctl(dev, DIOCSDINFO, data, flags, &ssp, info);
+       case DIOCWDINFO32:
+               error = dsioctl(dev, DIOCSDINFO32, data, flags, &ssp, info);
                if (error != 0)
                        return (error);
 
@@ -632,29 +580,11 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
                 */
                old_wlabel = sp->ds_wlabel;
                set_ds_wlabel(ssp, slice, TRUE);
-               old_reserved = sp->ds_reserved;
-               sp->ds_reserved = SBSIZE / ssp->dss_secsize;
-               error = writedisklabel(dev, sp->ds_label);
+               error = ops->op_writedisklabel(dev, sp, sp->ds_label);
                set_ds_wlabel(ssp, slice, old_wlabel);
-               sp->ds_reserved = old_reserved;
                /* XXX should invalidate in-core label if write failed. */
                return (error);
 
-       case DIOCSETSNOOP:
-               /*
-                * Set label snooping even if there is no label present.
-                */
-               if (slice == WHOLE_DISK_SLICE || part != WHOLE_SLICE_PART)
-                       return (EINVAL);
-               if (lp == NULL) {
-                       if (*(int *)data) {
-                               sp->ds_reserved = SBSIZE / ssp->dss_secsize;
-                       } else {
-                               sp->ds_reserved = 0;
-                       }
-               }
-               return (0);
-
        case DIOCWLABEL:
                if (slice == WHOLE_DISK_SLICE)
                        return (ENODEV);
@@ -668,27 +598,6 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
        }
 }
 
-/*
- * Chain the bio_done.  b_cmd remains valid through such chaining.
- */
-static void
-dsiodone(struct bio *bio)
-{
-       struct buf *bp = bio->bio_buf;
-       char *msg;
-
-       if (bp->b_cmd != BUF_CMD_READ
-           || (!(bp->b_flags & B_ERROR) && bp->b_error == 0)) {
-               msg = fixlabel(NULL, bio->bio_caller_info1.ptr,
-                              (struct disklabel *)
-                              (bp->b_data + (int)bio->bio_caller_info2.offset),
-                              FALSE);
-               if (msg != NULL)
-                       kprintf("%s\n", msg);
-       }
-       biodone(bio->bio_prev);
-}
-
 int
 dsisopen(struct diskslices *ssp)
 {
@@ -903,7 +812,7 @@ dsopen(cdev_t dev, int mode, u_int flags,
                 * template.
                 */
                sp = &ssp->dss_slices[WHOLE_DISK_SLICE];
-               sp->ds_label = clone_label(info, NULL);
+               sp->ds_label = ops->op_clone_label(info, NULL);
                sp->ds_wlabel = TRUE;
                sp->ds_reserved = 0;
        }
@@ -927,7 +836,7 @@ dsopen(cdev_t dev, int mode, u_int flags,
        sp = &ssp->dss_slices[slice];
        part = dkpart(dev);
 
-       if ((flags & DSO_NOLABELS) == 0 && sp->ds_label == NULL) {
+       if ((flags & DSO_NOLABELS) == 0 && sp->ds_label.opaque == NULL) {
                dev1 = dkmodslice(dkmodpart(dev, WHOLE_SLICE_PART), slice);
 
                /*
@@ -953,8 +862,10 @@ 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 >= getnumparts(sp->ds_label))
+               if (sp->ds_label.opaque == NULL ||
+                   part >= ops->op_getnumparts(sp->ds_label)) {
                        return (EINVAL);
+               }
        }
        dssetmask(sp, part);
 
@@ -983,34 +894,29 @@ dsreadandsetlabel(cdev_t dev, u_int flags,
                  struct diskslices *ssp, struct diskslice *sp,
                  struct disk_info *info)
 {
-       struct disklabel *lp1;
+       disklabel_t lp;
        const char *msg;
        const char *sname;
        char partname[2];
        int slice = dkslice(dev);
-       u_int64_t old_reserved;
+
+       lp.opaque = NULL;
 
        sname = dsname(dev, dkunit(dev), slice, WHOLE_SLICE_PART, partname);
-       lp1 = clone_label(info, sp);
-       old_reserved = sp->ds_reserved;
-       sp->ds_reserved = 0;
-       msg = readdisklabel(dev, lp1);
-       sp->ds_reserved = old_reserved;
+       msg = ops->op_readdisklabel(dev, sp, &lp, info);
 
        if (msg != NULL && (flags & DSO_COMPATLABEL)) {
                msg = NULL;
-               kfree(lp1, M_DEVBUF);
-               lp1 = clone_label(info, sp);
+               lp = ops->op_clone_label(info, sp);
        }
-       if (msg == NULL)
-               msg = fixlabel(sname, sp, lp1, FALSE);
        if (msg != NULL) {
                if (sp->ds_type == DOSPTYP_386BSD /* XXX */)
                        log(LOG_WARNING, "%s: cannot find label (%s)\n",
                            sname, msg);
-               kfree(lp1, M_DEVBUF);
+               if (lp.opaque)
+                       kfree(lp.opaque, M_DEVBUF);
        } else {
-               set_ds_label(ssp, slice, lp1);
+               set_ds_label(ssp, slice, lp);
                set_ds_wlabel(ssp, slice, FALSE);
        }
        return (msg ? EINVAL : 0);
@@ -1019,7 +925,7 @@ dsreadandsetlabel(cdev_t dev, u_int flags,
 int64_t
 dssize(cdev_t dev, struct diskslices **sspp)
 {
-       struct disklabel *lp;
+       disklabel_t lp;
        int part;
        int slice;
        struct diskslices *ssp;
@@ -1037,9 +943,9 @@ dssize(cdev_t dev, struct diskslices **sspp)
                ssp = *sspp;
        }
        lp = ssp->dss_slices[slice].ds_label;
-       if (lp == NULL)
+       if (lp.opaque == NULL)
                return (-1);
-       if (getpartbounds(lp, part, &start, &blocks))
+       if (ops->op_getpartbounds(lp, part, &start, &blocks))
                return (-1);
        return ((int64_t)blocks);
 }
@@ -1047,24 +953,25 @@ dssize(cdev_t dev, struct diskslices **sspp)
 static void
 free_ds_label(struct diskslices *ssp, int slice)
 {
-       struct disklabel *lp;
        struct diskslice *sp;
+       disklabel_t lp;
 
        sp = &ssp->dss_slices[slice];
        lp = sp->ds_label;
-       if (lp == NULL)
-               return;
-       kfree(lp, M_DEVBUF);
-       set_ds_label(ssp, slice, (struct disklabel *)NULL);
+       if (lp.opaque != NULL) {
+               kfree(lp.opaque, M_DEVBUF);
+               lp.opaque = NULL;
+               set_ds_label(ssp, slice, lp);
+       }
 }
 
 static void
-set_ds_label(struct diskslices *ssp, int slice, struct disklabel *lp)
+set_ds_label(struct diskslices *ssp, int slice, disklabel_t lp)
 {
        struct diskslice *sp = &ssp->dss_slices[slice];
 
        sp->ds_label = lp;
-       adjust_label_reserved(ssp, slice, sp);
+       ops->op_adjust_label_reserved(ssp, slice, sp);
 }
 
 static void
index 7dc749e..dfc8f21 100644 (file)
@@ -1,38 +1,40 @@
 /*
- * Copyright (c) 1987, 1988, 1993
- *     The Regents of the University of California.  All rights reserved.
- *
+ * 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. 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
+ *    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.
- *
- *     @(#)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.26 2007/06/17 23:50:12 dillon Exp $
+ * 
+ * $DragonFly: src/sys/sys/disklabel.h,v 1.27 2007/06/18 05:13:42 dillon Exp $
+ */
+/*
+ * Disklabel abstraction
  */
 
 #ifndef _SYS_DISKLABEL_H_
 #ifndef _SYS_TYPES_H_
 #include <sys/types.h>
 #endif
-#if defined(_KERNEL) && !defined(_SYS_SYSTM_H_)
-#include <sys/systm.h>
+#ifndef _SYS_UUID_H_
+#include <sys/uuid.h>
 #endif
-#ifndef _SYS_IOCCOM_H_
-#include <sys/ioccom.h>
-#endif
-
-/*
- * Each disk has a label which includes information about the hardware
- * disk geometry, filesystem partitions, and drive specific information.
- * The label is in block 0 or 1, possibly offset from the beginning
- * to leave room for a bootstrap, etc.
- */
 
-/* XXX these should be defined per controller (or drive) elsewhere, not here! */
-#ifdef __i386__
-#define LABELSECTOR    1                       /* sector containing label */
-#define LABELOFFSET    0                       /* offset of label in sector */
-#endif
+struct disklabel32;
+struct disklabel64;
 
-#define DISKMAGIC      ((u_int32_t)0x82564557) /* The disk magic number */
-#ifndef MAXPARTITIONS
-#define        MAXPARTITIONS   16
-#endif
-
-#define        LABEL_PART      2               /* partition containing label */
-#define        RAW_PART        2               /* partition containing whole disk */
-#define        SWAP_PART       1               /* partition normally containing swap */
-
-#ifndef LOCORE
-struct disklabel {
-       u_int32_t d_magic;              /* the magic number */
-       u_int16_t d_type;               /* drive type */
-       u_int16_t d_subtype;            /* controller/d_type specific */
-       char      d_typename[16];       /* type name, e.g. "eagle" */
-
-       char    d_packname[16];         /* pack identifier */
-
-       /* disk geometry: */
-       u_int32_t d_secsize;            /* # of bytes per sector */
-       u_int32_t d_nsectors;           /* # of data sectors per track */
-       u_int32_t d_ntracks;            /* # of tracks per cylinder */
-       u_int32_t d_ncylinders;         /* # of data cylinders per unit */
-       u_int32_t d_secpercyl;          /* # of data sectors per cylinder */
-       u_int32_t d_secperunit;         /* # of data sectors per unit */
-
-       /*
-        * Spares (bad sector replacements) below are not counted in
-        * d_nsectors or d_secpercyl.  Spare sectors are assumed to
-        * be physical sectors which occupy space at the end of each
-        * track and/or cylinder.
-        */
-       u_int16_t d_sparespertrack;     /* # of spare sectors per track */
-       u_int16_t d_sparespercyl;       /* # of spare sectors per cylinder */
-       /*
-        * Alternate cylinders include maintenance, replacement, configuration
-        * description areas, etc.
-        */
-       u_int32_t d_acylinders;         /* # of alt. cylinders per unit */
-
-                       /* hardware characteristics: */
-       /*
-        * d_interleave, d_trackskew and d_cylskew describe perturbations
-        * in the media format used to compensate for a slow controller.
-        * Interleave is physical sector interleave, set up by the
-        * formatter or controller when formatting.  When interleaving is
-        * in use, logically adjacent sectors are not physically
-        * contiguous, but instead are separated by some number of
-        * sectors.  It is specified as the ratio of physical sectors
-        * traversed per logical sector.  Thus an interleave of 1:1
-        * implies contiguous layout, while 2:1 implies that logical
-        * sector 0 is separated by one sector from logical sector 1.
-        * d_trackskew is the offset of sector 0 on track N relative to
-        * sector 0 on track N-1 on the same cylinder.  Finally, d_cylskew
-        * is the offset of sector 0 on cylinder N relative to sector 0
-        * on cylinder N-1.
-        */
-       u_int16_t d_rpm;                /* rotational speed */
-       u_int16_t d_interleave;         /* hardware sector interleave */
-       u_int16_t d_trackskew;          /* sector 0 skew, per track */
-       u_int16_t d_cylskew;            /* sector 0 skew, per cylinder */
-       u_int32_t d_headswitch;         /* head switch time, usec */
-       u_int32_t d_trkseek;            /* track-to-track seek, usec */
-       u_int32_t d_flags;              /* generic flags (now unused) */
-#define NDDATA 5
-       u_int32_t d_drivedata[NDDATA];  /* drive-type specific information */
-#define NSPARE 5
-       u_int32_t d_spare[NSPARE];      /* reserved for future use */
-       u_int32_t d_magic2;             /* the magic number (again) */
-       u_int16_t d_checksum;           /* xor of data incl. partitions */
-
-                       /* filesystem and partition information: */
-       u_int16_t d_npartitions;        /* number of partitions in following */
-       u_int32_t d_bbsize;             /* size of boot area at sn0, bytes */
-       u_int32_t d_sbsize;             /* max size of fs superblock, bytes */
-       struct  partition {             /* the partition table */
-               u_int32_t p_size;       /* number of sectors in partition */
-               u_int32_t p_offset;     /* starting sector */
-               u_int32_t p_fsize;      /* filesystem basic fragment size */
-               u_int8_t p_fstype;      /* filesystem type, see below */
-               u_int8_t p_frag;        /* filesystem fragments per block */
-               union {
-                       u_int16_t cpg;  /* UFS: FS cylinders per group */
-                       u_int16_t sgs;  /* LFS: FS segment shift */
-               } __partition_u1;
-#define        p_cpg   __partition_u1.cpg
-#define        p_sgs   __partition_u1.sgs
-       } d_partitions[MAXPARTITIONS];  /* actually may be more */
-};
-
-static u_int16_t dkcksum(struct disklabel *lp);
-
-static __inline u_int16_t
-dkcksum(struct disklabel *lp)
-{
-       u_int16_t *start, *end;
-       u_int16_t sum = 0;
-
-       start = (u_int16_t *)lp;
-       end = (u_int16_t *)&lp->d_partitions[lp->d_npartitions];
-       while (start < end)
-               sum ^= *start++;
-       return (sum);
-}
-
-#else /* LOCORE */
-       /*
-        * offsets for asm boot files.
-        */
-       .set    d_secsize,40
-       .set    d_nsectors,44
-       .set    d_ntracks,48
-       .set    d_ncylinders,52
-       .set    d_secpercyl,56
-       .set    d_secperunit,60
-       .set    d_end_,276              /* size of disk label */
-#endif /* LOCORE */
-
-#ifndef LOCORE
-
-/*
- * Disk-specific ioctls.
- */
-#define DIOCGDINFO     _IOR('d', 101, struct disklabel)/* get */
-#define DIOCSDINFO     _IOW('d', 102, struct disklabel)/* set */
-#define DIOCWDINFO     _IOW('d', 103, struct disklabel)/* set, update disk */
-#define DIOCGDVIRGIN   _IOR('d', 105, struct disklabel) /* get virgin label */
-
-#ifdef _KERNEL
+typedef union abstracted_disklabel {
+       void                    *opaque;
+       struct disklabel32      *lab32;
+       struct disklabel64      *lab64;
+} disklabel_t;
 
+struct cdev;
 struct diskslice;
 struct diskslices;
 struct disk_info;
 
-char   *readdisklabel (cdev_t dev, struct disklabel *lp);
-int    setdisklabel (struct disklabel *olp, struct disklabel *nlp,
-                   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 */
-
-#endif /* LOCORE */
+struct disklabel_ops {
+       struct uuid type;       /* uuid specifies disklabel type */
+       int labelsect;
+       int labelsize;          /* size of disklabel in bytes */
+
+       const char *(*op_readdisklabel)
+                   (struct cdev *, struct diskslice *, disklabel_t *,
+                    struct disk_info *);
+       int (*op_setdisklabel)
+                   (disklabel_t, disklabel_t, struct diskslice *, u_int32_t *);
+       int (*op_writedisklabel)
+                   (struct cdev *, struct diskslice *, disklabel_t);
+       disklabel_t (*op_clone_label)
+                   (struct disk_info *, struct diskslice *);
+       void (*op_adjust_label_reserved)
+                   (struct diskslices *, int, struct diskslice *);
+       int (*op_getpartbounds)
+                   (disklabel_t, u_int32_t, u_int64_t *, u_int64_t *);
+       int (*op_getpartfstype)
+                   (disklabel_t, u_int32_t);
+       u_int32_t (*op_getnumparts)
+                   (disklabel_t);
+       void (*op_makevirginlabel)
+                   (disklabel_t, struct diskslices *,
+                    struct diskslice *, struct disk_info *);
+};
 
 #endif /* !_SYS_DISKLABEL_H_ */
+
index 4b8710d..9f4f02f 100644 (file)
  *
  *     @(#)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.26 2007/06/17 23:50:12 dillon Exp $
+ * $DragonFly: src/sys/sys/disklabel32.h,v 1.27 2007/06/18 05:13:42 dillon Exp $
  */
 
-#ifndef _SYS_DISKLABEL_H_
-#define        _SYS_DISKLABEL_H_
+#ifndef _SYS_DISKLABEL32_H_
+#define        _SYS_DISKLABEL32_H_
 
 #ifndef _SYS_TYPES_H_
 #include <sys/types.h>
 
 /* XXX these should be defined per controller (or drive) elsewhere, not here! */
 #ifdef __i386__
-#define LABELSECTOR    1                       /* sector containing label */
-#define LABELOFFSET    0                       /* offset of label in sector */
+#define LABELSECTOR32  1                       /* sector containing label */
+#define LABELOFFSET32  0                       /* offset of label in sector */
 #endif
 
-#define DISKMAGIC      ((u_int32_t)0x82564557) /* The disk magic number */
-#ifndef MAXPARTITIONS
-#define        MAXPARTITIONS   16
+#define DISKMAGIC32    ((u_int32_t)0x82564557) /* The disk magic number */
+#ifndef MAXPARTITIONS32
+#define        MAXPARTITIONS32 16
 #endif
 
 #define        LABEL_PART      2               /* partition containing label */
@@ -71,7 +71,7 @@
 #define        SWAP_PART       1               /* partition normally containing swap */
 
 #ifndef LOCORE
-struct disklabel {
+struct disklabel32 {
        u_int32_t d_magic;              /* the magic number */
        u_int16_t d_type;               /* drive type */
        u_int16_t d_subtype;            /* controller/d_type specific */
@@ -125,10 +125,10 @@ struct disklabel {
        u_int32_t d_headswitch;         /* head switch time, usec */
        u_int32_t d_trkseek;            /* track-to-track seek, usec */
        u_int32_t d_flags;              /* generic flags (now unused) */
-#define NDDATA 5
-       u_int32_t d_drivedata[NDDATA];  /* drive-type specific information */
-#define NSPARE 5
-       u_int32_t d_spare[NSPARE];      /* reserved for future use */
+#define NDDATA32 5
+       u_int32_t d_drivedata[NDDATA32];/* drive-type specific information */
+#define NSPARE32 5
+       u_int32_t d_spare[NSPARE32];    /* reserved for future use */
        u_int32_t d_magic2;             /* the magic number (again) */
        u_int16_t d_checksum;           /* xor of data incl. partitions */
 
@@ -136,7 +136,7 @@ struct disklabel {
        u_int16_t d_npartitions;        /* number of partitions in following */
        u_int32_t d_bbsize;             /* size of boot area at sn0, bytes */
        u_int32_t d_sbsize;             /* max size of fs superblock, bytes */
-       struct  partition {             /* the partition table */
+       struct  partition32 {           /* the partition table */
                u_int32_t p_size;       /* number of sectors in partition */
                u_int32_t p_offset;     /* starting sector */
                u_int32_t p_fsize;      /* filesystem basic fragment size */
@@ -148,13 +148,13 @@ struct disklabel {
                } __partition_u1;
 #define        p_cpg   __partition_u1.cpg
 #define        p_sgs   __partition_u1.sgs
-       } d_partitions[MAXPARTITIONS];  /* actually may be more */
+       } d_partitions[MAXPARTITIONS32];/* actually may be more */
 };
 
-static u_int16_t dkcksum(struct disklabel *lp);
+static u_int16_t dkcksum32(struct disklabel32 *lp);
 
 static __inline u_int16_t
-dkcksum(struct disklabel *lp)
+dkcksum32(struct disklabel32 *lp)
 {
        u_int16_t *start, *end;
        u_int16_t sum = 0;
@@ -166,6 +166,10 @@ dkcksum(struct disklabel *lp)
        return (sum);
 }
 
+#ifdef _KERNEL
+extern struct disklabel_ops disklabel32_ops;
+#endif
+
 #else /* LOCORE */
        /*
         * offsets for asm boot files.
@@ -184,34 +188,11 @@ dkcksum(struct disklabel *lp)
 /*
  * Disk-specific ioctls.
  */
-#define DIOCGDINFO     _IOR('d', 101, struct disklabel)/* get */
-#define DIOCSDINFO     _IOW('d', 102, struct disklabel)/* set */
-#define DIOCWDINFO     _IOW('d', 103, struct disklabel)/* set, update disk */
-#define DIOCGDVIRGIN   _IOR('d', 105, struct disklabel) /* get virgin label */
-
-#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,
-                   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 */
+#define DIOCGDINFO32   _IOR('d', 101, struct disklabel32) /* get */
+#define DIOCSDINFO32   _IOW('d', 102, struct disklabel32) /* set */
+#define DIOCWDINFO32   _IOW('d', 103, struct disklabel32) /* set, update disk */
+#define DIOCGDVIRGIN32 _IOR('d', 105, struct disklabel32) /* get virgin label */
 
 #endif /* LOCORE */
 
-#endif /* !_SYS_DISKLABEL_H_ */
+#endif /* !_SYS_DISKLABEL32_H_ */
diff --git a/sys/sys/disklabel64.h b/sys/sys/disklabel64.h
new file mode 100644 (file)
index 0000000..2ea72c9
--- /dev/null
@@ -0,0 +1,103 @@
+/*
+ * 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/sys/disklabel64.h,v 1.1 2007/06/18 05:13:42 dillon Exp $
+ */
+
+#ifndef _SYS_DISKLABEL64_H_
+#define        _SYS_DISKLABEL64_H_
+
+#ifndef _SYS_TYPES_H_
+#include <sys/types.h>
+#endif
+#if defined(_KERNEL) && !defined(_SYS_SYSTM_H_)
+#include <sys/systm.h>
+#endif
+#ifndef _SYS_IOCCOM_H_
+#include <sys/ioccom.h>
+#endif
+#ifndef _SYS_UUID_H_
+#include <sys/uuid.h>
+#endif
+
+/*
+ * 64 disklabels start at offset 0 on the disk or slice they reside.  All
+ * values are byte offsets, not block numbers, in order to allow portability.
+ * Unlike the original 32 bit disklabels, the on-disk format for a 64 bit
+ * disklabel is slice-relative and does not have to be translated.
+ */
+
+#define DISKMAGIC64    ((u_int32_t)0xc4464c59) /* The disk magic number */
+#ifndef MAXPARTITIONS64
+#define        MAXPARTITIONS64 16
+#endif
+
+#ifndef LOCORE
+
+struct disklabel64 {
+       u_int32_t d_magic;              /* the magic number */
+       u_int32_t d_crc;                /* crc32() */
+       u_int32_t d_align;              /* partition alignment requirement */
+       u_int32_t d_npartitions;        /* number of partitions */
+       struct uuid d_obj_uuid;         /* unique uuid for label */
+
+       u_int64_t d_total_size;         /* total size incl everything (bytes) */
+       u_int64_t d_bbase;              /* boot area base offset (bytes) */
+                                       /* boot area is pbase - bbase */
+       u_int64_t d_pbase;              /* first allocatable offset (bytes) */
+       u_int64_t d_pstop;              /* last allocatable offset+1 (bytes) */
+       u_int64_t d_abase;              /* location of backup copy if not 0 */
+
+       struct partition64 {            /* the partition table */
+               u_int64_t p_boffset;    /* slice relative offset, in bytes */
+               u_int64_t p_bsize;      /* size of partition, in bytes */
+               u_int32_t p_unused00;   /* reserved for future use */
+               u_int32_t p_unused01;   /* reserved for future use */
+               u_int32_t p_unused02;   /* reserved for future use */
+               u_int32_t p_unused03;   /* reserved for future use */
+               struct uuid p_type_uuid;/* mount type as UUID */
+               struct uuid p_obj_uuid; /* unique uuid for storage */
+       } d_partitions[MAXPARTITIONS64];/* actually may be more */
+};
+
+/*
+ * Disk-specific ioctls.
+ */
+#define DIOCGDINFO64   _IOR('d', 101, struct disklabel64)
+#define DIOCSDINFO64   _IOW('d', 102, struct disklabel64)
+#define DIOCWDINFO64   _IOW('d', 103, struct disklabel64)
+#define DIOCGDVIRGIN64 _IOR('d', 105, struct disklabel64)
+
+#endif /* LOCORE */
+
+#endif /* !_SYS_DISKLABEL64_H_ */
index d1de866..aea9317 100644 (file)
@@ -57,7 +57,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/sys/diskslice.h,v 1.36.2.1 2001/01/29 01:50:50 ken Exp $
- * $DragonFly: src/sys/sys/diskslice.h,v 1.20 2007/06/17 09:56:17 dillon Exp $
+ * $DragonFly: src/sys/sys/diskslice.h,v 1.21 2007/06/18 05:13:42 dillon Exp $
  */
 
 #ifndef        _SYS_DISKSLICE_H_
@@ -66,6 +66,9 @@
 #ifndef _SYS_TYPES_H_
 #include <sys/types.h>
 #endif
+#ifndef _SYS_DISKLABEL_H_
+#include <sys/disklabel.h>
+#endif
 #ifndef _SYS_IOCCOM_H_
 #include <sys/ioccom.h>
 #endif
@@ -88,7 +91,6 @@
 #define DIOCWLABEL             _IOW('d', 109, int)
 #define        DIOCGSLICEINFO          _IOR('d', 111, struct diskslices)
 #define        DIOCSYNCSLICEINFO       _IOW('d', 112, int)
-#define        DIOCSETSNOOP            _IOW('d', 113, int)
 #define        MAX_SLICES              16
 
 /*
@@ -129,7 +131,8 @@ struct diskslice {
        u_int64_t       ds_size;        /* number of sectors */
        u_int32_t       ds_reserved;    /* sectors reserved parent overlap */
        int             ds_type;        /* (foreign) slice type */
-       struct disklabel *ds_label;     /* BSD label, if any */
+       disklabel_t     ds_label;       /* label, if any */
+       struct disklabel_ops *ds_ops;   /* label ops (probe default) */
        void            *ds_dev;        /* devfs token for raw whole slice */
        void            *ds_devs[MAXPARTITIONS]; /* XXX s.b. in label */
        u_int32_t       ds_openmask[DKMAXPARTITIONS/(sizeof(u_int32_t)*8)];
@@ -386,7 +389,6 @@ dssetmaskfrommask(struct diskslice *ds, u_int32_t *tmask)
 
 struct buf;
 struct bio;
-struct disklabel;
 struct disk_info;
 struct bio_queue_head;
 
diff --git a/sys/sys/ndisklabel.h b/sys/sys/ndisklabel.h
deleted file mode 100644 (file)
index b3d0eb2..0000000
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * 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/sys/Attic/ndisklabel.h,v 1.2 2007/05/15 17:51:02 dillon Exp $
- */
-
-/*
- * DragonFly disk label
- */
-#ifndef _SYS_NDISKLABEL_H_
-#define        _SYS_NDISKLABEL_H_
-
-#ifndef _SYS_TYPES_H_
-#include <sys/types.h>
-#endif
-
-/*
- * A Dragonfly new-style disklabel always resides at byte offset 4096
- * from the beginning of the block device, regardless of the sector size.
- *
- * All offsets stored in the disklabel are in bytes relative to the
- * beginning of the block device, not relative to the disk label.
- */
-#define DFLY_LABEL_BYTE_OFFSET 4096
-
-/*
- * Misc constants.
- *
- * Disklabels are stored in native-endian format and are portable as long
- * as the code checks for and properly converts the label.  Only big-endian
- * and little-endian formats are supported.  All fields are structuralized.
- */
-#define DFLY_DISKMAGIC         ((u_int64_t)0xc4466c7942534430ULL)
-#define DFLY_DISKMAGIC_OTHER   ((u_int64_t)0x30445342796c46c4ULL)
-#define DFLY_MAXPARTITIONS     16
-
-#ifndef LOCORE
-
-/*
- * The disk label and partitions a-p.  All offsets and sizes are in bytes
- * but must be sector-aligned.  Other then the alignment requirement, the
- * disklabel doesn't care what the physical sector size of the media is.
- *
- * All offsets are in bytes and are relative to the beginning of the
- * block device in question (raw disk, slice, whatever), NOT the beginning
- * of the label.
- */
-struct dfly_disklabel {
-       u_int64_t       d_magic;        /* magic number / endian check */
-       u_int64_t       d_serialno;     /* initial disklabel creation */
-       u_int64_t       d_timestamp;    /* timestamp of disklabel creation */
-       u_int64_t       d_crc;          /* cyclic redundancy check for label */
-                                       /* (after any endian translation) */
-       u_int64_t       d_size;         /* size of block device in bytes */
-       u_int32_t       d_npart;        /* actual number of partitions */
-       u_int32_t       d_labelsize;    /* max size of label in bytes */
-       u_int32_t       d_bootpart;     /* -1 if not defined */
-       u_int32_t       d_version;      /* disklabel version control */
-       char            d_label[64];    /* user defined label (mandatory) */
-       char            d_reserved[128];
-
-       /*
-        * Partitions do not have individual labels.  The filesystem or
-        * storage layer id is specified in ascii, 14 chars max, 0-extended.
-        * p_layer[15] must always be 0.
-        *
-        * All offsets and sizes are in bytes but still must be aligned to
-        * the native sector size of the media.
-        */
-       struct dfly_diskpart {
-               u_int64_t       p_offset;       /* offset in bytes */
-               u_int64_t       p_size;         /* size in bytes */
-               u_int32_t       p_flags;        /* misc flags */
-               char            p_layer[16];    /* FS or storage layer ID */
-       } d_partitions[DFLY_MAXPARTITIONS];
-       /* might be extended further */
-};
-
-#endif
-
-#define DFLY_PARTF_VALID       0x0001          /* partition defined */
-#define DFLY_PARTF_GOOD                0x0002          /* fs/storage formatted */
-#define DFLY_PARTF_RECURSE     0x0004          /* recursive disklabel */
-
-#define DFLY_DISKLABEL_SWAP    "swap"          /* strcmp w/ p_layer[] */
-#define DFLY_DISKLABEL_UFS     "ufs"           /* strcmp w/ p_layer[] */
-
-#ifndef LOCORE
-
-#define DFLY_DIOCGDINFO   _IOR('d', 101, struct dfly_disklabel) /* get */
-#define DFLY_DIOCSDINFO          _IOW('d', 102, struct dfly_disklabel) /* set */
-#define DFLY_DIOCWDINFO          _IOW('d', 103, struct dfly_disklabel) /* set, update */
-#define DFLY_DIOCGDVIRGIN _IOR('d', 105, struct dfly_disklabel) /* get new */
-
-#endif
-
-#endif /* !_SYS_NDISKLABEL_H_ */
diff --git a/sys/sys/odisklabel.h b/sys/sys/odisklabel.h
deleted file mode 100644 (file)
index 6cca35f..0000000
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * 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/Attic/odisklabel.h,v 1.18 2007/05/16 05:20:25 dillon Exp $
- */
-
-#ifndef _SYS_ODISKLABEL_H_
-#define        _SYS_ODISKLABEL_H_
-
-#ifndef _SYS_TYPES_H_
-#include <sys/types.h>
-#endif
-#if defined(_KERNEL) && !defined(_SYS_SYSTM_H_)
-#include <sys/systm.h>
-#endif
-#ifndef _SYS_IOCCOM_H_
-#include <sys/ioccom.h>
-#endif
-#if defined(_KERNEL) && !defined(_SYS_CONF_H_)
-#include <sys/conf.h>          /* for make_sub_dev() */
-#endif
-
-#define DISKMAGIC      ((u_int32_t)0x82564557) /* The disk magic number */
-#ifndef MAXPARTITIONS
-#define        MAXPARTITIONS   16
-#endif
-
-#define        LABEL_PART      2               /* partition containing label */
-#define        RAW_PART        2               /* partition containing whole disk */
-#define        SWAP_PART       1               /* partition normally containing swap */
-
-#ifndef LOCORE
-struct odisklabel {
-       u_int32_t d_magic;              /* the magic number */
-       u_int16_t d_type;               /* drive type */
-       u_int16_t d_subtype;            /* controller/d_type specific */
-       char      d_typename[16];       /* type name, e.g. "eagle" */
-
-       /* 
-        * d_packname contains the pack identifier and is returned when
-        * the disklabel is read off the disk or in-core copy.
-        * d_boot0 and d_boot1 are the (optional) names of the
-        * primary (block 0) and secondary (block 1-15) bootstraps
-        * as found in /boot.  These are returned when using
-        * getdiskbyname(3) to retrieve the values from /etc/disktab.
-        */
-       union {
-               char    un_d_packname[16];      /* pack identifier */
-               struct {
-                       char *un_d_boot0;       /* primary bootstrap name */
-                       char *un_d_boot1;       /* secondary bootstrap name */
-               } un_b;
-       } d_un;
-#define d_packname     d_un.un_d_packname
-#define d_boot0                d_un.un_b.un_d_boot0
-#define d_boot1                d_un.un_b.un_d_boot1
-
-                       /* disk geometry: */
-       u_int32_t d_secsize;            /* # of bytes per sector */
-       u_int32_t d_nsectors;           /* # of data sectors per track */
-       u_int32_t d_ntracks;            /* # of tracks per cylinder */
-       u_int32_t d_ncylinders;         /* # of data cylinders per unit */
-       u_int32_t d_secpercyl;          /* # of data sectors per cylinder */
-       u_int32_t d_secperunit;         /* # of data sectors per unit */
-
-       /*
-        * Spares (bad sector replacements) below are not counted in
-        * d_nsectors or d_secpercyl.  Spare sectors are assumed to
-        * be physical sectors which occupy space at the end of each
-        * track and/or cylinder.
-        */
-       u_int16_t d_sparespertrack;     /* # of spare sectors per track */
-       u_int16_t d_sparespercyl;       /* # of spare sectors per cylinder */
-       /*
-        * Alternate cylinders include maintenance, replacement, configuration
-        * description areas, etc.
-        */
-       u_int32_t d_acylinders;         /* # of alt. cylinders per unit */
-
-                       /* hardware characteristics: */
-       /*
-        * d_interleave, d_trackskew and d_cylskew describe perturbations
-        * in the media format used to compensate for a slow controller.
-        * Interleave is physical sector interleave, set up by the
-        * formatter or controller when formatting.  When interleaving is
-        * in use, logically adjacent sectors are not physically
-        * contiguous, but instead are separated by some number of
-        * sectors.  It is specified as the ratio of physical sectors
-        * traversed per logical sector.  Thus an interleave of 1:1
-        * implies contiguous layout, while 2:1 implies that logical
-        * sector 0 is separated by one sector from logical sector 1.
-        * d_trackskew is the offset of sector 0 on track N relative to
-        * sector 0 on track N-1 on the same cylinder.  Finally, d_cylskew
-        * is the offset of sector 0 on cylinder N relative to sector 0
-        * on cylinder N-1.
-        */
-       u_int16_t d_rpm;                /* rotational speed */
-       u_int16_t d_interleave;         /* hardware sector interleave */
-       u_int16_t d_trackskew;          /* sector 0 skew, per track */
-       u_int16_t d_cylskew;            /* sector 0 skew, per cylinder */
-       u_int32_t d_headswitch;         /* head switch time, usec */
-       u_int32_t d_trkseek;            /* track-to-track seek, usec */
-       u_int32_t d_flags;              /* generic flags */
-#define NDDATA 5
-       u_int32_t d_drivedata[NDDATA];  /* drive-type specific information */
-#define NSPARE 5
-       u_int32_t d_spare[NSPARE];      /* reserved for future use */
-       u_int32_t d_magic2;             /* the magic number (again) */
-       u_int16_t d_checksum;           /* xor of data incl. partitions */
-
-                       /* filesystem and partition information: */
-       u_int16_t d_npartitions;        /* number of partitions in following */
-       u_int32_t d_bbsize;             /* size of boot area at sn0, bytes */
-       u_int32_t d_sbsize;             /* max size of fs superblock, bytes */
-       struct  opartition {            /* the partition table */
-               u_int32_t p_size;       /* number of sectors in partition */
-               u_int32_t p_offset;     /* starting sector */
-               u_int32_t p_fsize;      /* filesystem basic fragment size */
-               u_int8_t p_fstype;      /* filesystem type, see below */
-               u_int8_t p_frag;        /* filesystem fragments per block */
-               union {
-                       u_int16_t cpg;  /* UFS: FS cylinders per group */
-                       u_int16_t sgs;  /* LFS: FS segment shift */
-               } __partition_u1;
-#define        p_cpg   __partition_u1.cpg
-#define        p_sgs   __partition_u1.sgs
-       } d_partitions[MAXPARTITIONS];  /* actually may be more */
-};
-
-static u_int16_t odkcksum(struct odisklabel *lp);
-
-static __inline u_int16_t
-odkcksum(struct odisklabel *lp)
-{
-       u_int16_t *start, *end;
-       u_int16_t sum = 0;
-
-       start = (u_int16_t *)lp;
-       end = (u_int16_t *)&lp->d_partitions[lp->d_npartitions];
-       while (start < end)
-               sum ^= *start++;
-       return (sum);
-}
-
-#else /* LOCORE */
-       /*
-        * offsets for asm boot files.
-        */
-       .set    d_secsize,40
-       .set    d_nsectors,44
-       .set    d_ntracks,48
-       .set    d_ncylinders,52
-       .set    d_secpercyl,56
-       .set    d_secperunit,60
-       .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 */
-
-#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",
-       NULL
-};
-#define FSMAXTYPES     (sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)
-#endif
-
-#ifndef LOCORE
-
-/*
- * Disk-specific ioctls.
- */
-               /* get and set disklabel; DIOCGPART used internally */
-#define ODIOCGDINFO    _IOR('d', 101, struct odisklabel)/* get */
-#define ODIOCSDINFO    _IOW('d', 102, struct odisklabel)/* set */
-#define ODIOCWDINFO    _IOW('d', 103, struct odisklabel)/* set, update disk */
-#define ODIOCGDVIRGIN  _IOR('d', 105, struct odisklabel) /* get virgin label */
-
-#endif /* LOCORE */
-
-#endif /* !_SYS_ODISKLABEL_H_ */
index 97eb464..57bfabf 100644 (file)
  *
  *     @(#)param.h     8.3 (Berkeley) 4/4/95
  * $FreeBSD: src/sys/sys/param.h,v 1.61.2.38 2003/05/22 17:12:01 fjoe Exp $
- * $DragonFly: src/sys/sys/param.h,v 1.40 2007/05/08 02:31:43 dillon Exp $
+ * $DragonFly: src/sys/sys/param.h,v 1.41 2007/06/18 05:13:43 dillon Exp $
  */
 
 #ifndef _SYS_PARAM_H_
 #define _SYS_PARAM_H_
 
-#define BSD    200307          /* XXX kern.osrevision */
+#define BSD    200701          /* XXX kern.osrevision */
 #define BSD4_3 1               /* XXX obsolete */
 #define BSD4_4 1               /* XXX obsolete */