sys/kern/subr_diskslice.c

   1 /*-
   2  * Copyright (c) 1994 Bruce D. Evans.
   3  * All rights reserved.
   4  *
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * William Jolitz.
  10  *
  11  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
  12  * All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  * 3. All advertising materials mentioning features or use of this software
  23  *    must display the following acknowledgement:
  24  *      This product includes software developed by the University of
  25  *      California, Berkeley and its contributors.
  26  * 4. Neither the name of the University nor the names of its contributors
  27  *    may be used to endorse or promote products derived from this software
  28  *    without specific prior written permission.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40  * SUCH DAMAGE.
  41  *
  42  *      from: @(#)wd.c  7.2 (Berkeley) 5/9/91
  43  *      from: wd.c,v 1.55 1994/10/22 01:57:12 phk Exp $
  44  *      from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
  45  *      from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
  46  * $FreeBSD: src/sys/kern/subr_diskslice.c,v 1.82.2.6 2001/07/24 09:49:41 dd Exp $
  47  * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.51 2008/08/29 20:08:36 dillon Exp $
  48  */
  49
  50 #include <sys/param.h>
  51 #include <sys/systm.h>
  52 #include <sys/buf.h>
  53 #include <sys/conf.h>
  54 #include <sys/disklabel.h>
  55 #include <sys/disklabel32.h>
  56 #include <sys/disklabel64.h>
  57 #include <sys/diskslice.h>
  58 #include <sys/disk.h>
  59 #include <sys/diskmbr.h>
  60 #include <sys/fcntl.h>
  61 #include <sys/malloc.h>
  62 #include <sys/stat.h>
  63 #include <sys/syslog.h>
  64 #include <sys/proc.h>
  65 #include <sys/vnode.h>
  66 #include <sys/device.h>
  67 #include <sys/thread2.h>
  68
  69 #include <vfs/ufs/dinode.h>     /* XXX used only for fs.h */
  70 #include <vfs/ufs/fs.h>         /* XXX used only to get BBSIZE/SBSIZE */
  71
  72 static int  dsreadandsetlabel(cdev_t dev, u_int flags,
  73                            struct diskslices *ssp, struct diskslice *sp,
  74                            struct disk_info *info);
  75 static void free_ds_label (struct diskslices *ssp, int slice);
  76 static void set_ds_label (struct diskslices *ssp, int slice, disklabel_t lp,
  77                            disklabel_ops_t ops);
  78 static void set_ds_wlabel (struct diskslices *ssp, int slice, int wlabel);
  79
  80 /*
  81  * Determine the size of the transfer, and make sure it is
  82  * within the boundaries of the partition. Adjust transfer
  83  * if needed, and signal errors or early completion.
  84  *
  85  * XXX TODO:
  86  *      o Split buffers that are too big for the device.
  87  *      o Check for overflow.
  88  *      o Finish cleaning this up.
  89  *
  90  * This function returns 1 on success, 0 if transfer equates
  91  * to EOF (end of disk) or -1 on failure.  The appropriate
  92  * 'errno' value is also set in bp->b_error and bp->b_flags
  93  * is marked with B_ERROR.
  94  */
  95 struct bio *
  96 dscheck(cdev_t dev, struct bio *bio, struct diskslices *ssp)
  97 {
  98         struct buf *bp = bio->bio_buf;
  99         struct bio *nbio;
 100         disklabel_t lp;
 101         disklabel_ops_t ops;
 102         long nsec;
 103         u_int64_t secno;
 104         u_int64_t endsecno;
 105         u_int64_t slicerel_secno;
 106         struct diskslice *sp;
 107         u_int32_t part;
 108         u_int32_t slice;
 109         int shift;
 110         int mask;
 111
 112         slice = dkslice(dev);
 113         part  = dkpart(dev);
 114
 115         if (bio->bio_offset < 0) {
 116                 kprintf("dscheck(%s): negative bio_offset %lld\n",
 117                         devtoname(dev), (long long)bio->bio_offset);
 118                 goto bad;
 119         }
 120         if (slice >= ssp->dss_nslices) {
 121                 kprintf("dscheck(%s): slice too large %d/%d\n",
 122                         devtoname(dev), slice, ssp->dss_nslices);
 123                 goto bad;
 124         }
 125         sp = &ssp->dss_slices[slice];
 126         /*
 127          * Calculate secno and nsec
 128          */
 129         if (ssp->dss_secmult == 1) {
 130                 shift = DEV_BSHIFT;
 131                 goto doshift;
 132         } else if (ssp->dss_secshift != -1) {
 133                 shift = DEV_BSHIFT + ssp->dss_secshift;
 134 doshift:
 135                 mask = (1 << shift) - 1;
 136                 if ((int)bp->b_bcount & mask)
 137                         goto bad_bcount;
 138                 if ((int)bio->bio_offset & mask)
 139                         goto bad_blkno;
 140                 secno = bio->bio_offset >> shift;
 141                 nsec = bp->b_bcount >> shift;
 142         } else {
 143                 if (bp->b_bcount % ssp->dss_secsize)
 144                         goto bad_bcount;
 145                 if (bio->bio_offset % ssp->dss_secsize)
 146                         goto bad_blkno;
 147                 secno = bio->bio_offset / ssp->dss_secsize;
 148                 nsec = bp->b_bcount / ssp->dss_secsize;
 149         }
 150
 151         /*
 152          * Calculate slice-relative sector number end slice-relative
 153          * limit.
 154          */
 155         if (slice == WHOLE_DISK_SLICE) {
 156                 /*
 157                  * Labels have not been allowed on whole-disks for a while.
 158                  * This really puts the nail in the coffin.
 159                  *
 160                  * Accesses to the WHOLE_DISK_SLICE do not use a disklabel
 161                  * and partition numbers are special-cased.  Currently numbers
 162                  * less then 128 are not allowed.  Partition numbers >= 128
 163                  * are encoded in the high 8 bits of the 64 bit buffer offset
 164                  * and are fed directly through to the device with no
 165                  * further interpretation.  In particular, no sector
 166                  * translation interpretation should occur because the
 167                  * sector size for the special raw access may not be the
 168                  * same as the nominal sector size for the device.
 169                  */
 170                 lp.opaque = NULL;
 171                 if (part < 128) {
 172                         kprintf("dscheck(%s): illegal partition number (%d) "
 173                                 "for WHOLE_DISK_SLICE access\n",
 174                                 devtoname(dev), part);
 175                         goto bad;
 176                 } else if (part != WHOLE_SLICE_PART) {
 177                         nbio = push_bio(bio);
 178                         nbio->bio_offset = bio->bio_offset |
 179                                            (u_int64_t)part << 56;
 180                         return(nbio);
 181                 } else {
 182                         /*
 183                          * If writing to the raw disk request a
 184                          * reprobe on the last close.
 185                          */
 186                         if (bp->b_cmd == BUF_CMD_WRITE)
 187                                 sp->ds_flags |= DSF_REPROBE;
 188                 }
 189
 190                 /*
 191                  * sp->ds_size is for the whole disk in the WHOLE_DISK_SLICE,
 192                  * there are no reserved areas.
 193                  */
 194                 endsecno = sp->ds_size;
 195                 slicerel_secno = secno;
 196         } else if (part == WHOLE_SLICE_PART) {
 197                 /*
 198                  * NOTE! opens on a whole-slice partition will not attempt
 199                  * to read a disklabel in, so there may not be an in-core
 200                  * disklabel even if there is one on the disk.
 201                  */
 202                 endsecno = sp->ds_size;
 203                 slicerel_secno = secno;
 204         } else if ((lp = sp->ds_label).opaque != NULL) {
 205                 /*
 206                  * A label is present, extract the partition.  Snooping of
 207                  * the disklabel is not supported even if accessible.  Of
 208                  * course, the reserved area is still write protected.
 209                  */
 210                 ops = sp->ds_ops;
 211                 if (ops->op_getpartbounds(ssp, lp, part,
 212                                           &slicerel_secno, &endsecno)) {
 213                         kprintf("dscheck(%s): partition %d out of bounds\n",
 214                                 devtoname(dev), part);
 215                         goto bad;
 216                 }
 217                 slicerel_secno += secno;
 218         } else {
 219                 /*
 220                  * Attempt to access partition when no disklabel present
 221                  */
 222                 kprintf("dscheck(%s): attempt to access non-existent partition\n",
 223                         devtoname(dev));
 224                 goto bad;
 225         }
 226
 227         /*
 228          * Disallow writes to reserved areas unless ds_wlabel allows it.
 229          * If the reserved area is written to request a reprobe of the
 230          * disklabel when the slice is closed.
 231          */
 232         if (slicerel_secno < sp->ds_reserved && nsec &&
 233             bp->b_cmd == BUF_CMD_WRITE) {
 234                 if (sp->ds_wlabel == 0) {
 235                         bp->b_error = EROFS;
 236                         goto error;
 237                 }
 238                 sp->ds_flags |= DSF_REPROBE;
 239         }
 240
 241         /*
 242          * If we get here, bio_offset must be on a block boundary and
 243          * the sector size must be a power of 2.
 244          */
 245         if ((bio->bio_offset & (ssp->dss_secsize - 1)) ||
 246             (ssp->dss_secsize ^ (ssp->dss_secsize - 1)) !=
 247             ((ssp->dss_secsize << 1) - 1)) {
 248                 kprintf("%s: invalid BIO offset, not sector aligned or"
 249                         " invalid sector size (not power of 2) %08llx %d\n",
 250                         devtoname(dev), (long long)bio->bio_offset,
 251                         ssp->dss_secsize);
 252                 goto bad;
 253         }
 254
 255         /*
 256          * EOF handling
 257          */
 258         if (secno + nsec > endsecno) {
 259                 /*
 260                  * Return an error if beyond the end of the disk, or
 261                  * if B_BNOCLIP is set.  Tell the system that we do not
 262                  * need to keep the buffer around.
 263                  */
 264                 if (secno > endsecno || (bp->b_flags & B_BNOCLIP))
 265                         goto bad;
 266
 267                 /*
 268                  * If exactly at end of disk, return an EOF.  Throw away
 269                  * the buffer contents, if any, by setting B_INVAL.
 270                  */
 271                 if (secno == endsecno) {
 272                         bp->b_resid = bp->b_bcount;
 273                         bp->b_flags |= B_INVAL;
 274                         goto done;
 275                 }
 276
 277                 /*
 278                  * Else truncate
 279                  */
 280                 nsec = endsecno - secno;
 281                 bp->b_bcount = nsec * ssp->dss_secsize;
 282         }
 283
 284         nbio = push_bio(bio);
 285         nbio->bio_offset = (off_t)(sp->ds_offset + slicerel_secno) *
 286                            ssp->dss_secsize;
 287         return (nbio);
 288
 289 bad_bcount:
 290         kprintf(
 291         "dscheck(%s): b_bcount %d is not on a sector boundary (ssize %d)\n",
 292             devtoname(dev), bp->b_bcount, ssp->dss_secsize);
 293         goto bad;
 294
 295 bad_blkno:
 296         kprintf(
 297         "dscheck(%s): bio_offset %lld is not on a sector boundary (ssize %d)\n",
 298             devtoname(dev), (long long)bio->bio_offset, ssp->dss_secsize);
 299 bad:
 300         bp->b_error = EINVAL;
 301         /* fall through */
 302 error:
 303         /*
 304          * Terminate the I/O with a ranging error.  Since the buffer is
 305          * either illegal or beyond the file EOF, mark it B_INVAL as well.
 306          */
 307         bp->b_resid = bp->b_bcount;
 308         bp->b_flags |= B_ERROR | B_INVAL;
 309 done:
 310         /*
 311          * Caller must biodone() the originally passed bio if NULL is
 312          * returned.
 313          */
 314         return (NULL);
 315 }
 316
 317 /*
 318  * dsclose() - close a cooked disk slice.
 319  *
 320  * WARNING!  The passed diskslices and related diskslice structures may
 321  *           be invalidated or replaced by this function, callers must
 322  *           reload from the disk structure for continued access.
 323  */
 324 void
 325 dsclose(cdev_t dev, int mode, struct diskslices *ssp)
 326 {
 327         u_int32_t part;
 328         u_int32_t slice;
 329         struct diskslice *sp;
 330
 331         slice = dkslice(dev);
 332         part  = dkpart(dev);
 333         if (slice < ssp->dss_nslices) {
 334                 sp = &ssp->dss_slices[slice];
 335                 dsclrmask(sp, part);
 336                 if (sp->ds_flags & DSF_REPROBE) {
 337                         sp->ds_flags &= ~DSF_REPROBE;
 338                         if (slice == WHOLE_DISK_SLICE) {
 339                                 kprintf("reprobe whole disk\n");
 340                                 disk_msg_send_sync(DISK_DISK_REPROBE,
 341                                                    dev->si_disk, NULL);
 342                         } else {
 343                                 kprintf("reprobe slice\n");
 344                                 disk_msg_send_sync(DISK_SLICE_REPROBE,
 345                                                    dev->si_disk, sp);
 346                         }
 347                         /* ssp and sp may both be invalid after reprobe */
 348                 }
 349         }
 350 }
 351
 352 void
 353 dsgone(struct diskslices **sspp)
 354 {
 355         int slice;
 356         struct diskslice *sp;
 357         struct diskslices *ssp;
 358
 359         kprintf("dsgone is called... fear!\n");
 360
 361         for (slice = 0, ssp = *sspp; slice < ssp->dss_nslices; slice++) {
 362                 sp = &ssp->dss_slices[slice];
 363                 free_ds_label(ssp, slice);
 364         }
 365         kfree(ssp, M_DEVBUF);
 366         *sspp = NULL;
 367 }
 368
 369 /*
 370  * For the "write" commands (DIOCSDINFO and DIOCWDINFO), this
 371  * is subject to the same restriction as dsopen().
 372  */
 373 int
 374 dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
 375         struct diskslices **sspp, struct disk_info *info)
 376 {
 377         int error;
 378         disklabel_t lp;
 379         disklabel_t lptmp;
 380         disklabel_ops_t ops;
 381         int old_wlabel;
 382         u_int32_t openmask[DKMAXPARTITIONS/(sizeof(u_int32_t)*8)];
 383         int part;
 384         int slice;
 385         struct diskslice *sp;
 386         struct diskslices *ssp;
 387
 388         slice = dkslice(dev);
 389         part = dkpart(dev);
 390         ssp = *sspp;
 391         if (slice >= ssp->dss_nslices)
 392                 return (EINVAL);
 393         sp = &ssp->dss_slices[slice];
 394         lp = sp->ds_label;
 395         ops = sp->ds_ops;       /* may be NULL if no label */
 396
 397         switch (cmd) {
 398         case DIOCGDVIRGIN32:
 399                 ops = &disklabel32_ops;
 400                 /* fall through */
 401         case DIOCGDVIRGIN64:
 402                 if (cmd != DIOCGDVIRGIN32)
 403                         ops = &disklabel64_ops;
 404                 /*
 405                  * You can only retrieve a virgin disklabel on the whole
 406                  * disk slice or whole-slice partition.
 407                  */
 408                 if (slice != WHOLE_DISK_SLICE &&
 409                     part != WHOLE_SLICE_PART) {
 410                         return(EINVAL);
 411                 }
 412
 413                 lp.opaque = data;
 414                 ops->op_makevirginlabel(lp, ssp, sp, info);
 415                 return (0);
 416
 417         case DIOCGDINFO32:
 418         case DIOCGDINFO64:
 419                 /*
 420                  * You can only retrieve a disklabel on the whole
 421                  * slice partition.
 422                  *
 423                  * We do not support labels directly on whole-disks
 424                  * any more (that is, disks without slices), unless the
 425                  * device driver has asked for a compatible label (e.g.
 426                  * for a CD) to allow booting off of storage that is
 427                  * otherwise unlabeled.
 428                  */
 429                 error = 0;
 430                 if (part != WHOLE_SLICE_PART)
 431                         return(EINVAL);
 432                 if (slice == WHOLE_DISK_SLICE &&
 433                     (info->d_dsflags & DSO_COMPATLABEL) == 0) {
 434                         return (ENODEV);
 435                 }
 436                 if (sp->ds_label.opaque == NULL) {
 437                         error = dsreadandsetlabel(dev, info->d_dsflags,
 438                                                   ssp, sp, info);
 439                         ops = sp->ds_ops;       /* may be NULL */
 440                 }
 441
 442                 /*
 443                  * The type of label we found must match the type of
 444                  * label requested.
 445                  */
 446                 if (error == 0 && IOCPARM_LEN(cmd) != ops->labelsize)
 447                         error = ENOATTR;
 448                 if (error == 0)
 449                         bcopy(sp->ds_label.opaque, data, ops->labelsize);
 450                 return (error);
 451
 452         case DIOCGPART:
 453                 {
 454                         struct partinfo *dpart = (void *)data;
 455
 456                         /*
 457                          * The disk management layer may not have read the
 458                          * disklabel yet because simply opening a slice no
 459                          * longer 'probes' the disk that way.  Be sure we
 460                          * have tried.
 461                          *
 462                          * We ignore any error.
 463                          */
 464                         if (sp->ds_label.opaque == NULL &&
 465                             part == WHOLE_SLICE_PART &&
 466                             slice != WHOLE_DISK_SLICE) {
 467                                 kprintf("dsioctl: I shouldn't be here...\n");
 468                                 dsreadandsetlabel(dev, info->d_dsflags,
 469                                                   ssp, sp, info);
 470                                 ops = sp->ds_ops;       /* may be NULL */
 471                         }
 472
 473                         bzero(dpart, sizeof(*dpart));
 474                         dpart->media_offset   = (u_int64_t)sp->ds_offset *
 475                                                 info->d_media_blksize;
 476                         dpart->media_size     = (u_int64_t)sp->ds_size *
 477                                                 info->d_media_blksize;
 478                         dpart->media_blocks   = sp->ds_size;
 479                         dpart->media_blksize  = info->d_media_blksize;
 480                         dpart->reserved_blocks= sp->ds_reserved;
 481                         dpart->fstype_uuid = sp->ds_type_uuid;
 482                         dpart->storage_uuid = sp->ds_stor_uuid;
 483
 484                         if (slice != WHOLE_DISK_SLICE &&
 485                             part != WHOLE_SLICE_PART) {
 486                                 u_int64_t start;
 487                                 u_int64_t blocks;
 488                                 if (lp.opaque == NULL)
 489                                         return(EINVAL);
 490                                 if (ops->op_getpartbounds(ssp, lp, part,
 491                                                           &start, &blocks)) {
 492                                         return(EINVAL);
 493                                 }
 494                                 ops->op_loadpartinfo(lp, part, dpart);
 495                                 dpart->media_offset += start *
 496                                                        info->d_media_blksize;
 497                                 dpart->media_size = blocks *
 498                                                     info->d_media_blksize;
 499                                 dpart->media_blocks = blocks;
 500
 501                                 /*
 502                                  * partition starting sector (p_offset)
 503                                  * requires slice's reserved areas to be
 504                                  * adjusted.
 505                                  */
 506                                 if (dpart->reserved_blocks > start)
 507                                         dpart->reserved_blocks -= start;
 508                                 else
 509                                         dpart->reserved_blocks = 0;
 510                         }
 511
 512                         /*
 513                          * Load remaining fields from the info structure
 514                          */
 515                         dpart->d_nheads =       info->d_nheads;
 516                         dpart->d_ncylinders =   info->d_ncylinders;
 517                         dpart->d_secpertrack =  info->d_secpertrack;
 518                         dpart->d_secpercyl =    info->d_secpercyl;
 519                 }
 520                 return (0);
 521
 522         case DIOCGSLICEINFO:
 523                 bcopy(ssp, data, (char *)&ssp->dss_slices[ssp->dss_nslices] -
 524                                  (char *)ssp);
 525                 return (0);
 526
 527         case DIOCSDINFO32:
 528                 ops = &disklabel32_ops;
 529                 /* fall through */
 530         case DIOCSDINFO64:
 531                 if (cmd != DIOCSDINFO32)
 532                         ops = &disklabel64_ops;
 533                 /*
 534                  * You can write a disklabel on the whole disk slice or
 535                  * whole-slice partition.
 536                  */
 537                 if (slice != WHOLE_DISK_SLICE &&
 538                     part != WHOLE_SLICE_PART) {
 539                         return(EINVAL);
 540                 }
 541
 542                 /*
 543                  * We no longer support writing disklabels directly to media
 544                  * without there being a slice.  Keep this as a separate
 545                  * conditional.
 546                  */
 547                 if (slice == WHOLE_DISK_SLICE)
 548                         return (ENODEV);
 549                 if (!(flags & FWRITE))
 550                         return (EBADF);
 551
 552                 /*
 553                  * If an existing label is present it must be the same
 554                  * type as the label being passed by the ioctl.
 555                  */
 556                 if (sp->ds_label.opaque && sp->ds_ops != ops)
 557                         return (ENOATTR);
 558
 559                 /*
 560                  * Create a temporary copy of the existing label
 561                  * (if present) so setdisklabel can compare it against
 562                  * the new label.
 563                  */
 564                 lp.opaque = kmalloc(ops->labelsize, M_DEVBUF, M_WAITOK);
 565                 if (sp->ds_label.opaque == NULL)
 566                         bzero(lp.opaque, ops->labelsize);
 567                 else
 568                         bcopy(sp->ds_label.opaque, lp.opaque, ops->labelsize);
 569                 if (sp->ds_label.opaque == NULL) {
 570                         bzero(openmask, sizeof(openmask));
 571                 } else {
 572                         bcopy(sp->ds_openmask, openmask, sizeof(openmask));
 573                 }
 574                 lptmp.opaque = data;
 575                 error = ops->op_setdisklabel(lp, lptmp, ssp, sp, openmask);
 576                 //XXX: send reprobe message here.
 577                 disk_msg_send_sync(DISK_SLICE_REPROBE, dev->si_disk, sp);
 578                 if (error != 0) {
 579                         kfree(lp.opaque, M_DEVBUF);
 580                         return (error);
 581                 }
 582                 free_ds_label(ssp, slice);
 583                 set_ds_label(ssp, slice, lp, ops);
 584                 return (0);
 585
 586         case DIOCSYNCSLICEINFO:
 587                 /*
 588                  * This ioctl can only be done on the whole disk
 589                  */
 590                 if (slice != WHOLE_DISK_SLICE || part != WHOLE_SLICE_PART)
 591                         return (EINVAL);
 592
 593                 if (*(int *)data == 0) {
 594                         for (slice = 0; slice < ssp->dss_nslices; slice++) {
 595                                 struct diskslice *ds = &ssp->dss_slices[slice];
 596
 597                                 switch(dscountmask(ds)) {
 598                                 case 0:
 599                                         break;
 600                                 case 1:
 601                                         if (slice != WHOLE_DISK_SLICE)
 602                                                 return (EBUSY);
 603                                         if (!dschkmask(ds, RAW_PART))
 604                                                 return (EBUSY);
 605                                         break;
 606                                 default:
 607                                         return (EBUSY);
 608                                 }
 609                         }
 610                 }
 611
 612                 disk_msg_send_sync(DISK_DISK_REPROBE, dev->si_disk, NULL);
 613                 return 0;
 614 #if 0
 615                 /*
 616                  * Temporarily forget the current slices struct and read
 617                  * the current one.
 618                  *
 619                  * NOTE:
 620                  *
 621                  * XXX should wait for current accesses on this disk to
 622                  * complete, then lock out future accesses and opens.
 623                  */
 624                 kprintf("dsioctl messed with our stuff!\n");
 625                 *sspp = NULL;
 626                 error = dsopen(dev, S_IFCHR, ssp->dss_oflags, sspp, info);
 627                 if (error != 0) {
 628                         *sspp = ssp;
 629                         return (error);
 630                 }
 631
 632                 /*
 633                  * Reopen everything.  This is a no-op except in the "force"
 634                  * case and when the raw bdev and cdev are both open.  Abort
 635                  * if anything fails.
 636                  */
 637                 for (slice = 0; slice < ssp->dss_nslices; slice++) {
 638                         for (part = 0; part < DKMAXPARTITIONS; ++part) {
 639                                 if (!dschkmask(&ssp->dss_slices[slice], part))
 640                                         continue;
 641                                 error = dsopen(dkmodslice(dkmodpart(dev, part),
 642                                                           slice),
 643                                                S_IFCHR, ssp->dss_oflags, sspp,
 644                                                info);
 645                                 if (error != 0) {
 646                                         *sspp = ssp;
 647                                         return (EBUSY);
 648                                 }
 649                         }
 650                 }
 651
 652                 //XXX: recheck this...
 653                 dsgone(&ssp);
 654                 return (0);
 655 #endif
 656
 657         case DIOCWDINFO32:
 658         case DIOCWDINFO64:
 659                 error = dsioctl(dev, ((cmd == DIOCWDINFO32) ?
 660                                         DIOCSDINFO32 : DIOCSDINFO64),
 661                                 data, flags, &ssp, info);
 662                 if (error == 0 && sp->ds_label.opaque == NULL)
 663                         error = EINVAL;
 664                 if (part != WHOLE_SLICE_PART)
 665                         error = EINVAL;
 666                 if (error != 0)
 667                         return (error);
 668
 669                 /*
 670                  * Allow the reserved area to be written, reload ops
 671                  * because the DIOCSDINFO op above may have installed
 672                  * a new label type.
 673                  */
 674                 ops = sp->ds_ops;
 675                 old_wlabel = sp->ds_wlabel;
 676                 set_ds_wlabel(ssp, slice, TRUE);
 677                 error = ops->op_writedisklabel(dev, ssp, sp, sp->ds_label);
 678                 disk_msg_send_sync(DISK_SLICE_REPROBE, dev->si_disk, sp);
 679                 set_ds_wlabel(ssp, slice, old_wlabel);
 680                 /* XXX should invalidate in-core label if write failed. */
 681                 return (error);
 682
 683         case DIOCWLABEL:
 684                 if (slice == WHOLE_DISK_SLICE)
 685                         return (ENODEV);
 686                 if (!(flags & FWRITE))
 687                         return (EBADF);
 688                 set_ds_wlabel(ssp, slice, *(int *)data != 0);
 689                 return (0);
 690
 691         default:
 692                 return (ENOIOCTL);
 693         }
 694 }
 695
 696 int
 697 dsisopen(struct diskslices *ssp)
 698 {
 699         int slice;
 700
 701         if (ssp == NULL)
 702                 return (0);
 703         for (slice = 0; slice < ssp->dss_nslices; slice++) {
 704                 if (dscountmask(&ssp->dss_slices[slice]))
 705                         return (1);
 706         }
 707         return (0);
 708 }
 709
 710 /*
 711  * Allocate a slices "struct" and initialize it to contain only an empty
 712  * compatibility slice (pointing to itself), a whole disk slice (covering
 713  * the disk as described by the label), and (nslices - BASE_SLICES) empty
 714  * slices beginning at BASE_SLICE.
 715  *
 716  * Note that the compatibility slice is no longer really a compatibility
 717  * slice.  It is slice 0 if a GPT label is present, and the dangerously
 718  * dedicated slice if no slice table otherwise exists.  Else it is 0-sized.
 719  */
 720 struct diskslices *
 721 dsmakeslicestruct(int nslices, struct disk_info *info)
 722 {
 723         struct diskslice *sp;
 724         struct diskslices *ssp;
 725
 726         ssp = kmalloc(offsetof(struct diskslices, dss_slices) +
 727                      nslices * sizeof *sp, M_DEVBUF, M_WAITOK);
 728         ssp->dss_first_bsd_slice = COMPATIBILITY_SLICE;
 729         ssp->dss_nslices = nslices;
 730         ssp->dss_oflags = 0;
 731
 732         /*
 733          * Figure out if we can use shifts or whether we have to
 734          * use mod/multply to translate byte offsets into sector numbers.
 735          */
 736         if ((info->d_media_blksize ^ (info->d_media_blksize - 1)) ==
 737              (info->d_media_blksize << 1) - 1) {
 738                 ssp->dss_secmult = info->d_media_blksize / DEV_BSIZE;
 739                 if (ssp->dss_secmult & (ssp->dss_secmult - 1))
 740                         ssp->dss_secshift = -1;
 741                 else
 742                         ssp->dss_secshift = ffs(ssp->dss_secmult) - 1;
 743         } else {
 744                 ssp->dss_secmult = 0;
 745                 ssp->dss_secshift = -1;
 746         }
 747         ssp->dss_secsize = info->d_media_blksize;
 748         sp = &ssp->dss_slices[0];
 749         bzero(sp, nslices * sizeof *sp);
 750         sp[WHOLE_DISK_SLICE].ds_size = info->d_media_blocks;
 751         return (ssp);
 752 }
 753
 754 char *
 755 dsname(cdev_t dev, int unit, int slice, int part, char *partname)
 756 {
 757         return dev->si_name;
 758 }
 759
 760 /*
 761  * This should only be called when the unit is inactive and the strategy
 762  * routine should not allow it to become active unless we call it.  Our
 763  * strategy routine must be special to allow activity.
 764  */
 765 int
 766 dsopen(cdev_t dev, int mode, u_int flags,
 767         struct diskslices **sspp, struct disk_info *info)
 768 {
 769         cdev_t dev1;
 770         int error;
 771         int need_init;
 772         struct diskslice *sp;
 773         struct diskslices *ssp;
 774         int slice;
 775         int part;
 776
 777         ssp = *sspp;
 778         dev->si_bsize_phys = info->d_media_blksize;
 779         slice = dkslice(dev);
 780         part = dkpart(dev);
 781         sp = &ssp->dss_slices[slice];
 782         dssetmask(sp, part);
 783
 784         return 0;
 785
 786         /*
 787          * Do not attempt to read the slice table or disk label when
 788          * accessing the whole-disk slice or a while-slice partition.
 789          */
 790         if (dkslice(dev) == WHOLE_DISK_SLICE)
 791                 flags |= DSO_ONESLICE | DSO_NOLABELS;
 792         if (dkpart(dev) == WHOLE_SLICE_PART)
 793                 flags |= DSO_NOLABELS;
 794
 795         /*
 796          * Reinitialize the slice table unless there is an open device
 797          * on the unit.
 798          *
 799          * It would be nice if we didn't have to do this but when a
 800          * user is slicing and partitioning up a disk it is a lot safer
 801          * to not take any chances.
 802          */
 803         ssp = *sspp;
 804         need_init = !dsisopen(ssp);
 805         if (ssp != NULL && need_init)
 806                 dsgone(sspp);
 807         if (need_init) {
 808                 /*
 809                  * Allocate a minimal slices "struct".  This will become
 810                  * the final slices "struct" if we don't want real slices
 811                  * or if we can't find any real slices.
 812                  *
 813                  * Then scan the disk
 814                  */
 815                 *sspp = dsmakeslicestruct(BASE_SLICE, info);
 816
 817                 if ((flags & DSO_ONESLICE) == 0) {
 818                         error = mbrinit(dev, info, sspp);
 819                         if (error != 0) {
 820                                 dsgone(sspp);
 821                                 return (error);
 822                         }
 823                 }
 824                 ssp = *sspp;
 825                 ssp->dss_oflags = flags;
 826
 827                 /*
 828                  * If there are no real slices, then make the compatiblity
 829                  * slice cover the whole disk.
 830                  */
 831                 if (ssp->dss_nslices == BASE_SLICE) {
 832                         sp = &ssp->dss_slices[COMPATIBILITY_SLICE];
 833
 834                         sp->ds_size = info->d_media_blocks;
 835                         sp->ds_reserved = 0;
 836                 }
 837
 838                 /*
 839                  * Set dss_first_bsd_slice to point at the first BSD
 840                  * slice, if any.
 841                  */
 842                 for (slice = BASE_SLICE; slice < ssp->dss_nslices; slice++) {
 843                         sp = &ssp->dss_slices[slice];
 844                         if (sp->ds_type == DOSPTYP_386BSD /* XXX */) {
 845 #if 0
 846                                 struct diskslice *csp;
 847 #endif
 848
 849                                 ssp->dss_first_bsd_slice = slice;
 850 #if 0
 851                                 /*
 852                                  * no longer supported, s0 is a real slice
 853                                  * for GPT
 854                                  */
 855                                 csp = &ssp->dss_slices[COMPATIBILITY_SLICE];
 856                                 csp->ds_offset = sp->ds_offset;
 857                                 csp->ds_size = sp->ds_size;
 858                                 csp->ds_type = sp->ds_type;
 859                                 csp->ds_reserved = sp->ds_reserved;
 860 #endif
 861                                 break;
 862                         }
 863                 }
 864
 865                 /*
 866                  * By definition accesses via the whole-disk device do not
 867                  * specify any reserved areas.  The whole disk may be read
 868                  * or written by the whole-disk device.
 869                  *
 870                  * The whole-disk slice does not ever have a label.
 871                  */
 872                 sp = &ssp->dss_slices[WHOLE_DISK_SLICE];
 873                 sp->ds_wlabel = TRUE;
 874                 sp->ds_reserved = 0;
 875         }
 876
 877         /*
 878          * Load the disklabel for the slice being accessed unless it is
 879          * a whole-disk-slice or a whole-slice-partition (as determined
 880          * by DSO_NOLABELS).
 881          *
 882          * We could scan all slices here and try to load up their
 883          * disklabels, but that would cause us to access slices that
 884          * the user may otherwise not intend us to access, or corrupted
 885          * slices, etc.
 886          *
 887          * XXX if there are no opens on the slice we may want to re-read
 888          * the disklabel anyway, even if we have one cached.
 889          */
 890         slice = dkslice(dev);
 891         if (slice >= ssp->dss_nslices)
 892                 return (ENXIO);
 893         sp = &ssp->dss_slices[slice];
 894         part = dkpart(dev);
 895
 896         if ((flags & DSO_NOLABELS) == 0 && sp->ds_label.opaque == NULL) {
 897                 dev1 = dkmodslice(dkmodpart(dev, WHOLE_SLICE_PART), slice);
 898
 899                 /*
 900                  * If opening a raw disk we do not try to
 901                  * read the disklabel now.  No interpretation of raw disks
 902                  * (e.g. like 'da0') ever occurs.  We will try to read the
 903                  * disklabel for a raw slice if asked to via DIOC* ioctls.
 904                  *
 905                  * Access to the label area is disallowed by default.  Note
 906                  * however that accesses via WHOLE_DISK_SLICE, and accesses
 907                  * via WHOLE_SLICE_PART for slices without valid disklabels,
 908                  * will allow writes and ignore the flag.
 909                  */
 910                 set_ds_wlabel(ssp, slice, FALSE);
 911                 dsreadandsetlabel(dev1, flags, ssp, sp, info);
 912         }
 913
 914         /*
 915          * If opening a particular partition the disklabel must exist and
 916          * the partition must be present in the label.
 917          *
 918          * If the partition is the special whole-disk-slice no partition
 919          * table need exist.
 920          */
 921         if (part != WHOLE_SLICE_PART && slice != WHOLE_DISK_SLICE) {
 922                 if (sp->ds_label.opaque == NULL ||
 923                     part >= sp->ds_ops->op_getnumparts(sp->ds_label)) {
 924                         return (EINVAL);
 925                 }
 926         }
 927
 928         /*
 929          * Do not allow special raw-extension partitions to be opened
 930          * if the device doesn't support them.  Raw-extension partitions
 931          * are typically used to handle CD tracks.
 932          */
 933         if (slice == WHOLE_DISK_SLICE && part >= 128 &&
 934             part != WHOLE_SLICE_PART) {
 935                 if ((info->d_dsflags & DSO_RAWEXTENSIONS) == 0)
 936                         return (EINVAL);
 937         }
 938
 939         /*
 940          * Ok, we are open
 941          */
 942         dssetmask(sp, part);
 943         return (0);
 944 }
 945
 946 /*
 947  * Attempt to read the disklabel.  If successful, store it in sp->ds_label.
 948  *
 949  * If we cannot read the disklabel and DSO_COMPATLABEL is set, we construct
 950  * a fake label covering the whole disk.
 951  */
 952 static
 953 int
 954 dsreadandsetlabel(cdev_t dev, u_int flags,
 955                   struct diskslices *ssp, struct diskslice *sp,
 956                   struct disk_info *info)
 957 {
 958         disklabel_t lp;
 959         disklabel_ops_t ops;
 960         const char *msg;
 961         const char *sname;
 962         char partname[2];
 963         int slice = dkslice(dev);
 964
 965         /*
 966          * Probe the disklabel
 967          */
 968         lp.opaque = NULL;
 969         sname = dsname(dev, dkunit(dev), slice, WHOLE_SLICE_PART, partname);
 970         ops = &disklabel32_ops;
 971         msg = ops->op_readdisklabel(dev, sp, &lp, info);
 972         if (msg && strcmp(msg, "no disk label") == 0) {
 973                 ops = &disklabel64_ops;
 974                 msg = disklabel64_ops.op_readdisklabel(dev, sp, &lp, info);
 975         }
 976
 977         /*
 978          * If we failed and COMPATLABEL is set, create a dummy disklabel.
 979          */
 980         if (msg != NULL && (flags & DSO_COMPATLABEL)) {
 981                 msg = NULL;
 982                 if (sp->ds_size >= 0x100000000ULL)
 983                         ops = &disklabel64_ops;
 984                 else
 985                         ops = &disklabel32_ops;
 986                 lp = ops->op_clone_label(info, sp);
 987         }
 988         if (msg != NULL) {
 989                 if (sp->ds_type == DOSPTYP_386BSD /* XXX */)
 990                         log(LOG_WARNING, "%s: cannot find label (%s)\n",
 991                             sname, msg);
 992                 if (lp.opaque)
 993                         kfree(lp.opaque, M_DEVBUF);
 994         } else {
 995                 set_ds_label(ssp, slice, lp, ops);
 996                 set_ds_wlabel(ssp, slice, FALSE);
 997         }
 998         return (msg ? EINVAL : 0);
 999 }
