sys/sys/diskslice.h

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 /*-
  35  * Copyright (c) 1994 Bruce D. Evans.
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  57  * SUCH DAMAGE.
  58  *
  59  * $FreeBSD: src/sys/sys/diskslice.h,v 1.36.2.1 2001/01/29 01:50:50 ken Exp $
  60  * $DragonFly: src/sys/sys/diskslice.h,v 1.22 2007/06/19 06:07:51 dillon Exp $
  61  */
  62
  63 #ifndef _SYS_DISKSLICE_H_
  64 #define _SYS_DISKSLICE_H_
  65
  66 #ifndef _SYS_TYPES_H_
  67 #include <sys/types.h>
  68 #endif
  69 #ifndef _SYS_DISKLABEL_H_
  70 #include <sys/disklabel.h>
  71 #endif
  72 #ifndef _SYS_UUID_H_
  73 #include <sys/uuid.h>
  74 #endif
  75 #ifndef _SYS_IOCCOM_H_
  76 #include <sys/ioccom.h>
  77 #endif
  78 #if defined(_KERNEL)
  79 #ifndef _SYS_CONF_H_
  80 #include <sys/conf.h>           /* for make_sub_dev() */
  81 #endif
  82 #ifndef _SYS_SYSTM_H_
  83 #include <sys/systm.h>          /* for minor() */
  84 #endif
  85 #endif
  86
  87 #define BASE_SLICE              2       /* e.g. ad0s1 */
  88 #define COMPATIBILITY_SLICE     0       /* e.g. ad0a-j */
  89                                 /* 101 - compat disklabel DIOCGDINFO    */
  90                                 /* 102 - compat disklabel DIOCSDINFO    */
  91                                 /* 103 - compat disklabel DIOCWDINFO    */
  92                                 /* 104 - DIOCGPART (see below)          */
  93                                 /* 105 - compat disklabel DIOCGDVIRGIN  */
  94 #define DIOCWLABEL              _IOW('d', 109, int)
  95 #define DIOCGSLICEINFO          _IOR('d', 111, struct diskslices)
  96 #define DIOCSYNCSLICEINFO       _IOW('d', 112, int)
  97 #define MAX_SLICES              16
  98
  99 /*
 100  * Support limits
 101  */
 102 #define DKMAXUNITS      512     /* maximum supported disk units */
 103 #define DKMAXSLICES     128     /* maximum supported slices (0 & 1 special) */
 104 #define DKRESPARTITIONS 128     /* 128+ have special meanings */
 105 #define DKMAXPARTITIONS 256     /* maximum supported in-kernel partitions */
 106
 107 /*
 108  * The whole-disk-slice does not try to interpret the MBR.  The whole slice
 109  * partition does not try to interpret the disklabel within the slice.
 110  */
 111 #define WHOLE_DISK_SLICE        1
 112 #define WHOLE_SLICE_PART        (DKMAXPARTITIONS - 1)
 113
 114 #ifdef MAXPARTITIONS                    /* XXX don't depend on disklabel.h */
 115 #if MAXPARTITIONS !=    16              /* but check consistency if possible */
 116 #error "inconsistent MAXPARTITIONS"
 117 #endif
 118 #else
 119 #define MAXPARTITIONS   16
 120 #endif
 121
 122 /*
 123  * diskslice structure - slices up the disk and indicates where the
 124  * BSD labels are, if any.
 125  *
 126  * ds_reserved       -  indicates read-only sectors due to an overlap with
 127  *                      a parent partition or an in-band label.  BSD labels
 128  *                      are in-band labels.  This field is also set if
 129  *                      label snooping has been requested, even if there is
 130  *                      no label present.
 131  */
 132 struct diskslice {
 133         u_int64_t       ds_offset;      /* starting sector */
 134         u_int64_t       ds_size;        /* number of sectors */
 135         u_int32_t       ds_reserved;    /* sectors reserved parent overlap */
 136         struct uuid     ds_type_uuid;   /* slice type uuid */
 137         struct uuid     ds_stor_uuid;   /* slice storage unique uuid */
 138         int             ds_type;        /* (foreign) slice type */
 139         disklabel_t     ds_label;       /* label, if any */
 140         struct disklabel_ops *ds_ops;   /* label ops (probe default) */
 141         void            *ds_dev;        /* devfs token for raw whole slice */
 142         void            *ds_devs[MAXPARTITIONS]; /* XXX s.b. in label */
 143         u_int32_t       ds_openmask[DKMAXPARTITIONS/(sizeof(u_int32_t)*8)];
 144                                         /* devs open */
 145         u_char          ds_wlabel;      /* nonzero if label is writable */
 146         int             ds_ttlopens;    /* total opens, incl slice & raw */
 147 };
 148
 149 struct diskslices {
 150         struct cdevsw *dss_cdevsw;      /* for containing device */
 151         int     dss_first_bsd_slice;    /* COMPATIBILITY_SLICE is mapped here */
 152         u_int   dss_nslices;            /* actual dimension of dss_slices[] */
 153         u_int   dss_oflags;             /* copy of flags for "first" open */
 154         int     dss_secmult;            /* block to sector multiplier */
 155         int     dss_secshift;           /* block to sector shift (or -1) */
 156         int     dss_secsize;            /* sector size */
 157         struct diskslice
 158                 dss_slices[MAX_SLICES]; /* actually usually less */
 159 };
 160
 161 /*
 162  * DIOCGPART ioctl - returns information about a disk, slice, or partition.
 163  * This ioctl is primarily used to get the block size and media size.
 164  *
 165  * NOTE: media_offset currently represents the byte offset on the raw device,
 166  * it is not a partition relative offset.  disklabel(32) uses this field
 167  * to figure out the slice offset so it fixup raw labels.
 168  *
 169  * NOTE: reserved_blocks indicates how many blocks at the beginning of the
 170  * partition are read-only due to in-band sharing with the parent.  For
 171  * example, if partition 'a' starts at block 0, it actually overlaps the
 172  * disklabel itself so numerous sectors at the beginning of 'a' will be
 173  * reserved.
 174  */
 175 struct partinfo {
 176         u_int64_t       media_offset;   /* byte offset in parent layer */
 177         u_int64_t       media_size;     /* media size in bytes */
 178         u_int64_t       media_blocks;   /* media size in blocks */
 179         int             media_blksize;  /* block size in bytes (sector size) */
 180
 181         u_int64_t       reserved_blocks;/* read-only, in sectors */
 182         int             fstype;         /* legacy filesystem type or FS_OTHER */
 183         char            fsreserved[16]; /* reserved for future use */
 184
 185         /*
 186          * These fields are loaded from the diskinfo structure
 187          */
 188         u_int           d_nheads;
 189         u_int           d_ncylinders;
 190         u_int           d_secpertrack;
 191         u_int           d_secpercyl;
 192         u_int           d_reserved[8];  /* reserved for future use */
 193
 194         /*
 195          * UUIDs can be extracted from GPT slices and disklabel64
 196          * partitions.  If not known, they will be set to a nil uuid.
 197          *
 198          * fstype_uuid represents the slice or partition type, e.g.
 199          * like GPT_ENT_TYPE_DRAGONFLY_DISKLABEL32.  If not nil,
 200          * storage_uuid uniquely identifies the physical storage.
 201          */
 202         struct uuid     fstype_uuid;
 203         struct uuid     storage_uuid;
 204 };
 205
 206 #define DIOCGPART       _IOR('d', 104, struct partinfo) /* get partition */
 207
 208 /*
 209  * disk unit and slice helper functions
 210  *
 211  *     3                   2                   1                   0
 212  *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 213  *  _________________________________________________________________
 214  *  | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
 215  *  -----------------------------------------------------------------
 216  *  | SL2 | PART3 |UNIT_2 |P| SLICE |  MAJOR?       |  UNIT   |PART |
 217  *  -----------------------------------------------------------------
 218  */
 219
 220 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
 221
 222 /*
 223  * Build a minor device number.
 224  */
 225 static __inline u_int32_t
 226 dkmakeminor(u_int32_t unit, u_int32_t slice, u_int32_t part)
 227 {
 228         u_int32_t val;
 229
 230         val = ((unit & 0x001f) << 3) | ((unit & 0x01e0) << 16) |
 231               ((slice & 0x000f) << 16) | ((slice & 0x0070) << 25) |
 232               (part & 0x0007) | ((part & 0x0008) << 17) |
 233               ((part & 0x00F0) << 21);
 234         return(val);
 235 }
 236
 237 /*
 238  * Generate the minor number representing the entire disk, with no
 239  * mbr or label interpretation.
 240  */
 241 static __inline u_int32_t
 242 dkmakewholedisk(u_int32_t unit)
 243 {
 244         return(dkmakeminor(unit, WHOLE_DISK_SLICE, WHOLE_SLICE_PART));
 245 }
 246
 247 /*
 248  * Generate the minor number representing an entire slice, with no
 249  * recursive mbr, boot sector, or label interpretation.
 250  */
 251 static __inline u_int32_t
 252 dkmakewholeslice(u_int32_t unit, u_int32_t slice)
 253 {
 254         return(dkmakeminor(unit, slice, WHOLE_SLICE_PART));
 255 }
 256
 257 /*
 258  * Return the unit mask, used in calls to make_dev()
 259  */
 260 static __inline u_int32_t
 261 dkunitmask(void)
 262 {
 263         return (0x01e000f8);
 264 }
 265
 266 /*
 267  * build minor number elements - encode unit number, slice, and partition
 268  * (OR the results together).
 269  */
 270 static __inline u_int32_t
 271 dkmakeunit(int unit)
 272 {
 273         return(dkmakeminor((u_int32_t)unit, 0, 0));
 274 }
 275
 276 static __inline u_int32_t
 277 dkmakeslice(int slice)
 278 {
 279         return(dkmakeminor(0, (u_int32_t)slice, 0));
 280 }
 281
 282 static __inline u_int32_t
 283 dkmakepart(int part)
 284 {
 285         return(dkmakeminor(0, 0, (u_int32_t)part));
 286 }
 287
 288 #endif
 289
 290 /*
 291  * dk*() support functions operating on cdev_t's
 292  */
 293 #ifdef _KERNEL
 294
 295 static __inline int
 296 dkunit(cdev_t dev)
 297 {
 298         u_int32_t val = minor(dev);
 299
 300         val = ((val >> 3) & 0x001f) | ((val >> 16) & 0x01e0);
 301         return((int)val);
 302 }
 303
 304 static __inline u_int32_t
 305 dkslice(cdev_t dev)
 306 {
 307         u_int32_t val = minor(dev);
 308
 309         val = ((val >> 16) & 0x000f) | ((val >> 25) & 0x0070);
 310         return(val);
 311 }
 312
 313 static __inline u_int32_t
 314 dkpart(cdev_t dev)
 315 {
 316         u_int32_t val = minor(dev);
 317
 318         val = (val & 0x0007) | ((val >> 17) & 0x0008) | ((val >> 21) & 0x00f0);
 319         return(val);
 320 }
 321
 322 /*
 323  * dkmodpart() - create sub-device
 324  */
 325 static __inline cdev_t
 326 dkmodpart(cdev_t dev, int part)
 327 {
 328         u_int32_t val;
 329
 330         val = (minor(dev) & ~dkmakepart(-1)) | dkmakepart(part);
 331         return (make_sub_dev(dev, val));
 332 }
 333
 334 static __inline cdev_t
 335 dkmodslice(cdev_t dev, int slice)
 336 {
 337         u_int32_t val;
 338
 339         val = (minor(dev) & ~dkmakeslice(-1)) | dkmakeslice(slice);
 340         return (make_sub_dev(dev, val));
 341 }
 342
 343 #endif
 344
 345 /*
 346  * Bitmask ops, keeping track of which partitions are open.
 347  */
 348 static __inline
 349 void
 350 dsclrmask(struct diskslice *ds, int part)
 351 {
 352         part &= (DKMAXPARTITIONS - 1);
 353         ds->ds_openmask[part >> 5] &= ~(1 << (part & 31));
 354 }
 355
 356 static __inline
 357 void
 358 dssetmask(struct diskslice *ds, int part)
 359 {
 360         part &= (DKMAXPARTITIONS - 1);
 361         ds->ds_openmask[part >> 5] |= (1 << (part & 31));
 362 }
 363
 364 static __inline
 365 int
 366 dschkmask(struct diskslice *ds, int part)
 367 {
 368         part &= (DKMAXPARTITIONS - 1);
 369         return (ds->ds_openmask[part >> 5] & (1 << (part & 31)));
 370 }
 371
 372 static __inline
 373 int
 374 dscountmask(struct diskslice *ds)
 375 {
 376         int count = 0;
 377         int i;
 378         int j;
 379
 380         for (i = 0; i < DKMAXPARTITIONS / 32; ++i) {
 381                 if (ds->ds_openmask[i]) {
 382                         for (j = 0; j < 32; ++j) {
 383                                 if (ds->ds_openmask[i] & (1 << j))
 384                                         ++count;
 385                         }
 386                 }
 387         }
 388         return(count);
 389 }
 390
 391 static __inline
 392 void
 393 dssetmaskfrommask(struct diskslice *ds, u_int32_t *tmask)
 394 {
 395         int i;
 396
 397         for (i = 0; i < DKMAXPARTITIONS / 32; ++i)
 398                 tmask[i] |= ds->ds_openmask[i];
 399 }
 400
 401 /*
 402  * disk management functions
 403  */
 404
 405 #ifdef _KERNEL
 406
 407 struct buf;
 408 struct bio;
 409 struct disk_info;
 410 struct bio_queue_head;
 411
 412 int     mbrinit (cdev_t dev, struct disk_info *info,
 413                     struct diskslices **sspp);
 414 int     gptinit (cdev_t dev, struct disk_info *info,
 415                     struct diskslices **sspp);
 416 struct bio *
 417         dscheck (cdev_t dev, struct bio *bio, struct diskslices *ssp);
 418 void    dsclose (cdev_t dev, int mode, struct diskslices *ssp);
 419 void    dsgone (struct diskslices **sspp);
 420 int     dsioctl (cdev_t dev, u_long cmd, caddr_t data, int flags,
 421                     struct diskslices **sspp, struct disk_info *info);
 422 int     dsisopen (struct diskslices *ssp);
 423 struct diskslices *
 424         dsmakeslicestruct (int nslices, struct disk_info *info);
 425 char    *dsname (cdev_t dev, int unit, int slice, int part,
 426                     char *partname);
 427 int     dsopen (cdev_t dev, int mode, u_int flags,
 428                     struct diskslices **sspp, struct disk_info *info);
 429 int64_t dssize (cdev_t dev, struct diskslices **sspp);
 430
 431 /*
 432  * Ancillary functions
 433  */
 434
 435 void    diskerr (struct bio *bio, cdev_t dev, const char *what, int pri,
 436                     int donecnt);
 437 void    disksort (struct buf *ap, struct buf *bp);
 438 void    bioqdisksort (struct bio_queue_head *ap, struct bio *bio);
 439
 440 #endif /* _KERNEL */
 441
 442 #endif /* !_SYS_DISKSLICE_H_ */