sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zvol.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  *
  24  * Copyright (c) 2006-2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
  25  * All rights reserved.
  26  */
  27
  28 /* Portions Copyright 2010 Robert Milkowski */
  29 /* Portions Copyright 2011 Martin Matuska <mm@FreeBSD.org> */
  30
  31 /*
  32  * ZFS volume emulation driver.
  33  *
  34  * Makes a DMU object look like a volume of arbitrary size, up to 2^64 bytes.
  35  * Volumes are accessed through the symbolic links named:
  36  *
  37  * /dev/zvol/dsk/<pool_name>/<dataset_name>
  38  * /dev/zvol/rdsk/<pool_name>/<dataset_name>
  39  *
  40  * These links are created by the /dev filesystem (sdev_zvolops.c).
  41  * Volumes are persistent through reboot.  No user command needs to be
  42  * run before opening and using a device.
  43  *
  44  * FreeBSD notes.
  45  * On FreeBSD ZVOLs are simply GEOM providers like any other storage device
  46  * in the system.
  47  */
  48
  49 #include <sys/types.h>
  50 #include <sys/param.h>
  51 #include <sys/kernel.h>
  52 #include <sys/errno.h>
  53 #include <sys/uio.h>
  54 #include <sys/bio.h>
  55 #include <sys/buf.h>
  56 #include <sys/kmem.h>
  57 #include <sys/conf.h>
  58 #include <sys/cmn_err.h>
  59 #include <sys/stat.h>
  60 #include <sys/zap.h>
  61 #include <sys/spa.h>
  62 #include <sys/zio.h>
  63 #include <sys/dmu_traverse.h>
  64 #include <sys/dnode.h>
  65 #include <sys/dsl_dataset.h>
  66 #include <sys/dsl_prop.h>
  67 #include <sys/dkio.h>
  68 #include <sys/byteorder.h>
  69 #include <sys/sunddi.h>
  70 #include <sys/dirent.h>
  71 #include <sys/policy.h>
  72 #include <sys/fs/zfs.h>
  73 #include <sys/zfs_ioctl.h>
  74 #include <sys/zil.h>
  75 #include <sys/refcount.h>
  76 #include <sys/zfs_znode.h>
  77 #include <sys/zfs_rlock.h>
  78 #include <sys/vdev_impl.h>
  79 #include <sys/zvol.h>
  80 #include <sys/zil_impl.h>
  81 #include <geom/geom.h>
  82
  83 #include "zfs_namecheck.h"
  84
  85 struct g_class zfs_zvol_class = {
  86         .name = "ZFS::ZVOL",
  87         .version = G_VERSION,
  88 };
  89
  90 DECLARE_GEOM_CLASS(zfs_zvol_class, zfs_zvol);
  91
  92 void *zfsdev_state;
  93 static char *zvol_tag = "zvol_tag";
  94
  95 #define ZVOL_DUMPSIZE           "dumpsize"
  96
  97 /*
  98  * The spa_namespace_lock protects the zfsdev_state structure from being
  99  * modified while it's being used, e.g. an open that comes in before a
 100  * create finishes.  It also protects temporary opens of the dataset so that,
 101  * e.g., an open doesn't get a spurious EBUSY.
 102  */
 103 static uint32_t zvol_minors;
 104
 105 typedef struct zvol_extent {
 106         list_node_t     ze_node;
 107         dva_t           ze_dva;         /* dva associated with this extent */
 108         uint64_t        ze_nblks;       /* number of blocks in extent */
 109 } zvol_extent_t;
 110
 111 /*
 112  * The in-core state of each volume.
 113  */
 114 typedef struct zvol_state {
 115         char            zv_name[MAXPATHLEN]; /* pool/dd name */
 116         uint64_t        zv_volsize;     /* amount of space we advertise */
 117         uint64_t        zv_volblocksize; /* volume block size */
 118         struct g_provider *zv_provider; /* GEOM provider */
 119         uint8_t         zv_min_bs;      /* minimum addressable block shift */
 120         uint8_t         zv_flags;       /* readonly, dumpified, etc. */
 121         objset_t        *zv_objset;     /* objset handle */
 122         uint32_t        zv_total_opens; /* total open count */
 123         zilog_t         *zv_zilog;      /* ZIL handle */
 124         list_t          zv_extents;     /* List of extents for dump */
 125         znode_t         zv_znode;       /* for range locking */
 126         dmu_buf_t       *zv_dbuf;       /* bonus handle */
 127         int             zv_state;
 128         struct bio_queue_head zv_queue;
 129         struct mtx      zv_queue_mtx;   /* zv_queue mutex */
 130 } zvol_state_t;
 131
 132 /*
 133  * zvol specific flags
 134  */
 135 #define ZVOL_RDONLY     0x1
 136 #define ZVOL_DUMPIFIED  0x2
 137 #define ZVOL_EXCL       0x4
 138 #define ZVOL_WCE        0x8
 139
 140 /*
 141  * zvol maximum transfer in one DMU tx.
 142  */
 143 int zvol_maxphys = DMU_MAX_ACCESS/2;
 144
 145 extern int zfs_set_prop_nvlist(const char *, zprop_source_t,
 146     nvlist_t *, nvlist_t **);
 147 static int zvol_remove_zv(zvol_state_t *);
 148 static int zvol_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio);
 149 static int zvol_dumpify(zvol_state_t *zv);
 150 static int zvol_dump_fini(zvol_state_t *zv);
 151 static int zvol_dump_init(zvol_state_t *zv, boolean_t resize);
 152
 153 static zvol_state_t *zvol_geom_create(const char *name);
 154 static void zvol_geom_run(zvol_state_t *zv);
 155 static void zvol_geom_destroy(zvol_state_t *zv);
 156 static int zvol_geom_access(struct g_provider *pp, int acr, int acw, int ace);
 157 static void zvol_geom_start(struct bio *bp);
 158 static void zvol_geom_worker(void *arg);
 159
 160 static void
 161 zvol_size_changed(zvol_state_t *zv)
 162 {
 163 #ifdef sun
 164         dev_t dev = makedevice(maj, min);
 165
 166         VERIFY(ddi_prop_update_int64(dev, zfs_dip,
 167             "Size", volsize) == DDI_SUCCESS);
 168         VERIFY(ddi_prop_update_int64(dev, zfs_dip,
 169             "Nblocks", lbtodb(volsize)) == DDI_SUCCESS);
 170
 171         /* Notify specfs to invalidate the cached size */
 172         spec_size_invalidate(dev, VBLK);
 173         spec_size_invalidate(dev, VCHR);
 174 #else   /* !sun */
 175         struct g_provider *pp;
 176
 177         pp = zv->zv_provider;
 178         if (pp == NULL)
 179                 return;
 180         if (zv->zv_volsize == pp->mediasize)
 181                 return;
 182         /*
 183          * Changing provider size is not really supported by GEOM, but it
 184          * should be safe when provider is closed.
 185          */
 186         if (zv->zv_total_opens > 0)
 187                 return;
 188         pp->mediasize = zv->zv_volsize;
 189 #endif  /* !sun */
 190 }
 191
 192 int
 193 zvol_check_volsize(uint64_t volsize, uint64_t blocksize)
 194 {
 195         if (volsize == 0)
 196                 return (EINVAL);
 197
 198         if (volsize % blocksize != 0)
 199                 return (EINVAL);
 200
 201 #ifdef _ILP32
 202         if (volsize - 1 > SPEC_MAXOFFSET_T)
 203                 return (EOVERFLOW);
 204 #endif
 205         return (0);
 206 }
 207
 208 int
 209 zvol_check_volblocksize(uint64_t volblocksize)
 210 {
 211         if (volblocksize < SPA_MINBLOCKSIZE ||
 212             volblocksize > SPA_MAXBLOCKSIZE ||
 213             !ISP2(volblocksize))
 214                 return (EDOM);
 215
 216         return (0);
 217 }
 218
 219 int
 220 zvol_get_stats(objset_t *os, nvlist_t *nv)
 221 {
 222         int error;
 223         dmu_object_info_t doi;
 224         uint64_t val;
 225
 226         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &val);
 227         if (error)
 228                 return (error);
 229
 230         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLSIZE, val);
 231
 232         error = dmu_object_info(os, ZVOL_OBJ, &doi);
 233
 234         if (error == 0) {
 235                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLBLOCKSIZE,
 236                     doi.doi_data_block_size);
 237         }
 238
 239         return (error);
 240 }
 241
 242 static zvol_state_t *
 243 zvol_minor_lookup(const char *name)
 244 {
 245         struct g_provider *pp;
 246         struct g_geom *gp;
 247         zvol_state_t *zv = NULL;
 248
 249         ASSERT(MUTEX_HELD(&spa_namespace_lock));
 250
 251         g_topology_lock();
 252         LIST_FOREACH(gp, &zfs_zvol_class.geom, geom) {
 253                 pp = LIST_FIRST(&gp->provider);
 254                 if (pp == NULL)
 255                         continue;
 256                 zv = pp->private;
 257                 if (zv == NULL)
 258                         continue;
 259                 if (strcmp(zv->zv_name, name) == 0)
 260                         break;
 261         }
 262         g_topology_unlock();
 263
 264         return (gp != NULL ? zv : NULL);
 265 }
 266
 267 /* extent mapping arg */
 268 struct maparg {
 269         zvol_state_t    *ma_zv;
 270         uint64_t        ma_blks;
 271 };
 272
 273 /*ARGSUSED*/
 274 static int
 275 zvol_map_block(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf,
 276     const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
 277 {
 278         struct maparg *ma = arg;
 279         zvol_extent_t *ze;
 280         int bs = ma->ma_zv->zv_volblocksize;
 281
 282         if (bp == NULL || zb->zb_object != ZVOL_OBJ || zb->zb_level != 0)
 283                 return (0);
 284
 285         VERIFY3U(ma->ma_blks, ==, zb->zb_blkid);
 286         ma->ma_blks++;
 287
 288         /* Abort immediately if we have encountered gang blocks */
 289         if (BP_IS_GANG(bp))
 290                 return (EFRAGS);
 291
 292         /*
 293          * See if the block is at the end of the previous extent.
 294          */
 295         ze = list_tail(&ma->ma_zv->zv_extents);
 296         if (ze &&
 297             DVA_GET_VDEV(BP_IDENTITY(bp)) == DVA_GET_VDEV(&ze->ze_dva) &&
 298             DVA_GET_OFFSET(BP_IDENTITY(bp)) ==
 299             DVA_GET_OFFSET(&ze->ze_dva) + ze->ze_nblks * bs) {
 300                 ze->ze_nblks++;
 301                 return (0);
 302         }
 303
 304         dprintf_bp(bp, "%s", "next blkptr:");
 305
 306         /* start a new extent */
 307         ze = kmem_zalloc(sizeof (zvol_extent_t), KM_SLEEP);
 308         ze->ze_dva = bp->blk_dva[0];    /* structure assignment */
 309         ze->ze_nblks = 1;
 310         list_insert_tail(&ma->ma_zv->zv_extents, ze);
 311         return (0);
 312 }
 313
 314 static void
 315 zvol_free_extents(zvol_state_t *zv)
 316 {
 317         zvol_extent_t *ze;
 318
 319         while (ze = list_head(&zv->zv_extents)) {
 320                 list_remove(&zv->zv_extents, ze);
 321                 kmem_free(ze, sizeof (zvol_extent_t));
 322         }
 323 }
 324
 325 static int
 326 zvol_get_lbas(zvol_state_t *zv)
 327 {
 328         objset_t *os = zv->zv_objset;
 329         struct maparg   ma;
 330         int             err;
 331
 332         ma.ma_zv = zv;
 333         ma.ma_blks = 0;
 334         zvol_free_extents(zv);
 335
 336         /* commit any in-flight changes before traversing the dataset */
 337         txg_wait_synced(dmu_objset_pool(os), 0);
 338         err = traverse_dataset(dmu_objset_ds(os), 0,
 339             TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA, zvol_map_block, &ma);
 340         if (err || ma.ma_blks != (zv->zv_volsize / zv->zv_volblocksize)) {
 341                 zvol_free_extents(zv);
 342                 return (err ? err : EIO);
 343         }
 344
 345         return (0);
 346 }
 347
 348 /* ARGSUSED */
 349 void
 350 zvol_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
 351 {
 352         zfs_creat_t *zct = arg;
 353         nvlist_t *nvprops = zct->zct_props;
 354         int error;
 355         uint64_t volblocksize, volsize;
 356
 357         VERIFY(nvlist_lookup_uint64(nvprops,
 358             zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) == 0);
 359         if (nvlist_lookup_uint64(nvprops,
 360             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), &volblocksize) != 0)
 361                 volblocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
 362
 363         /*
 364          * These properties must be removed from the list so the generic
 365          * property setting step won't apply to them.
 366          */
 367         VERIFY(nvlist_remove_all(nvprops,
 368             zfs_prop_to_name(ZFS_PROP_VOLSIZE)) == 0);
 369         (void) nvlist_remove_all(nvprops,
 370             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE));
 371
 372         error = dmu_object_claim(os, ZVOL_OBJ, DMU_OT_ZVOL, volblocksize,
 373             DMU_OT_NONE, 0, tx);
 374         ASSERT(error == 0);
 375
 376         error = zap_create_claim(os, ZVOL_ZAP_OBJ, DMU_OT_ZVOL_PROP,
 377             DMU_OT_NONE, 0, tx);
 378         ASSERT(error == 0);
 379
 380         error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize, tx);
 381         ASSERT(error == 0);
 382 }
 383
 384 /*
 385  * Replay a TX_WRITE ZIL transaction that didn't get committed
 386  * after a system failure
 387  */
 388 static int
 389 zvol_replay_write(zvol_state_t *zv, lr_write_t *lr, boolean_t byteswap)
 390 {
 391         objset_t *os = zv->zv_objset;
 392         char *data = (char *)(lr + 1);  /* data follows lr_write_t */
 393         uint64_t offset, length;
 394         dmu_tx_t *tx;
 395         int error;
 396
 397         if (byteswap)
 398                 byteswap_uint64_array(lr, sizeof (*lr));
 399
 400         offset = lr->lr_offset;
 401         length = lr->lr_length;
 402
 403         /* If it's a dmu_sync() block, write the whole block */
 404         if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
 405                 uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);
 406                 if (length < blocksize) {
 407                         offset -= offset % blocksize;
 408                         length = blocksize;
 409                 }
 410         }
 411
 412         tx = dmu_tx_create(os);
 413         dmu_tx_hold_write(tx, ZVOL_OBJ, offset, length);
 414         error = dmu_tx_assign(tx, TXG_WAIT);
 415         if (error) {
 416                 dmu_tx_abort(tx);
 417         } else {
 418                 dmu_write(os, ZVOL_OBJ, offset, length, data, tx);
 419                 dmu_tx_commit(tx);
 420         }
 421
 422         return (error);
 423 }
 424
 425 /* ARGSUSED */
 426 static int
 427 zvol_replay_err(zvol_state_t *zv, lr_t *lr, boolean_t byteswap)
 428 {
 429         return (ENOTSUP);
 430 }
 431
 432 /*
 433  * Callback vectors for replaying records.
 434  * Only TX_WRITE is needed for zvol.
 435  */
 436 zil_replay_func_t *zvol_replay_vector[TX_MAX_TYPE] = {
 437         zvol_replay_err,        /* 0 no such transaction type */
 438         zvol_replay_err,        /* TX_CREATE */
 439         zvol_replay_err,        /* TX_MKDIR */
 440         zvol_replay_err,        /* TX_MKXATTR */
 441         zvol_replay_err,        /* TX_SYMLINK */
 442         zvol_replay_err,        /* TX_REMOVE */
 443         zvol_replay_err,        /* TX_RMDIR */
 444         zvol_replay_err,        /* TX_LINK */
 445         zvol_replay_err,        /* TX_RENAME */
 446         zvol_replay_write,      /* TX_WRITE */
 447         zvol_replay_err,        /* TX_TRUNCATE */
 448         zvol_replay_err,        /* TX_SETATTR */
 449         zvol_replay_err,        /* TX_ACL */
 450         zvol_replay_err,        /* TX_CREATE_ACL */
 451         zvol_replay_err,        /* TX_CREATE_ATTR */
 452         zvol_replay_err,        /* TX_CREATE_ACL_ATTR */
 453         zvol_replay_err,        /* TX_MKDIR_ACL */
 454         zvol_replay_err,        /* TX_MKDIR_ATTR */
 455         zvol_replay_err,        /* TX_MKDIR_ACL_ATTR */
 456         zvol_replay_err,        /* TX_WRITE2 */
 457 };
 458
 459 #ifdef sun
 460 int
 461 zvol_name2minor(const char *name, minor_t *minor)
 462 {
 463         zvol_state_t *zv;
 464
 465         mutex_enter(&spa_namespace_lock);
 466         zv = zvol_minor_lookup(name);
 467         if (minor && zv)
 468                 *minor = zv->zv_minor;
 469         mutex_exit(&spa_namespace_lock);
 470         return (zv ? 0 : -1);
 471 }
 472 #endif  /* sun */
 473
 474 /*
 475  * Create a minor node (plus a whole lot more) for the specified volume.
 476  */
 477 int
 478 zvol_create_minor(const char *name)
 479 {
 480         zfs_soft_state_t *zs;
 481         zvol_state_t *zv;
 482         objset_t *os;
 483         dmu_object_info_t doi;
 484         uint64_t volsize;
 485         int error;
 486
 487         ZFS_LOG(1, "Creating ZVOL %s...", name);
 488
 489         mutex_enter(&spa_namespace_lock);
 490
 491         if (zvol_minor_lookup(name) != NULL) {
 492                 mutex_exit(&spa_namespace_lock);
 493                 return (EEXIST);
 494         }
 495
 496         /* lie and say we're read-only */
 497         error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, FTAG, &os);
 498
 499         if (error) {
 500                 mutex_exit(&spa_namespace_lock);
 501                 return (error);
 502         }
 503
 504 #ifdef sun
 505         if ((minor = zfsdev_minor_alloc()) == 0) {
 506                 dmu_objset_disown(os, FTAG);
 507                 mutex_exit(&spa_namespace_lock);
 508                 return (ENXIO);
 509         }
 510
 511         if (ddi_soft_state_zalloc(zfsdev_state, minor) != DDI_SUCCESS) {
 512                 dmu_objset_disown(os, FTAG);
 513                 mutex_exit(&spa_namespace_lock);
 514                 return (EAGAIN);
 515         }
 516         (void) ddi_prop_update_string(minor, zfs_dip, ZVOL_PROP_NAME,
 517             (char *)name);
 518
 519         (void) snprintf(chrbuf, sizeof (chrbuf), "%u,raw", minor);
 520
 521         if (ddi_create_minor_node(zfs_dip, chrbuf, S_IFCHR,
 522             minor, DDI_PSEUDO, 0) == DDI_FAILURE) {
 523                 ddi_soft_state_free(zfsdev_state, minor);
 524                 dmu_objset_disown(os, FTAG);
 525                 mutex_exit(&spa_namespace_lock);
 526                 return (EAGAIN);
 527         }
 528
 529         (void) snprintf(blkbuf, sizeof (blkbuf), "%u", minor);
 530
 531         if (ddi_create_minor_node(zfs_dip, blkbuf, S_IFBLK,
 532             minor, DDI_PSEUDO, 0) == DDI_FAILURE) {
 533                 ddi_remove_minor_node(zfs_dip, chrbuf);
 534                 ddi_soft_state_free(zfsdev_state, minor);
 535                 dmu_objset_disown(os, FTAG);
 536                 mutex_exit(&spa_namespace_lock);
 537                 return (EAGAIN);
 538         }
 539
 540         zs = ddi_get_soft_state(zfsdev_state, minor);
 541         zs->zss_type = ZSST_ZVOL;
 542         zv = zs->zss_data = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP);
 543 #else   /* !sun */
 544
 545         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
 546         if (error) {
 547                 ASSERT(error == 0);
 548                 dmu_objset_disown(os, zvol_tag);
 549                 mutex_exit(&spa_namespace_lock);
 550                 return (error);
 551         }
 552
 553         DROP_GIANT();
 554         g_topology_lock();
 555         zv = zvol_geom_create(name);
 556         zv->zv_volsize = volsize;
 557         zv->zv_provider->mediasize = zv->zv_volsize;
 558
 559 #endif  /* !sun */
 560
 561         (void) strlcpy(zv->zv_name, name, MAXPATHLEN);
 562         zv->zv_min_bs = DEV_BSHIFT;
 563         zv->zv_objset = os;
 564         if (dmu_objset_is_snapshot(os) || !spa_writeable(dmu_objset_spa(os)))
 565                 zv->zv_flags |= ZVOL_RDONLY;
 566         mutex_init(&zv->zv_znode.z_range_lock, NULL, MUTEX_DEFAULT, NULL);
 567         avl_create(&zv->zv_znode.z_range_avl, zfs_range_compare,
 568             sizeof (rl_t), offsetof(rl_t, r_node));
 569         list_create(&zv->zv_extents, sizeof (zvol_extent_t),
 570             offsetof(zvol_extent_t, ze_node));
 571         /* get and cache the blocksize */
 572         error = dmu_object_info(os, ZVOL_OBJ, &doi);
 573         ASSERT(error == 0);
 574         zv->zv_volblocksize = doi.doi_data_block_size;
 575
 576         if (spa_writeable(dmu_objset_spa(os))) {
 577                 if (zil_replay_disable)
 578                         zil_destroy(dmu_objset_zil(os), B_FALSE);
 579                 else
 580                         zil_replay(os, zv, zvol_replay_vector);
 581         }
 582         dmu_objset_disown(os, FTAG);
 583         zv->zv_objset = NULL;
 584
 585         zvol_minors++;
 586
 587         mutex_exit(&spa_namespace_lock);
 588
 589         zvol_geom_run(zv);
 590
 591         g_topology_unlock();
 592         PICKUP_GIANT();
 593
 594         ZFS_LOG(1, "ZVOL %s created.", name);
 595
 596         return (0);
 597 }
 598
 599 /*
 600  * Remove minor node for the specified volume.
 601  */
 602 static int
 603 zvol_remove_zv(zvol_state_t *zv)
 604 {
 605 #ifdef sun
 606         minor_t minor = zv->zv_minor;
 607 #endif
 608
 609         ASSERT(MUTEX_HELD(&spa_namespace_lock));
 610         if (zv->zv_total_opens != 0)
 611                 return (EBUSY);
 612
 613         ZFS_LOG(1, "ZVOL %s destroyed.", zv->zv_name);
 614
 615 #ifdef sun
 616         (void) snprintf(nmbuf, sizeof (nmbuf), "%u,raw", minor);
 617         ddi_remove_minor_node(zfs_dip, nmbuf);
 618 #endif  /* sun */
 619
 620         avl_destroy(&zv->zv_znode.z_range_avl);
 621         mutex_destroy(&zv->zv_znode.z_range_lock);
 622
 623         zvol_geom_destroy(zv);
 624
 625         zvol_minors--;
 626         return (0);
 627 }
 628
 629 int
 630 zvol_remove_minor(const char *name)
 631 {
 632         zvol_state_t *zv;
 633         int rc;
 634
 635         mutex_enter(&spa_namespace_lock);
 636         if ((zv = zvol_minor_lookup(name)) == NULL) {
 637                 mutex_exit(&spa_namespace_lock);
 638                 return (ENXIO);
 639         }
 640         g_topology_lock();
 641         rc = zvol_remove_zv(zv);
 642         g_topology_unlock();
 643         mutex_exit(&spa_namespace_lock);
 644         return (rc);
 645 }
 646
 647 int
 648 zvol_first_open(zvol_state_t *zv)
 649 {
 650         objset_t *os;
 651         uint64_t volsize;
 652         int error;
 653         uint64_t readonly;
 654
 655         /* lie and say we're read-only */
 656         error = dmu_objset_own(zv->zv_name, DMU_OST_ZVOL, B_TRUE,
 657             zvol_tag, &os);
 658         if (error)
 659                 return (error);
 660
 661         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
 662         if (error) {
 663                 ASSERT(error == 0);
 664                 dmu_objset_disown(os, zvol_tag);
 665                 return (error);
 666         }
 667         zv->zv_objset = os;
 668         error = dmu_bonus_hold(os, ZVOL_OBJ, zvol_tag, &zv->zv_dbuf);
 669         if (error) {
 670                 dmu_objset_disown(os, zvol_tag);
 671                 return (error);
 672         }
 673         zv->zv_volsize = volsize;
 674         zv->zv_zilog = zil_open(os, zvol_get_data);
 675         zvol_size_changed(zv);
 676
 677         VERIFY(dsl_prop_get_integer(zv->zv_name, "readonly", &readonly,
 678             NULL) == 0);
 679         if (readonly || dmu_objset_is_snapshot(os) ||
 680             !spa_writeable(dmu_objset_spa(os)))
 681                 zv->zv_flags |= ZVOL_RDONLY;
 682         else
 683                 zv->zv_flags &= ~ZVOL_RDONLY;
 684         return (error);
 685 }
 686
 687 void
 688 zvol_last_close(zvol_state_t *zv)
 689 {
 690         zil_close(zv->zv_zilog);
 691         zv->zv_zilog = NULL;
 692
 693         dmu_buf_rele(zv->zv_dbuf, zvol_tag);
 694         zv->zv_dbuf = NULL;
 695
 696         /*
 697          * Evict cached data
 698          */
 699         if (dsl_dataset_is_dirty(dmu_objset_ds(zv->zv_objset)) &&
 700             !(zv->zv_flags & ZVOL_RDONLY))
 701                 txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);
 702         (void) dmu_objset_evict_dbufs(zv->zv_objset);
 703
 704         dmu_objset_disown(zv->zv_objset, zvol_tag);
 705         zv->zv_objset = NULL;
 706 }
 707
 708 #ifdef sun
 709 int
 710 zvol_prealloc(zvol_state_t *zv)
 711 {
 712         objset_t *os = zv->zv_objset;
 713         dmu_tx_t *tx;
 714         uint64_t refd, avail, usedobjs, availobjs;
 715         uint64_t resid = zv->zv_volsize;
 716         uint64_t off = 0;
 717
 718         /* Check the space usage before attempting to allocate the space */
 719         dmu_objset_space(os, &refd, &avail, &usedobjs, &availobjs);
 720         if (avail < zv->zv_volsize)
 721                 return (ENOSPC);
 722
 723         /* Free old extents if they exist */
 724         zvol_free_extents(zv);
 725
 726         while (resid != 0) {
 727                 int error;
 728                 uint64_t bytes = MIN(resid, SPA_MAXBLOCKSIZE);
 729
 730                 tx = dmu_tx_create(os);
 731                 dmu_tx_hold_write(tx, ZVOL_OBJ, off, bytes);
 732                 error = dmu_tx_assign(tx, TXG_WAIT);
 733                 if (error) {
 734                         dmu_tx_abort(tx);
 735                         (void) dmu_free_long_range(os, ZVOL_OBJ, 0, off);
 736                         return (error);
 737                 }
 738                 dmu_prealloc(os, ZVOL_OBJ, off, bytes, tx);
 739                 dmu_tx_commit(tx);
 740                 off += bytes;
 741                 resid -= bytes;
 742         }
 743         txg_wait_synced(dmu_objset_pool(os), 0);
 744
 745         return (0);
 746 }
 747 #endif  /* sun */
 748
 749 int
 750 zvol_update_volsize(objset_t *os, uint64_t volsize)
 751 {
 752         dmu_tx_t *tx;
 753         int error;
 754
 755         ASSERT(MUTEX_HELD(&spa_namespace_lock));
 756
 757         tx = dmu_tx_create(os);
 758         dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
 759         error = dmu_tx_assign(tx, TXG_WAIT);
 760         if (error) {
 761                 dmu_tx_abort(tx);
 762                 return (error);
 763         }
 764
 765         error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1,
 766             &volsize, tx);
 767         dmu_tx_commit(tx);
 768
 769         if (error == 0)
 770                 error = dmu_free_long_range(os,
 771                     ZVOL_OBJ, volsize, DMU_OBJECT_END);
 772         return (error);
 773 }
 774
 775 void
 776 zvol_remove_minors(const char *name)
 777 {
 778         struct g_geom *gp, *gptmp;
 779         struct g_provider *pp;
 780         zvol_state_t *zv;
 781         size_t namelen;
 782
 783         namelen = strlen(name);
 784
 785         DROP_GIANT();
 786         mutex_enter(&spa_namespace_lock);
 787         g_topology_lock();
 788
 789         LIST_FOREACH_SAFE(gp, &zfs_zvol_class.geom, geom, gptmp) {
 790                 pp = LIST_FIRST(&gp->provider);
 791                 if (pp == NULL)
 792                         continue;
 793                 zv = pp->private;
 794                 if (zv == NULL)
 795                         continue;
 796                 if (strcmp(zv->zv_name, name) == 0 ||
 797                     (strncmp(zv->zv_name, name, namelen) == 0 &&
 798                      zv->zv_name[namelen] == '/')) {
 799                         (void) zvol_remove_zv(zv);
 800                 }
 801         }
 802
 803         g_topology_unlock();
 804         mutex_exit(&spa_namespace_lock);
 805         PICKUP_GIANT();
 806 }
 807
 808 int
 809 zvol_set_volsize(const char *name, major_t maj, uint64_t volsize)
 810 {
 811         zvol_state_t *zv = NULL;
 812         objset_t *os;
 813         int error;
 814         dmu_object_info_t doi;
 815         uint64_t old_volsize = 0ULL;
 816         uint64_t readonly;
 817
 818         mutex_enter(&spa_namespace_lock);
 819         zv = zvol_minor_lookup(name);
 820         if ((error = dmu_objset_hold(name, FTAG, &os)) != 0) {
 821                 mutex_exit(&spa_namespace_lock);
 822                 return (error);
 823         }
 824
 825         if ((error = dmu_object_info(os, ZVOL_OBJ, &doi)) != 0 ||
 826             (error = zvol_check_volsize(volsize,
 827             doi.doi_data_block_size)) != 0)
 828                 goto out;
 829
 830         VERIFY(dsl_prop_get_integer(name, "readonly", &readonly,
 831             NULL) == 0);
 832         if (readonly) {
 833                 error = EROFS;
 834                 goto out;
 835         }
 836
 837         error = zvol_update_volsize(os, volsize);
 838         /*
 839          * Reinitialize the dump area to the new size. If we
 840          * failed to resize the dump area then restore it back to
 841          * its original size.
 842          */
 843         if (zv && error == 0) {
 844 #ifdef ZVOL_DUMP
 845                 if (zv->zv_flags & ZVOL_DUMPIFIED) {
 846                         old_volsize = zv->zv_volsize;
 847                         zv->zv_volsize = volsize;
 848                         if ((error = zvol_dumpify(zv)) != 0 ||
 849                             (error = dumpvp_resize()) != 0) {
 850                                 (void) zvol_update_volsize(os, old_volsize);
 851                                 zv->zv_volsize = old_volsize;
 852                                 error = zvol_dumpify(zv);
 853                         }
 854                 }
 855 #endif  /* ZVOL_DUMP */
 856                 if (error == 0) {
 857                         zv->zv_volsize = volsize;
 858                         zvol_size_changed(zv);
 859                 }
 860         }
 861
 862 #ifdef sun
 863         /*
 864          * Generate a LUN expansion event.
 865          */
 866         if (zv && error == 0) {
 867                 sysevent_id_t eid;
 868                 nvlist_t *attr;
 869                 char *physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 870
 871                 (void) snprintf(physpath, MAXPATHLEN, "%s%u", ZVOL_PSEUDO_DEV,
 872                     zv->zv_minor);
 873
 874                 VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 875                 VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0);
 876
 877                 (void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS,
 878                     ESC_DEV_DLE, attr, &eid, DDI_SLEEP);
 879
 880                 nvlist_free(attr);
 881                 kmem_free(physpath, MAXPATHLEN);
 882         }
 883 #endif  /* sun */
 884
 885 out:
 886         dmu_objset_rele(os, FTAG);
 887
 888         mutex_exit(&spa_namespace_lock);
 889
 890         return (error);
 891 }
 892
 893 /*ARGSUSED*/
 894 static int
 895 zvol_open(struct g_provider *pp, int flag, int count)
 896 {
 897         zvol_state_t *zv;
 898         int err = 0;
 899         boolean_t locked = B_FALSE;
 900
 901         /*
 902          * Protect against recursively entering spa_namespace_lock
 903          * when spa_open() is used for a pool on a (local) ZVOL(s).
 904          * This is needed since we replaced upstream zfsdev_state_lock
 905          * with spa_namespace_lock in the ZVOL code.
 906          * We are using the same trick as spa_open().
 907          * Note that calls in zvol_first_open which need to resolve
 908          * pool name to a spa object will enter spa_open()
 909          * recursively, but that function already has all the
 910          * necessary protection.
 911          */
 912         if (!MUTEX_HELD(&spa_namespace_lock)) {
 913                 mutex_enter(&spa_namespace_lock);
 914                 locked = B_TRUE;
 915         }
 916
 917         zv = pp->private;
 918         if (zv == NULL) {
 919                 if (locked)
 920                         mutex_exit(&spa_namespace_lock);
 921                 return (ENXIO);
 922         }
 923
 924         if (zv->zv_total_opens == 0)
 925                 err = zvol_first_open(zv);
 926         if (err) {
 927                 if (locked)
 928                         mutex_exit(&spa_namespace_lock);
 929                 return (err);
 930         }
 931         if ((flag & FWRITE) && (zv->zv_flags & ZVOL_RDONLY)) {
 932                 err = EROFS;
 933                 goto out;
 934         }
 935         if (zv->zv_flags & ZVOL_EXCL) {
 936                 err = EBUSY;
 937                 goto out;
 938         }
 939 #ifdef FEXCL
 940         if (flag & FEXCL) {
 941                 if (zv->zv_total_opens != 0) {
 942                         err = EBUSY;
 943                         goto out;
 944                 }
 945                 zv->zv_flags |= ZVOL_EXCL;
 946         }
 947 #endif
 948
 949         zv->zv_total_opens += count;
 950         if (locked)
 951                 mutex_exit(&spa_namespace_lock);
 952
 953         return (err);
 954 out:
 955         if (zv->zv_total_opens == 0)
 956                 zvol_last_close(zv);
 957         if (locked)
 958                 mutex_exit(&spa_namespace_lock);
 959         return (err);
 960 }
 961
 962 /*ARGSUSED*/
 963 static int
 964 zvol_close(struct g_provider *pp, int flag, int count)
 965 {
 966         zvol_state_t *zv;
 967         int error = 0;
 968         boolean_t locked = B_FALSE;
 969
 970         /* See comment in zvol_open(). */
 971         if (!MUTEX_HELD(&spa_namespace_lock)) {
 972                 mutex_enter(&spa_namespace_lock);
 973                 locked = B_TRUE;
 974         }
 975
 976         zv = pp->private;
 977         if (zv == NULL) {
 978                 if (locked)
 979                         mutex_exit(&spa_namespace_lock);
 980                 return (ENXIO);
 981         }
 982
 983         if (zv->zv_flags & ZVOL_EXCL) {
 984                 ASSERT(zv->zv_total_opens == 1);
 985                 zv->zv_flags &= ~ZVOL_EXCL;
 986         }
 987
 988         /*
 989          * If the open count is zero, this is a spurious close.
 990          * That indicates a bug in the kernel / DDI framework.
 991          */
 992         ASSERT(zv->zv_total_opens != 0);
 993
 994         /*
 995          * You may get multiple opens, but only one close.
 996          */
 997         zv->zv_total_opens -= count;
 998
 999         if (zv->zv_total_opens == 0)
1000                 zvol_last_close(zv);
1001
1002         if (locked)
1003                 mutex_exit(&spa_namespace_lock);
1004         return (error);
1005 }
1006
1007 static void
1008 zvol_get_done(zgd_t *zgd, int error)
1009 {
1010         if (zgd->zgd_db)
1011                 dmu_buf_rele(zgd->zgd_db, zgd);
1012
1013         zfs_range_unlock(zgd->zgd_rl);
1014
1015         if (error == 0 && zgd->zgd_bp)
1016                 zil_add_block(zgd->zgd_zilog, zgd->zgd_bp);
1017
1018         kmem_free(zgd, sizeof (zgd_t));
1019 }
1020
1021 /*
1022  * Get data to generate a TX_WRITE intent log record.
1023  */
1024 static int
1025 zvol_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
1026 {
1027         zvol_state_t *zv = arg;
1028         objset_t *os = zv->zv_objset;
1029         uint64_t object = ZVOL_OBJ;
1030         uint64_t offset = lr->lr_offset;
1031         uint64_t size = lr->lr_length;  /* length of user data */
1032         blkptr_t *bp = &lr->lr_blkptr;
1033         dmu_buf_t *db;
1034         zgd_t *zgd;
1035         int error;
1036
1037         ASSERT(zio != NULL);
1038         ASSERT(size != 0);
1039
1040         zgd = kmem_zalloc(sizeof (zgd_t), KM_SLEEP);
1041         zgd->zgd_zilog = zv->zv_zilog;
1042         zgd->zgd_rl = zfs_range_lock(&zv->zv_znode, offset, size, RL_READER);
1043
1044         /*
1045          * Write records come in two flavors: immediate and indirect.
1046          * For small writes it's cheaper to store the data with the
1047          * log record (immediate); for large writes it's cheaper to
1048          * sync the data and get a pointer to it (indirect) so that
1049          * we don't have to write the data twice.
1050          */
1051         if (buf != NULL) {      /* immediate write */
1052                 error = dmu_read(os, object, offset, size, buf,
1053                     DMU_READ_NO_PREFETCH);
1054         } else {
1055                 size = zv->zv_volblocksize;
1056                 offset = P2ALIGN(offset, size);
1057                 error = dmu_buf_hold(os, object, offset, zgd, &db,
1058                     DMU_READ_NO_PREFETCH);
1059                 if (error == 0) {
1060                         zgd->zgd_db = db;
1061                         zgd->zgd_bp = bp;
1062
1063                         ASSERT(db->db_offset == offset);
1064                         ASSERT(db->db_size == size);
1065
1066                         error = dmu_sync(zio, lr->lr_common.lrc_txg,
1067                             zvol_get_done, zgd);
1068
1069                         if (error == 0)
1070                                 return (0);
1071                 }
1072         }
1073
1074         zvol_get_done(zgd, error);
1075
1076         return (error);
1077 }
1078
1079 /*
1080  * zvol_log_write() handles synchronous writes using TX_WRITE ZIL transactions.
1081  *
1082  * We store data in the log buffers if it's small enough.
1083  * Otherwise we will later flush the data out via dmu_sync().
1084  */
1085 ssize_t zvol_immediate_write_sz = 32768;
1086
1087 static void
1088 zvol_log_write(zvol_state_t *zv, dmu_tx_t *tx, offset_t off, ssize_t resid,
1089     boolean_t sync)
1090 {
1091         uint32_t blocksize = zv->zv_volblocksize;
1092         zilog_t *zilog = zv->zv_zilog;
1093         boolean_t slogging;
1094         ssize_t immediate_write_sz;
1095
1096         if (zil_replaying(zilog, tx))
1097                 return;
1098
1099         immediate_write_sz = (zilog->zl_logbias == ZFS_LOGBIAS_THROUGHPUT)
1100             ? 0 : zvol_immediate_write_sz;
1101
1102         slogging = spa_has_slogs(zilog->zl_spa) &&
1103             (zilog->zl_logbias == ZFS_LOGBIAS_LATENCY);
1104
1105         while (resid) {
1106                 itx_t *itx;
1107                 lr_write_t *lr;
1108                 ssize_t len;
1109                 itx_wr_state_t write_state;
1110
1111                 /*
1112                  * Unlike zfs_log_write() we can be called with
1113                  * upto DMU_MAX_ACCESS/2 (5MB) writes.
1114                  */
1115                 if (blocksize > immediate_write_sz && !slogging &&
1116                     resid >= blocksize && off % blocksize == 0) {
1117                         write_state = WR_INDIRECT; /* uses dmu_sync */
1118                         len = blocksize;
1119                 } else if (sync) {
1120                         write_state = WR_COPIED;
1121                         len = MIN(ZIL_MAX_LOG_DATA, resid);
1122                 } else {
1123                         write_state = WR_NEED_COPY;
1124                         len = MIN(ZIL_MAX_LOG_DATA, resid);
1125                 }
1126
1127                 itx = zil_itx_create(TX_WRITE, sizeof (*lr) +
1128                     (write_state == WR_COPIED ? len : 0));
1129                 lr = (lr_write_t *)&itx->itx_lr;
1130                 if (write_state == WR_COPIED && dmu_read(zv->zv_objset,
1131                     ZVOL_OBJ, off, len, lr + 1, DMU_READ_NO_PREFETCH) != 0) {
1132                         zil_itx_destroy(itx);
1133                         itx = zil_itx_create(TX_WRITE, sizeof (*lr));
1134                         lr = (lr_write_t *)&itx->itx_lr;
1135                         write_state = WR_NEED_COPY;
1136                 }
1137
1138                 itx->itx_wr_state = write_state;
1139                 if (write_state == WR_NEED_COPY)
1140                         itx->itx_sod += len;
1141                 lr->lr_foid = ZVOL_OBJ;
1142                 lr->lr_offset = off;
1143                 lr->lr_length = len;
1144                 lr->lr_blkoff = 0;
1145                 BP_ZERO(&lr->lr_blkptr);
1146
1147                 itx->itx_private = zv;
1148                 itx->itx_sync = sync;
1149
1150                 zil_itx_assign(zilog, itx, tx);
1151
1152                 off += len;
1153                 resid -= len;
1154         }
1155 }
1156
1157 #ifdef sun
1158 static int
1159 zvol_dumpio_vdev(vdev_t *vd, void *addr, uint64_t offset, uint64_t size,
1160     boolean_t doread, boolean_t isdump)
1161 {
1162         vdev_disk_t *dvd;
1163         int c;
1164         int numerrors = 0;
1165
1166         for (c = 0; c < vd->vdev_children; c++) {
1167                 ASSERT(vd->vdev_ops == &vdev_mirror_ops ||
1168                     vd->vdev_ops == &vdev_replacing_ops ||
1169                     vd->vdev_ops == &vdev_spare_ops);
1170                 int err = zvol_dumpio_vdev(vd->vdev_child[c],
1171                     addr, offset, size, doread, isdump);
1172                 if (err != 0) {
1173                         numerrors++;
1174                 } else if (doread) {
1175                         break;
1176                 }
1177         }
1178
1179         if (!vd->vdev_ops->vdev_op_leaf)
1180                 return (numerrors < vd->vdev_children ? 0 : EIO);
1181
1182         if (doread && !vdev_readable(vd))
1183                 return (EIO);
1184         else if (!doread && !vdev_writeable(vd))
1185                 return (EIO);
1186
1187         dvd = vd->vdev_tsd;
1188         ASSERT3P(dvd, !=, NULL);
1189         offset += VDEV_LABEL_START_SIZE;
1190
1191         if (ddi_in_panic() || isdump) {
1192                 ASSERT(!doread);
1193                 if (doread)
1194                         return (EIO);
1195                 return (ldi_dump(dvd->vd_lh, addr, lbtodb(offset),
1196                     lbtodb(size)));
1197         } else {
1198                 return (vdev_disk_physio(dvd->vd_lh, addr, size, offset,
1199                     doread ? B_READ : B_WRITE));
1200         }
1201 }
1202
1203 static int
1204 zvol_dumpio(zvol_state_t *zv, void *addr, uint64_t offset, uint64_t size,
1205     boolean_t doread, boolean_t isdump)
1206 {
1207         vdev_t *vd;
1208         int error;
1209         zvol_extent_t *ze;
1210         spa_t *spa = dmu_objset_spa(zv->zv_objset);
1211
1212         /* Must be sector aligned, and not stradle a block boundary. */
1213         if (P2PHASE(offset, DEV_BSIZE) || P2PHASE(size, DEV_BSIZE) ||
1214             P2BOUNDARY(offset, size, zv->zv_volblocksize)) {
1215                 return (EINVAL);
1216         }
1217         ASSERT(size <= zv->zv_volblocksize);
1218
1219         /* Locate the extent this belongs to */
1220         ze = list_head(&zv->zv_extents);
1221         while (offset >= ze->ze_nblks * zv->zv_volblocksize) {
1222                 offset -= ze->ze_nblks * zv->zv_volblocksize;
1223                 ze = list_next(&zv->zv_extents, ze);
1224         }
1225
1226         if (!ddi_in_panic())
1227                 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
1228
1229         vd = vdev_lookup_top(spa, DVA_GET_VDEV(&ze->ze_dva));
1230         offset += DVA_GET_OFFSET(&ze->ze_dva);
1231         error = zvol_dumpio_vdev(vd, addr, offset, size, doread, isdump);
1232
1233         if (!ddi_in_panic())
1234                 spa_config_exit(spa, SCL_STATE, FTAG);
1235
1236         return (error);
1237 }
1238 #endif  /* sun */
1239
1240 int
1241 zvol_strategy(struct bio *bp)
1242 {
1243         zvol_state_t *zv = bp->bio_to->private;
1244         uint64_t off, volsize;
1245         size_t resid;
1246         char *addr;
1247         objset_t *os;
1248         rl_t *rl;
1249         int error = 0;
1250         boolean_t doread = (bp->bio_cmd == BIO_READ);
1251         boolean_t sync;
1252
1253         if (zv == NULL) {
1254                 g_io_deliver(bp, ENXIO);
1255                 return (0);
1256         }
1257
1258         if (bp->bio_cmd != BIO_READ && (zv->zv_flags & ZVOL_RDONLY)) {
1259                 g_io_deliver(bp, EROFS);
1260                 return (0);
1261         }
1262
1263         off = bp->bio_offset;
1264         volsize = zv->zv_volsize;
1265
1266         os = zv->zv_objset;
1267         ASSERT(os != NULL);
1268
1269         addr = bp->bio_data;
1270         resid = bp->bio_length;
1271
1272         if (resid > 0 && (off < 0 || off >= volsize)) {
1273                 g_io_deliver(bp, EIO);
1274                 return (0);
1275         }
1276
1277         sync = !doread && zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS;
1278
1279         /*
1280          * There must be no buffer changes when doing a dmu_sync() because
1281          * we can't change the data whilst calculating the checksum.
1282          */
1283         rl = zfs_range_lock(&zv->zv_znode, off, resid,
1284             doread ? RL_READER : RL_WRITER);
1285
1286         while (resid != 0 && off < volsize) {
1287                 size_t size = MIN(resid, zvol_maxphys);
1288                 if (doread) {
1289                         error = dmu_read(os, ZVOL_OBJ, off, size, addr,
1290                             DMU_READ_PREFETCH);
1291                 } else {
1292                         dmu_tx_t *tx = dmu_tx_create(os);
1293                         dmu_tx_hold_write(tx, ZVOL_OBJ, off, size);
1294                         error = dmu_tx_assign(tx, TXG_WAIT);
1295                         if (error) {
1296                                 dmu_tx_abort(tx);
1297                         } else {
1298                                 dmu_write(os, ZVOL_OBJ, off, size, addr, tx);
1299                                 zvol_log_write(zv, tx, off, size, sync);
1300                                 dmu_tx_commit(tx);
1301                         }
1302                 }
1303                 if (error) {
1304                         /* convert checksum errors into IO errors */
1305                         if (error == ECKSUM)
1306                                 error = EIO;
1307                         break;
1308                 }
1309                 off += size;
1310                 addr += size;
1311                 resid -= size;
1312         }
1313         zfs_range_unlock(rl);
1314
1315         bp->bio_completed = bp->bio_length - resid;
1316         if (bp->bio_completed < bp->bio_length)
1317                 bp->bio_error = (off > volsize ? EINVAL : error);
1318
1319         if (sync)
1320                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
1321         g_io_deliver(bp, 0);
1322
1323         return (0);
1324 }
1325
1326 #ifdef sun
1327 /*
1328  * Set the buffer count to the zvol maximum transfer.
1329  * Using our own routine instead of the default minphys()
1330  * means that for larger writes we write bigger buffers on X86
1331  * (128K instead of 56K) and flush the disk write cache less often
1332  * (every zvol_maxphys - currently 1MB) instead of minphys (currently
1333  * 56K on X86 and 128K on sparc).
1334  */
1335 void
1336 zvol_minphys(struct buf *bp)
1337 {
1338         if (bp->b_bcount > zvol_maxphys)
1339                 bp->b_bcount = zvol_maxphys;
1340 }
1341
1342 int
1343 zvol_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblocks)
1344 {
1345         minor_t minor = getminor(dev);
1346         zvol_state_t *zv;
1347         int error = 0;
1348         uint64_t size;
1349         uint64_t boff;
1350         uint64_t resid;
1351
1352         zv = zfsdev_get_soft_state(minor, ZSST_ZVOL);
1353         if (zv == NULL)
1354                 return (ENXIO);
1355
1356         boff = ldbtob(blkno);
1357         resid = ldbtob(nblocks);
1358
1359         VERIFY3U(boff + resid, <=, zv->zv_volsize);
1360
1361         while (resid) {
1362                 size = MIN(resid, P2END(boff, zv->zv_volblocksize) - boff);
1363                 error = zvol_dumpio(zv, addr, boff, size, B_FALSE, B_TRUE);
1364                 if (error)
1365                         break;
1366                 boff += size;
1367                 addr += size;
1368                 resid -= size;
1369         }
1370
1371         return (error);
1372 }
1373
1374 /*ARGSUSED*/
1375 int
1376 zvol_read(dev_t dev, uio_t *uio, cred_t *cr)
1377 {
1378         minor_t minor = getminor(dev);
1379         zvol_state_t *zv;
1380         uint64_t volsize;
1381         rl_t *rl;
1382         int error = 0;
1383
1384         zv = zfsdev_get_soft_state(minor, ZSST_ZVOL);
1385         if (zv == NULL)
1386                 return (ENXIO);
1387
1388         volsize = zv->zv_volsize;
1389         if (uio->uio_resid > 0 &&
1390             (uio->uio_loffset < 0 || uio->uio_loffset >= volsize))
1391                 return (EIO);
1392
1393         if (zv->zv_flags & ZVOL_DUMPIFIED) {
1394                 error = physio(zvol_strategy, NULL, dev, B_READ,
1395                     zvol_minphys, uio);
1396                 return (error);
1397         }
1398
1399         rl = zfs_range_lock(&zv->zv_znode, uio->uio_loffset, uio->uio_resid,
1400             RL_READER);
1401         while (uio->uio_resid > 0 && uio->uio_loffset < volsize) {
1402                 uint64_t bytes = MIN(uio->uio_resid, DMU_MAX_ACCESS >> 1);
1403
1404                 /* don't read past the end */
1405                 if (bytes > volsize - uio->uio_loffset)
1406                         bytes = volsize - uio->uio_loffset;
1407
1408                 error =  dmu_read_uio(zv->zv_objset, ZVOL_OBJ, uio, bytes);
1409                 if (error) {
1410                         /* convert checksum errors into IO errors */
1411                         if (error == ECKSUM)
1412                                 error = EIO;
1413                         break;
1414                 }
1415         }
1416         zfs_range_unlock(rl);
1417         return (error);
1418 }
1419
1420 /*ARGSUSED*/
1421 int
1422 zvol_write(dev_t dev, uio_t *uio, cred_t *cr)
1423 {
1424         minor_t minor = getminor(dev);
1425         zvol_state_t *zv;
1426         uint64_t volsize;
1427         rl_t *rl;
1428         int error = 0;
1429         boolean_t sync;
1430
1431         zv = zfsdev_get_soft_state(minor, ZSST_ZVOL);
1432         if (zv == NULL)
1433                 return (ENXIO);
1434
1435         volsize = zv->zv_volsize;
1436         if (uio->uio_resid > 0 &&
1437             (uio->uio_loffset < 0 || uio->uio_loffset >= volsize))
1438                 return (EIO);
1439
1440         if (zv->zv_flags & ZVOL_DUMPIFIED) {
1441                 error = physio(zvol_strategy, NULL, dev, B_WRITE,
1442                     zvol_minphys, uio);
1443                 return (error);
1444         }
1445
1446         sync = !(zv->zv_flags & ZVOL_WCE) ||
1447             (zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS);
1448
1449         rl = zfs_range_lock(&zv->zv_znode, uio->uio_loffset, uio->uio_resid,
1450             RL_WRITER);
1451         while (uio->uio_resid > 0 && uio->uio_loffset < volsize) {
1452                 uint64_t bytes = MIN(uio->uio_resid, DMU_MAX_ACCESS >> 1);
1453                 uint64_t off = uio->uio_loffset;
1454                 dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);
1455
1456                 if (bytes > volsize - off)      /* don't write past the end */
1457                         bytes = volsize - off;
1458
1459                 dmu_tx_hold_write(tx, ZVOL_OBJ, off, bytes);
1460                 error = dmu_tx_assign(tx, TXG_WAIT);
1461                 if (error) {
1462                         dmu_tx_abort(tx);
1463                         break;
1464                 }
1465                 error = dmu_write_uio_dbuf(zv->zv_dbuf, uio, bytes, tx);
1466                 if (error == 0)
1467                         zvol_log_write(zv, tx, off, bytes, sync);
1468                 dmu_tx_commit(tx);
1469
1470                 if (error)
1471                         break;
1472         }
1473         zfs_range_unlock(rl);
1474         if (sync)
1475                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
1476         return (error);
1477 }
1478
1479 int
1480 zvol_getefi(void *arg, int flag, uint64_t vs, uint8_t bs)
1481 {
1482         struct uuid uuid = EFI_RESERVED;
1483         efi_gpe_t gpe = { 0 };
1484         uint32_t crc;
1485         dk_efi_t efi;
1486         int length;
1487         char *ptr;
1488
1489         if (ddi_copyin(arg, &efi, sizeof (dk_efi_t), flag))
1490                 return (EFAULT);
1491         ptr = (char *)(uintptr_t)efi.dki_data_64;
1492         length = efi.dki_length;
1493         /*
1494          * Some clients may attempt to request a PMBR for the
1495          * zvol.  Currently this interface will return EINVAL to
1496          * such requests.  These requests could be supported by
1497          * adding a check for lba == 0 and consing up an appropriate
1498          * PMBR.
1499          */
1500         if (efi.dki_lba < 1 || efi.dki_lba > 2 || length <= 0)
1501                 return (EINVAL);
1502
1503         gpe.efi_gpe_StartingLBA = LE_64(34ULL);
1504         gpe.efi_gpe_EndingLBA = LE_64((vs >> bs) - 1);
1505         UUID_LE_CONVERT(gpe.efi_gpe_PartitionTypeGUID, uuid);
1506
1507         if (efi.dki_lba == 1) {
1508                 efi_gpt_t gpt = { 0 };
1509
1510                 gpt.efi_gpt_Signature = LE_64(EFI_SIGNATURE);
1511                 gpt.efi_gpt_Revision = LE_32(EFI_VERSION_CURRENT);
1512                 gpt.efi_gpt_HeaderSize = LE_32(sizeof (gpt));
1513                 gpt.efi_gpt_MyLBA = LE_64(1ULL);
1514                 gpt.efi_gpt_FirstUsableLBA = LE_64(34ULL);
1515                 gpt.efi_gpt_LastUsableLBA = LE_64((vs >> bs) - 1);
1516                 gpt.efi_gpt_PartitionEntryLBA = LE_64(2ULL);
1517                 gpt.efi_gpt_NumberOfPartitionEntries = LE_32(1);
1518                 gpt.efi_gpt_SizeOfPartitionEntry =
1519                     LE_32(sizeof (efi_gpe_t));
1520                 CRC32(crc, &gpe, sizeof (gpe), -1U, crc32_table);
1521                 gpt.efi_gpt_PartitionEntryArrayCRC32 = LE_32(~crc);
1522                 CRC32(crc, &gpt, sizeof (gpt), -1U, crc32_table);
1523                 gpt.efi_gpt_HeaderCRC32 = LE_32(~crc);
1524                 if (ddi_copyout(&gpt, ptr, MIN(sizeof (gpt), length),
1525                     flag))
1526                         return (EFAULT);
1527                 ptr += sizeof (gpt);
1528                 length -= sizeof (gpt);
1529         }
1530         if (length > 0 && ddi_copyout(&gpe, ptr, MIN(sizeof (gpe),
1531             length), flag))
1532                 return (EFAULT);
1533         return (0);
1534 }
1535
1536 /*
1537  * BEGIN entry points to allow external callers access to the volume.
1538  */
1539 /*
1540  * Return the volume parameters needed for access from an external caller.
1541  * These values are invariant as long as the volume is held open.
1542  */
1543 int
1544 zvol_get_volume_params(minor_t minor, uint64_t *blksize,
1545     uint64_t *max_xfer_len, void **minor_hdl, void **objset_hdl, void **zil_hdl,
1546     void **rl_hdl, void **bonus_hdl)
1547 {
1548         zvol_state_t *zv;
1549
1550         zv = zfsdev_get_soft_state(minor, ZSST_ZVOL);
1551         if (zv == NULL)
1552                 return (ENXIO);
1553         if (zv->zv_flags & ZVOL_DUMPIFIED)
1554                 return (ENXIO);
1555
1556         ASSERT(blksize && max_xfer_len && minor_hdl &&
1557             objset_hdl && zil_hdl && rl_hdl && bonus_hdl);
1558
1559         *blksize = zv->zv_volblocksize;
1560         *max_xfer_len = (uint64_t)zvol_maxphys;
1561         *minor_hdl = zv;
1562         *objset_hdl = zv->zv_objset;
1563         *zil_hdl = zv->zv_zilog;
1564         *rl_hdl = &zv->zv_znode;
1565         *bonus_hdl = zv->zv_dbuf;
1566         return (0);
1567 }
1568
1569 /*
1570  * Return the current volume size to an external caller.
1571  * The size can change while the volume is open.
1572  */
1573 uint64_t
1574 zvol_get_volume_size(void *minor_hdl)
1575 {
1576         zvol_state_t *zv = minor_hdl;
1577
1578         return (zv->zv_volsize);
1579 }
1580
1581 /*
1582  * Return the current WCE setting to an external caller.
1583  * The WCE setting can change while the volume is open.
1584  */
1585 int
1586 zvol_get_volume_wce(void *minor_hdl)
1587 {
1588         zvol_state_t *zv = minor_hdl;
1589
1590         return ((zv->zv_flags & ZVOL_WCE) ? 1 : 0);
1591 }
1592
1593 /*
1594  * Entry point for external callers to zvol_log_write
1595  */
1596 void
1597 zvol_log_write_minor(void *minor_hdl, dmu_tx_t *tx, offset_t off, ssize_t resid,
1598     boolean_t sync)
1599 {
1600         zvol_state_t *zv = minor_hdl;
1601
1602         zvol_log_write(zv, tx, off, resid, sync);
1603 }
1604 /*
1605  * END entry points to allow external callers access to the volume.
1606  */
1607
1608 /*
1609  * Dirtbag ioctls to support mkfs(1M) for UFS filesystems.  See dkio(7I).
1610  */
1611 /*ARGSUSED*/
1612 int
1613 zvol_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
1614 {
1615         zvol_state_t *zv;
1616         struct dk_cinfo dki;
1617         struct dk_minfo dkm;
1618         struct dk_callback *dkc;
1619         int error = 0;
1620         rl_t *rl;
1621
1622         mutex_enter(&spa_namespace_lock);
1623
1624         zv = zfsdev_get_soft_state(getminor(dev), ZSST_ZVOL);
1625
1626         if (zv == NULL) {
1627                 mutex_exit(&spa_namespace_lock);
1628                 return (ENXIO);
1629         }
1630         ASSERT(zv->zv_total_opens > 0);
1631
1632         switch (cmd) {
1633
1634         case DKIOCINFO:
1635                 bzero(&dki, sizeof (dki));
1636                 (void) strcpy(dki.dki_cname, "zvol");
1637                 (void) strcpy(dki.dki_dname, "zvol");
1638                 dki.dki_ctype = DKC_UNKNOWN;
1639                 dki.dki_unit = getminor(dev);
1640                 dki.dki_maxtransfer = 1 << (SPA_MAXBLOCKSHIFT - zv->zv_min_bs);
1641                 mutex_exit(&spa_namespace_lock);
1642                 if (ddi_copyout(&dki, (void *)arg, sizeof (dki), flag))
1643                         error = EFAULT;
1644                 return (error);
1645
1646         case DKIOCGMEDIAINFO:
1647                 bzero(&dkm, sizeof (dkm));
1648                 dkm.dki_lbsize = 1U << zv->zv_min_bs;
1649                 dkm.dki_capacity = zv->zv_volsize >> zv->zv_min_bs;
1650                 dkm.dki_media_type = DK_UNKNOWN;
1651                 mutex_exit(&spa_namespace_lock);
1652                 if (ddi_copyout(&dkm, (void *)arg, sizeof (dkm), flag))
1653                         error = EFAULT;
1654                 return (error);
1655
1656         case DKIOCGETEFI:
1657                 {
1658                         uint64_t vs = zv->zv_volsize;
1659                         uint8_t bs = zv->zv_min_bs;
1660
1661                         mutex_exit(&spa_namespace_lock);
1662                         error = zvol_getefi((void *)arg, flag, vs, bs);
1663                         return (error);
1664                 }
1665
1666         case DKIOCFLUSHWRITECACHE:
1667                 dkc = (struct dk_callback *)arg;
1668                 mutex_exit(&spa_namespace_lock);
1669                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
1670                 if ((flag & FKIOCTL) && dkc != NULL && dkc->dkc_callback) {
1671                         (*dkc->dkc_callback)(dkc->dkc_cookie, error);
1672                         error = 0;
1673                 }
1674                 return (error);
1675
1676         case DKIOCGETWCE:
1677                 {
1678                         int wce = (zv->zv_flags & ZVOL_WCE) ? 1 : 0;
1679                         if (ddi_copyout(&wce, (void *)arg, sizeof (int),
1680                             flag))
1681                                 error = EFAULT;
1682                         break;
1683                 }
1684         case DKIOCSETWCE:
1685                 {
1686                         int wce;
1687                         if (ddi_copyin((void *)arg, &wce, sizeof (int),
1688                             flag)) {
1689                                 error = EFAULT;
1690                                 break;
1691                         }
1692                         if (wce) {
1693                                 zv->zv_flags |= ZVOL_WCE;
1694                                 mutex_exit(&spa_namespace_lock);
1695                         } else {
1696                                 zv->zv_flags &= ~ZVOL_WCE;
1697                                 mutex_exit(&spa_namespace_lock);
1698                                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
1699                         }
1700                         return (0);
1701                 }
1702
1703         case DKIOCGGEOM:
1704         case DKIOCGVTOC:
1705                 /*
1706                  * commands using these (like prtvtoc) expect ENOTSUP
1707                  * since we're emulating an EFI label
1708                  */
1709                 error = ENOTSUP;
1710                 break;
1711
1712         case DKIOCDUMPINIT:
1713                 rl = zfs_range_lock(&zv->zv_znode, 0, zv->zv_volsize,
1714                     RL_WRITER);
1715                 error = zvol_dumpify(zv);
1716                 zfs_range_unlock(rl);
1717                 break;
1718
1719         case DKIOCDUMPFINI:
1720                 if (!(zv->zv_flags & ZVOL_DUMPIFIED))
1721                         break;
1722                 rl = zfs_range_lock(&zv->zv_znode, 0, zv->zv_volsize,
1723                     RL_WRITER);
1724                 error = zvol_dump_fini(zv);
1725                 zfs_range_unlock(rl);
1726                 break;
1727
1728         default:
1729                 error = ENOTTY;
1730                 break;
1731
1732         }
1733         mutex_exit(&spa_namespace_lock);
1734         return (error);
1735 }
1736 #endif  /* sun */
1737
1738 int
1739 zvol_busy(void)
1740 {
1741         return (zvol_minors != 0);
1742 }
1743
1744 void
1745 zvol_init(void)
1746 {
1747         VERIFY(ddi_soft_state_init(&zfsdev_state, sizeof (zfs_soft_state_t),
1748             1) == 0);
1749         ZFS_LOG(1, "ZVOL Initialized.");
1750 }
1751
1752 void
1753 zvol_fini(void)
1754 {
1755         ddi_soft_state_fini(&zfsdev_state);
1756         ZFS_LOG(1, "ZVOL Deinitialized.");
1757 }
1758
1759 #ifdef sun
1760 static int
1761 zvol_dump_init(zvol_state_t *zv, boolean_t resize)
1762 {
1763         dmu_tx_t *tx;
1764         int error = 0;
1765         objset_t *os = zv->zv_objset;
1766         nvlist_t *nv = NULL;
1767         uint64_t version = spa_version(dmu_objset_spa(zv->zv_objset));
1768
1769         ASSERT(MUTEX_HELD(&spa_namespace_lock));
1770         error = dmu_free_long_range(zv->zv_objset, ZVOL_OBJ, 0,
1771             DMU_OBJECT_END);
1772         /* wait for dmu_free_long_range to actually free the blocks */
1773         txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);
1774
1775         tx = dmu_tx_create(os);
1776         dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
1777         dmu_tx_hold_bonus(tx, ZVOL_OBJ);
1778         error = dmu_tx_assign(tx, TXG_WAIT);
1779         if (error) {
1780                 dmu_tx_abort(tx);
1781                 return (error);
1782         }
1783
1784         /*
1785          * If we are resizing the dump device then we only need to
1786          * update the refreservation to match the newly updated
1787          * zvolsize. Otherwise, we save off the original state of the
1788          * zvol so that we can restore them if the zvol is ever undumpified.
1789          */
1790         if (resize) {
1791                 error = zap_update(os, ZVOL_ZAP_OBJ,
1792                     zfs_prop_to_name(ZFS_PROP_REFRESERVATION), 8, 1,
1793                     &zv->zv_volsize, tx);
1794         } else {
1795                 uint64_t checksum, compress, refresrv, vbs, dedup;
1796
1797                 error = dsl_prop_get_integer(zv->zv_name,
1798                     zfs_prop_to_name(ZFS_PROP_COMPRESSION), &compress, NULL);
1799                 error = error ? error : dsl_prop_get_integer(zv->zv_name,
1800                     zfs_prop_to_name(ZFS_PROP_CHECKSUM), &checksum, NULL);
1801                 error = error ? error : dsl_prop_get_integer(zv->zv_name,
1802                     zfs_prop_to_name(ZFS_PROP_REFRESERVATION), &refresrv, NULL);
1803                 error = error ? error : dsl_prop_get_integer(zv->zv_name,
1804                     zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), &vbs, NULL);
1805                 if (version >= SPA_VERSION_DEDUP) {
1806                         error = error ? error :
1807                             dsl_prop_get_integer(zv->zv_name,
1808                             zfs_prop_to_name(ZFS_PROP_DEDUP), &dedup, NULL);
1809                 }
1810
1811                 error = error ? error : zap_update(os, ZVOL_ZAP_OBJ,
1812                     zfs_prop_to_name(ZFS_PROP_COMPRESSION), 8, 1,
1813                     &compress, tx);
1814                 error = error ? error : zap_update(os, ZVOL_ZAP_OBJ,
1815                     zfs_prop_to_name(ZFS_PROP_CHECKSUM), 8, 1, &checksum, tx);
1816                 error = error ? error : zap_update(os, ZVOL_ZAP_OBJ,
1817                     zfs_prop_to_name(ZFS_PROP_REFRESERVATION), 8, 1,
1818                     &refresrv, tx);
1819                 error = error ? error : zap_update(os, ZVOL_ZAP_OBJ,
1820                     zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 8, 1,
1821                     &vbs, tx);
1822                 error = error ? error : dmu_object_set_blocksize(
1823                     os, ZVOL_OBJ, SPA_MAXBLOCKSIZE, 0, tx);
1824                 if (version >= SPA_VERSION_DEDUP) {
1825                         error = error ? error : zap_update(os, ZVOL_ZAP_OBJ,
1826                             zfs_prop_to_name(ZFS_PROP_DEDUP), 8, 1,
1827                             &dedup, tx);
1828                 }
1829                 if (error == 0)
1830                         zv->zv_volblocksize = SPA_MAXBLOCKSIZE;
1831         }
1832         dmu_tx_commit(tx);
1833
1834         /*
1835          * We only need update the zvol's property if we are initializing
1836          * the dump area for the first time.
1837          */
1838         if (!resize) {
1839                 VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1840                 VERIFY(nvlist_add_uint64(nv,
1841                     zfs_prop_to_name(ZFS_PROP_REFRESERVATION), 0) == 0);
1842                 VERIFY(nvlist_add_uint64(nv,
1843                     zfs_prop_to_name(ZFS_PROP_COMPRESSION),
1844                     ZIO_COMPRESS_OFF) == 0);
1845                 VERIFY(nvlist_add_uint64(nv,
1846                     zfs_prop_to_name(ZFS_PROP_CHECKSUM),
1847                     ZIO_CHECKSUM_OFF) == 0);
1848                 if (version >= SPA_VERSION_DEDUP) {
1849                         VERIFY(nvlist_add_uint64(nv,
1850                             zfs_prop_to_name(ZFS_PROP_DEDUP),
1851                             ZIO_CHECKSUM_OFF) == 0);
1852                 }
1853
1854                 error = zfs_set_prop_nvlist(zv->zv_name, ZPROP_SRC_LOCAL,
1855                     nv, NULL);
1856                 nvlist_free(nv);
1857
1858                 if (error)
1859                         return (error);
1860         }
1861
1862         /* Allocate the space for the dump */
1863         error = zvol_prealloc(zv);
1864         return (error);
1865 }
1866
1867 static int
1868 zvol_dumpify(zvol_state_t *zv)
1869 {
1870         int error = 0;
1871         uint64_t dumpsize = 0;
1872         dmu_tx_t *tx;
1873         objset_t *os = zv->zv_objset;
1874
1875         if (zv->zv_flags & ZVOL_RDONLY)
1876                 return (EROFS);
1877
1878         if (zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ, ZVOL_DUMPSIZE,
1879             8, 1, &dumpsize) != 0 || dumpsize != zv->zv_volsize) {
1880                 boolean_t resize = (dumpsize > 0) ? B_TRUE : B_FALSE;
1881
1882                 if ((error = zvol_dump_init(zv, resize)) != 0) {
1883                         (void) zvol_dump_fini(zv);
1884                         return (error);
1885                 }
1886         }
1887
1888         /*
1889          * Build up our lba mapping.
1890          */
1891         error = zvol_get_lbas(zv);
1892         if (error) {
1893                 (void) zvol_dump_fini(zv);
1894                 return (error);
1895         }
1896
1897         tx = dmu_tx_create(os);
1898         dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
1899         error = dmu_tx_assign(tx, TXG_WAIT);
1900         if (error) {
1901                 dmu_tx_abort(tx);
1902                 (void) zvol_dump_fini(zv);
1903                 return (error);
1904         }
1905
1906         zv->zv_flags |= ZVOL_DUMPIFIED;
1907         error = zap_update(os, ZVOL_ZAP_OBJ, ZVOL_DUMPSIZE, 8, 1,
1908             &zv->zv_volsize, tx);
1909         dmu_tx_commit(tx);
1910
1911         if (error) {
1912                 (void) zvol_dump_fini(zv);
1913                 return (error);
1914         }
1915
1916         txg_wait_synced(dmu_objset_pool(os), 0);
1917         return (0);
1918 }
1919
1920 static int
1921 zvol_dump_fini(zvol_state_t *zv)
1922 {
1923         dmu_tx_t *tx;
1924         objset_t *os = zv->zv_objset;
1925         nvlist_t *nv;
1926         int error = 0;
1927         uint64_t checksum, compress, refresrv, vbs, dedup;
1928         uint64_t version = spa_version(dmu_objset_spa(zv->zv_objset));
1929
1930         /*
1931          * Attempt to restore the zvol back to its pre-dumpified state.
1932          * This is a best-effort attempt as it's possible that not all
1933          * of these properties were initialized during the dumpify process
1934          * (i.e. error during zvol_dump_init).
1935          */
1936
1937         tx = dmu_tx_create(os);
1938         dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
1939         error = dmu_tx_assign(tx, TXG_WAIT);
1940         if (error) {
1941                 dmu_tx_abort(tx);
1942                 return (error);
1943         }
1944         (void) zap_remove(os, ZVOL_ZAP_OBJ, ZVOL_DUMPSIZE, tx);
1945         dmu_tx_commit(tx);
1946
1947         (void) zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ,
1948             zfs_prop_to_name(ZFS_PROP_CHECKSUM), 8, 1, &checksum);
1949         (void) zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ,
1950             zfs_prop_to_name(ZFS_PROP_COMPRESSION), 8, 1, &compress);
1951         (void) zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ,
1952             zfs_prop_to_name(ZFS_PROP_REFRESERVATION), 8, 1, &refresrv);
1953         (void) zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ,
1954             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 8, 1, &vbs);
1955
1956         VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1957         (void) nvlist_add_uint64(nv,
1958             zfs_prop_to_name(ZFS_PROP_CHECKSUM), checksum);
1959         (void) nvlist_add_uint64(nv,
1960             zfs_prop_to_name(ZFS_PROP_COMPRESSION), compress);
1961         (void) nvlist_add_uint64(nv,
1962             zfs_prop_to_name(ZFS_PROP_REFRESERVATION), refresrv);
1963         if (version >= SPA_VERSION_DEDUP &&
1964             zap_lookup(zv->zv_objset, ZVOL_ZAP_OBJ,
1965             zfs_prop_to_name(ZFS_PROP_DEDUP), 8, 1, &dedup) == 0) {
1966                 (void) nvlist_add_uint64(nv,
1967                     zfs_prop_to_name(ZFS_PROP_DEDUP), dedup);
1968         }
1969         (void) zfs_set_prop_nvlist(zv->zv_name, ZPROP_SRC_LOCAL,
1970             nv, NULL);
1971         nvlist_free(nv);
1972
1973         zvol_free_extents(zv);
1974         zv->zv_flags &= ~ZVOL_DUMPIFIED;
1975         (void) dmu_free_long_range(os, ZVOL_OBJ, 0, DMU_OBJECT_END);
1976         /* wait for dmu_free_long_range to actually free the blocks */
1977         txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);
1978         tx = dmu_tx_create(os);
1979         dmu_tx_hold_bonus(tx, ZVOL_OBJ);
1980         error = dmu_tx_assign(tx, TXG_WAIT);
1981         if (error) {
1982                 dmu_tx_abort(tx);
1983                 return (error);
1984         }
1985         if (dmu_object_set_blocksize(os, ZVOL_OBJ, vbs, 0, tx) == 0)
1986                 zv->zv_volblocksize = vbs;
1987         dmu_tx_commit(tx);
1988
1989         return (0);
1990 }
1991 #endif  /* sun */
1992
1993 static zvol_state_t *
1994 zvol_geom_create(const char *name)
1995 {
1996         struct g_provider *pp;
1997         struct g_geom *gp;
1998         zvol_state_t *zv;
1999
2000         gp = g_new_geomf(&zfs_zvol_class, "zfs::zvol::%s", name);
2001         gp->start = zvol_geom_start;
2002         gp->access = zvol_geom_access;
2003         pp = g_new_providerf(gp, "%s/%s", ZVOL_DRIVER, name);
2004         pp->sectorsize = DEV_BSIZE;
2005
2006         zv = kmem_zalloc(sizeof(*zv), KM_SLEEP);
2007         zv->zv_provider = pp;
2008         zv->zv_state = 0;
2009         bioq_init(&zv->zv_queue);
2010         mtx_init(&zv->zv_queue_mtx, "zvol", NULL, MTX_DEF);
2011
2012         pp->private = zv;
2013
2014         return (zv);
2015 }
2016
2017 static void
2018 zvol_geom_run(zvol_state_t *zv)
2019 {
2020         struct g_provider *pp;
2021
2022         pp = zv->zv_provider;
2023         g_error_provider(pp, 0);
2024
2025         kproc_kthread_add(zvol_geom_worker, zv, &zfsproc, NULL, 0, 0,
2026             "zfskern", "zvol %s", pp->name + sizeof(ZVOL_DRIVER));
2027 }
2028
2029 static void
2030 zvol_geom_destroy(zvol_state_t *zv)
2031 {
2032         struct g_provider *pp;
2033
2034         g_topology_assert();
2035
2036         mtx_lock(&zv->zv_queue_mtx);
2037         zv->zv_state = 1;
2038         wakeup_one(&zv->zv_queue);
2039         while (zv->zv_state != 2)
2040                 msleep(&zv->zv_state, &zv->zv_queue_mtx, 0, "zvol:w", 0);
2041         mtx_destroy(&zv->zv_queue_mtx);
2042
2043         pp = zv->zv_provider;
2044         zv->zv_provider = NULL;
2045         pp->private = NULL;
2046         g_wither_geom(pp->geom, ENXIO);
2047
2048         kmem_free(zv, sizeof(*zv));
2049 }
2050
2051 static int
2052 zvol_geom_access(struct g_provider *pp, int acr, int acw, int ace)
2053 {
2054         int count, error, flags;
2055
2056         g_topology_assert();
2057
2058         /*
2059          * To make it easier we expect either open or close, but not both
2060          * at the same time.
2061          */
2062         KASSERT((acr >= 0 && acw >= 0 && ace >= 0) ||
2063             (acr <= 0 && acw <= 0 && ace <= 0),
2064             ("Unsupported access request to %s (acr=%d, acw=%d, ace=%d).",
2065             pp->name, acr, acw, ace));
2066
2067         if (pp->private == NULL) {
2068                 if (acr <= 0 && acw <= 0 && ace <= 0)
2069                         return (0);
2070                 return (pp->error);
2071         }
2072
2073         /*
2074          * We don't pass FEXCL flag to zvol_open()/zvol_close() if ace != 0,
2075          * because GEOM already handles that and handles it a bit differently.
2076          * GEOM allows for multiple read/exclusive consumers and ZFS allows
2077          * only one exclusive consumer, no matter if it is reader or writer.
2078          * I like better the way GEOM works so I'll leave it for GEOM to
2079          * decide what to do.
2080          */
2081
2082         count = acr + acw + ace;
2083         if (count == 0)
2084                 return (0);
2085
2086         flags = 0;
2087         if (acr != 0 || ace != 0)
2088                 flags |= FREAD;
2089         if (acw != 0)
2090                 flags |= FWRITE;
2091
2092         g_topology_unlock();
2093         if (count > 0)
2094                 error = zvol_open(pp, flags, count);
2095         else
2096                 error = zvol_close(pp, flags, -count);
2097         g_topology_lock();
2098         return (error);
2099 }
2100
2101 static void
2102 zvol_geom_start(struct bio *bp)
2103 {
2104         zvol_state_t *zv;
2105         boolean_t first;
2106
2107         switch (bp->bio_cmd) {
2108         case BIO_READ:
2109         case BIO_WRITE:
2110         case BIO_FLUSH:
2111                 zv = bp->bio_to->private;
2112                 ASSERT(zv != NULL);
2113                 mtx_lock(&zv->zv_queue_mtx);
2114                 first = (bioq_first(&zv->zv_queue) == NULL);
2115                 bioq_insert_tail(&zv->zv_queue, bp);
2116                 mtx_unlock(&zv->zv_queue_mtx);
2117                 if (first)
2118                         wakeup_one(&zv->zv_queue);
2119                 break;
2120         case BIO_GETATTR:
2121         case BIO_DELETE:
2122         default:
2123                 g_io_deliver(bp, EOPNOTSUPP);
2124                 break;
2125         }
2126 }
2127
2128 static void
2129 zvol_geom_worker(void *arg)
2130 {
2131         zvol_state_t *zv;
2132         struct bio *bp;
2133
2134         thread_lock(curthread);
2135         sched_prio(curthread, PRIBIO);
2136         thread_unlock(curthread);
2137
2138         zv = arg;
2139         for (;;) {
2140                 mtx_lock(&zv->zv_queue_mtx);
2141                 bp = bioq_takefirst(&zv->zv_queue);
2142                 if (bp == NULL) {
2143                         if (zv->zv_state == 1) {
2144                                 zv->zv_state = 2;
2145                                 wakeup(&zv->zv_state);
2146                                 mtx_unlock(&zv->zv_queue_mtx);
2147                                 kthread_exit();
2148                         }
2149                         msleep(&zv->zv_queue, &zv->zv_queue_mtx, PRIBIO | PDROP,
2150                             "zvol:io", 0);
2151                         continue;
2152                 }
2153                 mtx_unlock(&zv->zv_queue_mtx);
2154                 switch (bp->bio_cmd) {
2155                 case BIO_FLUSH:
2156                         zil_commit(zv->zv_zilog, ZVOL_OBJ);
2157                         g_io_deliver(bp, 0);
2158                         break;
2159                 case BIO_READ:
2160                 case BIO_WRITE:
2161                         zvol_strategy(bp);
2162                         break;
2163                 }
2164         }
2165 }
2166
2167 extern boolean_t dataset_name_hidden(const char *name);
2168
2169 static int
2170 zvol_create_snapshots(objset_t *os, const char *name)
2171 {
2172         uint64_t cookie, obj;
2173         char *sname;
2174         int error, len;
2175
2176         cookie = obj = 0;
2177         sname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2178
2179         (void) dmu_objset_find(name, dmu_objset_prefetch, NULL,
2180             DS_FIND_SNAPSHOTS);
2181
2182         for (;;) {
2183                 len = snprintf(sname, MAXPATHLEN, "%s@", name);
2184                 if (len >= MAXPATHLEN) {
2185                         dmu_objset_rele(os, FTAG);
2186                         error = ENAMETOOLONG;
2187                         break;
2188                 }
2189
2190                 error = dmu_snapshot_list_next(os, MAXPATHLEN - len,
2191                     sname + len, &obj, &cookie, NULL);
2192                 if (error != 0) {
2193                         if (error == ENOENT)
2194                                 error = 0;
2195                         break;
2196                 }
2197
2198                 if ((error = zvol_create_minor(sname)) != 0) {
2199                         printf("ZFS WARNING: Unable to create ZVOL %s (error=%d).\n",
2200                             sname, error);
2201                         break;
2202                 }
2203         }
2204
2205         kmem_free(sname, MAXPATHLEN);
2206         return (error);
2207 }
2208
2209 int
2210 zvol_create_minors(const char *name)
2211 {
2212         uint64_t cookie;
2213         objset_t *os;
2214         char *osname, *p;
2215         int error, len;
2216
2217         if (dataset_name_hidden(name))
2218                 return (0);
2219
2220         if ((error = dmu_objset_hold(name, FTAG, &os)) != 0) {
2221                 printf("ZFS WARNING: Unable to put hold on %s (error=%d).\n",
2222                     name, error);
2223                 return (error);
2224         }
2225         if (dmu_objset_type(os) == DMU_OST_ZVOL) {
2226                 if ((error = zvol_create_minor(name)) == 0)
2227                         error = zvol_create_snapshots(os, name);
2228                 else {
2229                         printf("ZFS WARNING: Unable to create ZVOL %s (error=%d).\n",
2230                             name, error);
2231                 }
2232                 dmu_objset_rele(os, FTAG);
2233                 return (error);
2234         }
2235         if (dmu_objset_type(os) != DMU_OST_ZFS) {
2236                 dmu_objset_rele(os, FTAG);
2237                 return (0);
2238         }
2239
2240         osname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2241         if (snprintf(osname, MAXPATHLEN, "%s/", name) >= MAXPATHLEN) {
2242                 dmu_objset_rele(os, FTAG);
2243                 kmem_free(osname, MAXPATHLEN);
2244                 return (ENOENT);
2245         }
2246         p = osname + strlen(osname);
2247         len = MAXPATHLEN - (p - osname);
2248
2249         /* Prefetch the datasets. */
2250         cookie = 0;
2251         while (dmu_dir_list_next(os, len, p, NULL, &cookie) == 0) {
2252                 if (!dataset_name_hidden(osname))
2253                         (void) dmu_objset_prefetch(osname, NULL);
2254         }
2255
2256         cookie = 0;
2257         while (dmu_dir_list_next(os, MAXPATHLEN - (p - osname), p, NULL,
2258             &cookie) == 0) {
2259                 dmu_objset_rele(os, FTAG);
2260                 (void)zvol_create_minors(osname);
2261                 if ((error = dmu_objset_hold(name, FTAG, &os)) != 0) {
2262                         printf("ZFS WARNING: Unable to put hold on %s (error=%d).\n",
2263                             name, error);
2264                         return (error);
2265                 }
2266         }
2267
2268         dmu_objset_rele(os, FTAG);
2269         kmem_free(osname, MAXPATHLEN);
2270         return (0);
2271 }
2272
2273 static void
2274 zvol_rename_minor(struct g_geom *gp, const char *newname)
2275 {
2276         struct g_provider *pp;
2277         zvol_state_t *zv;
2278
2279         ASSERT(MUTEX_HELD(&spa_namespace_lock));
2280         g_topology_assert();
2281
2282         pp = LIST_FIRST(&gp->provider);
2283         ASSERT(pp != NULL);
2284         zv = pp->private;
2285         ASSERT(zv != NULL);
2286
2287         zv->zv_provider = NULL;
2288         g_wither_provider(pp, ENXIO);
2289
2290         pp = g_new_providerf(gp, "%s/%s", ZVOL_DRIVER, newname);
2291         pp->sectorsize = DEV_BSIZE;
2292         pp->mediasize = zv->zv_volsize;
2293         pp->private = zv;
2294         zv->zv_provider = pp;
2295         strlcpy(zv->zv_name, newname, sizeof(zv->zv_name));
2296         g_error_provider(pp, 0);
2297 }
2298
2299 void
2300 zvol_rename_minors(const char *oldname, const char *newname)
2301 {
2302         char name[MAXPATHLEN];
2303         struct g_provider *pp;
2304         struct g_geom *gp;
2305         size_t oldnamelen, newnamelen;
2306         zvol_state_t *zv;
2307         char *namebuf;
2308
2309         oldnamelen = strlen(oldname);
2310         newnamelen = strlen(newname);
2311
2312         DROP_GIANT();
2313         mutex_enter(&spa_namespace_lock);
2314         g_topology_lock();
2315
2316         LIST_FOREACH(gp, &zfs_zvol_class.geom, geom) {
2317                 pp = LIST_FIRST(&gp->provider);
2318                 if (pp == NULL)
2319                         continue;
2320                 zv = pp->private;
2321                 if (zv == NULL)
2322                         continue;
2323                 if (strcmp(zv->zv_name, oldname) == 0) {
2324                         zvol_rename_minor(gp, newname);
2325                 } else if (strncmp(zv->zv_name, oldname, oldnamelen) == 0 &&
2326                     (zv->zv_name[oldnamelen] == '/' ||
2327                      zv->zv_name[oldnamelen] == '@')) {
2328                         snprintf(name, sizeof(name), "%s%c%s", newname,
2329                             zv->zv_name[oldnamelen],
2330                             zv->zv_name + oldnamelen + 1);
2331                         zvol_rename_minor(gp, name);
2332                 }
2333         }
2334
2335         g_topology_unlock();
2336         mutex_exit(&spa_namespace_lock);
2337         PICKUP_GIANT();
2338 }