1000
1001 int64_t
1002 dssize(cdev_t dev, struct diskslices **sspp)
1003 {
1004         disklabel_t lp;
1005         disklabel_ops_t ops;
1006         int part;
1007         int slice;
1008         struct diskslices *ssp;
1009         u_int64_t start;
1010         u_int64_t blocks;
1011
1012         slice = dkslice(dev);
1013         part = dkpart(dev);
1014         ssp = *sspp;
1015         if (ssp == NULL || slice >= ssp->dss_nslices
1016             || !dschkmask(&ssp->dss_slices[slice], part)) {
1017                 if (dev_dopen(dev, FREAD, S_IFCHR, proc0.p_ucred) != 0)
1018                         return (-1);
1019                 dev_dclose(dev, FREAD, S_IFCHR);
1020                 ssp = *sspp;
1021         }
1022         lp = ssp->dss_slices[slice].ds_label;
1023         if (lp.opaque == NULL)
1024                 return (-1);
1025         ops = ssp->dss_slices[slice].ds_ops;
1026         if (ops->op_getpartbounds(ssp, lp, part, &start, &blocks))
1027                 return (-1);
1028         return ((int64_t)blocks);
1029 }
1030
1031 static void
1032 free_ds_label(struct diskslices *ssp, int slice)
1033 {
1034         struct diskslice *sp;
1035         disklabel_t lp;
1036
1037         sp = &ssp->dss_slices[slice];
1038         lp = sp->ds_label;
1039         if (lp.opaque != NULL) {
1040                 kfree(lp.opaque, M_DEVBUF);
1041                 lp.opaque = NULL;
1042                 set_ds_label(ssp, slice, lp, NULL);
1043         }
1044 }
1045
1046 static void
1047 set_ds_label(struct diskslices *ssp, int slice,
1048              disklabel_t lp, disklabel_ops_t ops)
1049 {
1050         struct diskslice *sp = &ssp->dss_slices[slice];
1051
1052         sp->ds_label = lp;
1053         sp->ds_ops = ops;
1054         if (lp.opaque && slice != WHOLE_DISK_SLICE)
1055                 ops->op_adjust_label_reserved(ssp, slice, sp);
1056         else
1057                 sp->ds_reserved = 0;
1058 }
1059
1060 static void
1061 set_ds_wlabel(struct diskslices *ssp, int slice, int wlabel)
1062 {
1063         ssp->dss_slices[slice].ds_wlabel = wlabel;
1064 }
1065