module/zfs/dsl_dataset.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  * Copyright (c) 2011 by Delphix. All rights reserved.
  24  */
  25
  26 #include <sys/dmu_objset.h>
  27 #include <sys/dsl_dataset.h>
  28 #include <sys/dsl_dir.h>
  29 #include <sys/dsl_prop.h>
  30 #include <sys/dsl_synctask.h>
  31 #include <sys/dmu_traverse.h>
  32 #include <sys/dmu_tx.h>
  33 #include <sys/arc.h>
  34 #include <sys/zio.h>
  35 #include <sys/zap.h>
  36 #include <sys/unique.h>
  37 #include <sys/zfs_context.h>
  38 #include <sys/zfs_ioctl.h>
  39 #include <sys/spa.h>
  40 #include <sys/zfs_znode.h>
  41 #include <sys/zfs_onexit.h>
  42 #include <sys/zvol.h>
  43 #include <sys/dsl_scan.h>
  44 #include <sys/dsl_deadlist.h>
  45
  46 static char *dsl_reaper = "the grim reaper";
  47
  48 static dsl_checkfunc_t dsl_dataset_destroy_begin_check;
  49 static dsl_syncfunc_t dsl_dataset_destroy_begin_sync;
  50 static dsl_syncfunc_t dsl_dataset_set_reservation_sync;
  51
  52 #define SWITCH64(x, y) \
  53         { \
  54                 uint64_t __tmp = (x); \
  55                 (x) = (y); \
  56                 (y) = __tmp; \
  57         }
  58
  59 #define DS_REF_MAX      (1ULL << 62)
  60
  61 #define DSL_DEADLIST_BLOCKSIZE  SPA_MAXBLOCKSIZE
  62
  63 #define DSL_DATASET_IS_DESTROYED(ds)    ((ds)->ds_owner == dsl_reaper)
  64
  65
  66 /*
  67  * Figure out how much of this delta should be propogated to the dsl_dir
  68  * layer.  If there's a refreservation, that space has already been
  69  * partially accounted for in our ancestors.
  70  */
  71 static int64_t
  72 parent_delta(dsl_dataset_t *ds, int64_t delta)
  73 {
  74         uint64_t old_bytes, new_bytes;
  75
  76         if (ds->ds_reserved == 0)
  77                 return (delta);
  78
  79         old_bytes = MAX(ds->ds_phys->ds_unique_bytes, ds->ds_reserved);
  80         new_bytes = MAX(ds->ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
  81
  82         ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
  83         return (new_bytes - old_bytes);
  84 }
  85
  86 void
  87 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
  88 {
  89         int used, compressed, uncompressed;
  90         int64_t delta;
  91
  92         used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
  93         compressed = BP_GET_PSIZE(bp);
  94         uncompressed = BP_GET_UCSIZE(bp);
  95
  96         dprintf_bp(bp, "ds=%p", ds);
  97
  98         ASSERT(dmu_tx_is_syncing(tx));
  99         /* It could have been compressed away to nothing */
 100         if (BP_IS_HOLE(bp))
 101                 return;
 102         ASSERT(BP_GET_TYPE(bp) != DMU_OT_NONE);
 103         ASSERT3U(BP_GET_TYPE(bp), <, DMU_OT_NUMTYPES);
 104         if (ds == NULL) {
 105                 /*
 106                  * Account for the meta-objset space in its placeholder
 107                  * dsl_dir.
 108                  */
 109                 ASSERT3U(compressed, ==, uncompressed); /* it's all metadata */
 110                 dsl_dir_diduse_space(tx->tx_pool->dp_mos_dir, DD_USED_HEAD,
 111                     used, compressed, uncompressed, tx);
 112                 dsl_dir_dirty(tx->tx_pool->dp_mos_dir, tx);
 113                 return;
 114         }
 115         dmu_buf_will_dirty(ds->ds_dbuf, tx);
 116
 117         mutex_enter(&ds->ds_dir->dd_lock);
 118         mutex_enter(&ds->ds_lock);
 119         delta = parent_delta(ds, used);
 120         ds->ds_phys->ds_used_bytes += used;
 121         ds->ds_phys->ds_compressed_bytes += compressed;
 122         ds->ds_phys->ds_uncompressed_bytes += uncompressed;
 123         ds->ds_phys->ds_unique_bytes += used;
 124         mutex_exit(&ds->ds_lock);
 125         dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD, delta,
 126             compressed, uncompressed, tx);
 127         dsl_dir_transfer_space(ds->ds_dir, used - delta,
 128             DD_USED_REFRSRV, DD_USED_HEAD, tx);
 129         mutex_exit(&ds->ds_dir->dd_lock);
 130 }
 131
 132 int
 133 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
 134     boolean_t async)
 135 {
 136         int used, compressed, uncompressed;
 137
 138         if (BP_IS_HOLE(bp))
 139                 return (0);
 140
 141         ASSERT(dmu_tx_is_syncing(tx));
 142         ASSERT(bp->blk_birth <= tx->tx_txg);
 143
 144         used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
 145         compressed = BP_GET_PSIZE(bp);
 146         uncompressed = BP_GET_UCSIZE(bp);
 147
 148         ASSERT(used > 0);
 149         if (ds == NULL) {
 150                 /*
 151                  * Account for the meta-objset space in its placeholder
 152                  * dataset.
 153                  */
 154                 dsl_free(tx->tx_pool, tx->tx_txg, bp);
 155
 156                 dsl_dir_diduse_space(tx->tx_pool->dp_mos_dir, DD_USED_HEAD,
 157                     -used, -compressed, -uncompressed, tx);
 158                 dsl_dir_dirty(tx->tx_pool->dp_mos_dir, tx);
 159                 return (used);
 160         }
 161         ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
 162
 163         ASSERT(!dsl_dataset_is_snapshot(ds));
 164         dmu_buf_will_dirty(ds->ds_dbuf, tx);
 165
 166         if (bp->blk_birth > ds->ds_phys->ds_prev_snap_txg) {
 167                 int64_t delta;
 168
 169                 dprintf_bp(bp, "freeing ds=%llu", ds->ds_object);
 170                 dsl_free(tx->tx_pool, tx->tx_txg, bp);
 171
 172                 mutex_enter(&ds->ds_dir->dd_lock);
 173                 mutex_enter(&ds->ds_lock);
 174                 ASSERT(ds->ds_phys->ds_unique_bytes >= used ||
 175                     !DS_UNIQUE_IS_ACCURATE(ds));
 176                 delta = parent_delta(ds, -used);
 177                 ds->ds_phys->ds_unique_bytes -= used;
 178                 mutex_exit(&ds->ds_lock);
 179                 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD,
 180                     delta, -compressed, -uncompressed, tx);
 181                 dsl_dir_transfer_space(ds->ds_dir, -used - delta,
 182                     DD_USED_REFRSRV, DD_USED_HEAD, tx);
 183                 mutex_exit(&ds->ds_dir->dd_lock);
 184         } else {
 185                 dprintf_bp(bp, "putting on dead list: %s", "");
 186                 if (async) {
 187                         /*
 188                          * We are here as part of zio's write done callback,
 189                          * which means we're a zio interrupt thread.  We can't
 190                          * call dsl_deadlist_insert() now because it may block
 191                          * waiting for I/O.  Instead, put bp on the deferred
 192                          * queue and let dsl_pool_sync() finish the job.
 193                          */
 194                         bplist_append(&ds->ds_pending_deadlist, bp);
 195                 } else {
 196                         dsl_deadlist_insert(&ds->ds_deadlist, bp, tx);
 197                 }
 198                 ASSERT3U(ds->ds_prev->ds_object, ==,
 199                     ds->ds_phys->ds_prev_snap_obj);
 200                 ASSERT(ds->ds_prev->ds_phys->ds_num_children > 0);
 201                 /* if (bp->blk_birth > prev prev snap txg) prev unique += bs */
 202                 if (ds->ds_prev->ds_phys->ds_next_snap_obj ==
 203                     ds->ds_object && bp->blk_birth >
 204                     ds->ds_prev->ds_phys->ds_prev_snap_txg) {
 205                         dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
 206                         mutex_enter(&ds->ds_prev->ds_lock);
 207                         ds->ds_prev->ds_phys->ds_unique_bytes += used;
 208                         mutex_exit(&ds->ds_prev->ds_lock);
 209                 }
 210                 if (bp->blk_birth > ds->ds_dir->dd_origin_txg) {
 211                         dsl_dir_transfer_space(ds->ds_dir, used,
 212                             DD_USED_HEAD, DD_USED_SNAP, tx);
 213                 }
 214         }
 215         mutex_enter(&ds->ds_lock);
 216         ASSERT3U(ds->ds_phys->ds_used_bytes, >=, used);
 217         ds->ds_phys->ds_used_bytes -= used;
 218         ASSERT3U(ds->ds_phys->ds_compressed_bytes, >=, compressed);
 219         ds->ds_phys->ds_compressed_bytes -= compressed;
 220         ASSERT3U(ds->ds_phys->ds_uncompressed_bytes, >=, uncompressed);
 221         ds->ds_phys->ds_uncompressed_bytes -= uncompressed;
 222         mutex_exit(&ds->ds_lock);
 223
 224         return (used);
 225 }
 226
 227 uint64_t
 228 dsl_dataset_prev_snap_txg(dsl_dataset_t *ds)
 229 {
 230         uint64_t trysnap = 0;
 231
 232         if (ds == NULL)
 233                 return (0);
 234         /*
 235          * The snapshot creation could fail, but that would cause an
 236          * incorrect FALSE return, which would only result in an
 237          * overestimation of the amount of space that an operation would
 238          * consume, which is OK.
 239          *
 240          * There's also a small window where we could miss a pending
 241          * snapshot, because we could set the sync task in the quiescing
 242          * phase.  So this should only be used as a guess.
 243          */
 244         if (ds->ds_trysnap_txg >
 245             spa_last_synced_txg(ds->ds_dir->dd_pool->dp_spa))
 246                 trysnap = ds->ds_trysnap_txg;
 247         return (MAX(ds->ds_phys->ds_prev_snap_txg, trysnap));
 248 }
 249
 250 boolean_t
 251 dsl_dataset_block_freeable(dsl_dataset_t *ds, const blkptr_t *bp,
 252     uint64_t blk_birth)
 253 {
 254         if (blk_birth <= dsl_dataset_prev_snap_txg(ds))
 255                 return (B_FALSE);
 256
 257         ddt_prefetch(dsl_dataset_get_spa(ds), bp);
 258
 259         return (B_TRUE);
 260 }
 261
 262 /* ARGSUSED */
 263 static void
 264 dsl_dataset_evict(dmu_buf_t *db, void *dsv)
 265 {
 266         dsl_dataset_t *ds = dsv;
 267
 268         ASSERT(ds->ds_owner == NULL || DSL_DATASET_IS_DESTROYED(ds));
 269
 270         unique_remove(ds->ds_fsid_guid);
 271
 272         if (ds->ds_objset != NULL)
 273                 dmu_objset_evict(ds->ds_objset);
 274
 275         if (ds->ds_prev) {
 276                 dsl_dataset_drop_ref(ds->ds_prev, ds);
 277                 ds->ds_prev = NULL;
 278         }
 279
 280         bplist_destroy(&ds->ds_pending_deadlist);
 281         if (db != NULL) {
 282                 dsl_deadlist_close(&ds->ds_deadlist);
 283         } else {
 284                 ASSERT(ds->ds_deadlist.dl_dbuf == NULL);
 285                 ASSERT(!ds->ds_deadlist.dl_oldfmt);
 286         }
 287         if (ds->ds_dir)
 288                 dsl_dir_close(ds->ds_dir, ds);
 289
 290         ASSERT(!list_link_active(&ds->ds_synced_link));
 291
 292         mutex_destroy(&ds->ds_lock);
 293         mutex_destroy(&ds->ds_recvlock);
 294         mutex_destroy(&ds->ds_opening_lock);
 295         rw_destroy(&ds->ds_rwlock);
 296         cv_destroy(&ds->ds_exclusive_cv);
 297
 298         kmem_free(ds, sizeof (dsl_dataset_t));
 299 }
 300
 301 static int
 302 dsl_dataset_get_snapname(dsl_dataset_t *ds)
 303 {
 304         dsl_dataset_phys_t *headphys;
 305         int err;
 306         dmu_buf_t *headdbuf;
 307         dsl_pool_t *dp = ds->ds_dir->dd_pool;
 308         objset_t *mos = dp->dp_meta_objset;
 309
 310         if (ds->ds_snapname[0])
 311                 return (0);
 312         if (ds->ds_phys->ds_next_snap_obj == 0)
 313                 return (0);
 314
 315         err = dmu_bonus_hold(mos, ds->ds_dir->dd_phys->dd_head_dataset_obj,
 316             FTAG, &headdbuf);
 317         if (err)
 318                 return (err);
 319         headphys = headdbuf->db_data;
 320         err = zap_value_search(dp->dp_meta_objset,
 321             headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
 322         dmu_buf_rele(headdbuf, FTAG);
 323         return (err);
 324 }
 325
 326 static int
 327 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
 328 {
 329         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 330         uint64_t snapobj = ds->ds_phys->ds_snapnames_zapobj;
 331         matchtype_t mt;
 332         int err;
 333
 334         if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET)
 335                 mt = MT_FIRST;
 336         else
 337                 mt = MT_EXACT;
 338
 339         err = zap_lookup_norm(mos, snapobj, name, 8, 1,
 340             value, mt, NULL, 0, NULL);
 341         if (err == ENOTSUP && mt == MT_FIRST)
 342                 err = zap_lookup(mos, snapobj, name, 8, 1, value);
 343         return (err);
 344 }
 345
 346 static int
 347 dsl_dataset_snap_remove(dsl_dataset_t *ds, char *name, dmu_tx_t *tx)
 348 {
 349         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 350         uint64_t snapobj = ds->ds_phys->ds_snapnames_zapobj;
 351         matchtype_t mt;
 352         int err;
 353
 354         dsl_dir_snap_cmtime_update(ds->ds_dir);
 355
 356         if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET)
 357                 mt = MT_FIRST;
 358         else
 359                 mt = MT_EXACT;
 360
 361         err = zap_remove_norm(mos, snapobj, name, mt, tx);
 362         if (err == ENOTSUP && mt == MT_FIRST)
 363                 err = zap_remove(mos, snapobj, name, tx);
 364         return (err);
 365 }
 366
 367 static int
 368 dsl_dataset_get_ref(dsl_pool_t *dp, uint64_t dsobj, void *tag,
 369     dsl_dataset_t **dsp)
 370 {
 371         objset_t *mos = dp->dp_meta_objset;
 372         dmu_buf_t *dbuf;
 373         dsl_dataset_t *ds;
 374         int err;
 375         dmu_object_info_t doi;
 376
 377         ASSERT(RW_LOCK_HELD(&dp->dp_config_rwlock) ||
 378             dsl_pool_sync_context(dp));
 379
 380         err = dmu_bonus_hold(mos, dsobj, tag, &dbuf);
 381         if (err)
 382                 return (err);
 383
 384         /* Make sure dsobj has the correct object type. */
 385         dmu_object_info_from_db(dbuf, &doi);
 386         if (doi.doi_type != DMU_OT_DSL_DATASET)
 387                 return (EINVAL);
 388
 389         ds = dmu_buf_get_user(dbuf);
 390         if (ds == NULL) {
 391                 dsl_dataset_t *winner = NULL;
 392
 393                 ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
 394                 ds->ds_dbuf = dbuf;
 395                 ds->ds_object = dsobj;
 396                 ds->ds_phys = dbuf->db_data;
 397                 list_link_init(&ds->ds_synced_link);
 398
 399                 mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
 400                 mutex_init(&ds->ds_recvlock, NULL, MUTEX_DEFAULT, NULL);
 401                 mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
 402                 rw_init(&ds->ds_rwlock, NULL, RW_DEFAULT, NULL);
 403                 cv_init(&ds->ds_exclusive_cv, NULL, CV_DEFAULT, NULL);
 404
 405                 bplist_create(&ds->ds_pending_deadlist);
 406                 dsl_deadlist_open(&ds->ds_deadlist,
 407                     mos, ds->ds_phys->ds_deadlist_obj);
 408
 409                 if (err == 0) {
 410                         err = dsl_dir_open_obj(dp,
 411                             ds->ds_phys->ds_dir_obj, NULL, ds, &ds->ds_dir);
 412                 }
 413                 if (err) {
 414                         mutex_destroy(&ds->ds_lock);
 415                         mutex_destroy(&ds->ds_recvlock);
 416                         mutex_destroy(&ds->ds_opening_lock);
 417                         rw_destroy(&ds->ds_rwlock);
 418                         cv_destroy(&ds->ds_exclusive_cv);
 419                         bplist_destroy(&ds->ds_pending_deadlist);
 420                         dsl_deadlist_close(&ds->ds_deadlist);
 421                         kmem_free(ds, sizeof (dsl_dataset_t));
 422                         dmu_buf_rele(dbuf, tag);
 423                         return (err);
 424                 }
 425
 426                 if (!dsl_dataset_is_snapshot(ds)) {
 427                         ds->ds_snapname[0] = '\0';
 428                         if (ds->ds_phys->ds_prev_snap_obj) {
 429                                 err = dsl_dataset_get_ref(dp,
 430                                     ds->ds_phys->ds_prev_snap_obj,
 431                                     ds, &ds->ds_prev);
 432                         }
 433                 } else {
 434                         if (zfs_flags & ZFS_DEBUG_SNAPNAMES)
 435                                 err = dsl_dataset_get_snapname(ds);
 436                         if (err == 0 && ds->ds_phys->ds_userrefs_obj != 0) {
 437                                 err = zap_count(
 438                                     ds->ds_dir->dd_pool->dp_meta_objset,
 439                                     ds->ds_phys->ds_userrefs_obj,
 440                                     &ds->ds_userrefs);
 441                         }
 442                 }
 443
 444                 if (err == 0 && !dsl_dataset_is_snapshot(ds)) {
 445                         /*
 446                          * In sync context, we're called with either no lock
 447                          * or with the write lock.  If we're not syncing,
 448                          * we're always called with the read lock held.
 449                          */
 450                         boolean_t need_lock =
 451                             !RW_WRITE_HELD(&dp->dp_config_rwlock) &&
 452                             dsl_pool_sync_context(dp);
 453
 454                         if (need_lock)
 455                                 rw_enter(&dp->dp_config_rwlock, RW_READER);
 456
 457                         err = dsl_prop_get_ds(ds,
 458                             "refreservation", sizeof (uint64_t), 1,
 459                             &ds->ds_reserved, NULL);
 460                         if (err == 0) {
 461                                 err = dsl_prop_get_ds(ds,
 462                                     "refquota", sizeof (uint64_t), 1,
 463                                     &ds->ds_quota, NULL);
 464                         }
 465
 466                         if (need_lock)
 467                                 rw_exit(&dp->dp_config_rwlock);
 468                 } else {
 469                         ds->ds_reserved = ds->ds_quota = 0;
 470                 }
 471
 472                 if (err == 0) {
 473                         winner = dmu_buf_set_user_ie(dbuf, ds, &ds->ds_phys,
 474                             dsl_dataset_evict);
 475                 }
 476                 if (err || winner) {
 477                         bplist_destroy(&ds->ds_pending_deadlist);
 478                         dsl_deadlist_close(&ds->ds_deadlist);
 479                         if (ds->ds_prev)
 480                                 dsl_dataset_drop_ref(ds->ds_prev, ds);
 481                         dsl_dir_close(ds->ds_dir, ds);
 482                         mutex_destroy(&ds->ds_lock);
 483                         mutex_destroy(&ds->ds_recvlock);
 484                         mutex_destroy(&ds->ds_opening_lock);
 485                         rw_destroy(&ds->ds_rwlock);
 486                         cv_destroy(&ds->ds_exclusive_cv);
 487                         kmem_free(ds, sizeof (dsl_dataset_t));
 488                         if (err) {
 489                                 dmu_buf_rele(dbuf, tag);
 490                                 return (err);
 491                         }
 492                         ds = winner;
 493                 } else {
 494                         ds->ds_fsid_guid =
 495                             unique_insert(ds->ds_phys->ds_fsid_guid);
 496                 }
 497         }
 498         ASSERT3P(ds->ds_dbuf, ==, dbuf);
 499         ASSERT3P(ds->ds_phys, ==, dbuf->db_data);
 500         ASSERT(ds->ds_phys->ds_prev_snap_obj != 0 ||
 501             spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
 502             dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
 503         mutex_enter(&ds->ds_lock);
 504         if (!dsl_pool_sync_context(dp) && DSL_DATASET_IS_DESTROYED(ds)) {
 505                 mutex_exit(&ds->ds_lock);
 506                 dmu_buf_rele(ds->ds_dbuf, tag);
 507                 return (ENOENT);
 508         }
 509         mutex_exit(&ds->ds_lock);
 510         *dsp = ds;
 511         return (0);
 512 }
 513
 514 static int
 515 dsl_dataset_hold_ref(dsl_dataset_t *ds, void *tag)
 516 {
 517         dsl_pool_t *dp = ds->ds_dir->dd_pool;
 518
 519         /*
 520          * In syncing context we don't want the rwlock lock: there
 521          * may be an existing writer waiting for sync phase to
 522          * finish.  We don't need to worry about such writers, since
 523          * sync phase is single-threaded, so the writer can't be
 524          * doing anything while we are active.
 525          */
 526         if (dsl_pool_sync_context(dp)) {
 527                 ASSERT(!DSL_DATASET_IS_DESTROYED(ds));
 528                 return (0);
 529         }
 530
 531         /*
 532          * Normal users will hold the ds_rwlock as a READER until they
 533          * are finished (i.e., call dsl_dataset_rele()).  "Owners" will
 534          * drop their READER lock after they set the ds_owner field.
 535          *
 536          * If the dataset is being destroyed, the destroy thread will
 537          * obtain a WRITER lock for exclusive access after it's done its
 538          * open-context work and then change the ds_owner to
 539          * dsl_reaper once destruction is assured.  So threads
 540          * may block here temporarily, until the "destructability" of
 541          * the dataset is determined.
 542          */
 543         ASSERT(!RW_WRITE_HELD(&dp->dp_config_rwlock));
 544         mutex_enter(&ds->ds_lock);
 545         while (!rw_tryenter(&ds->ds_rwlock, RW_READER)) {
 546                 rw_exit(&dp->dp_config_rwlock);
 547                 cv_wait(&ds->ds_exclusive_cv, &ds->ds_lock);
 548                 if (DSL_DATASET_IS_DESTROYED(ds)) {
 549                         mutex_exit(&ds->ds_lock);
 550                         dsl_dataset_drop_ref(ds, tag);
 551                         rw_enter(&dp->dp_config_rwlock, RW_READER);
 552                         return (ENOENT);
 553                 }
 554                 /*
 555                  * The dp_config_rwlock lives above the ds_lock. And
 556                  * we need to check DSL_DATASET_IS_DESTROYED() while
 557                  * holding the ds_lock, so we have to drop and reacquire
 558                  * the ds_lock here.
 559                  */
 560                 mutex_exit(&ds->ds_lock);
 561                 rw_enter(&dp->dp_config_rwlock, RW_READER);
 562                 mutex_enter(&ds->ds_lock);
 563         }
 564         mutex_exit(&ds->ds_lock);
 565         return (0);
 566 }
 567
 568 int
 569 dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag,
 570     dsl_dataset_t **dsp)
 571 {
 572         int err = dsl_dataset_get_ref(dp, dsobj, tag, dsp);
 573
 574         if (err)
 575                 return (err);
 576         return (dsl_dataset_hold_ref(*dsp, tag));
 577 }
 578
 579 int
 580 dsl_dataset_own_obj(dsl_pool_t *dp, uint64_t dsobj, boolean_t inconsistentok,
 581     void *tag, dsl_dataset_t **dsp)
 582 {
 583         int err = dsl_dataset_hold_obj(dp, dsobj, tag, dsp);
 584         if (err)
 585                 return (err);
 586         if (!dsl_dataset_tryown(*dsp, inconsistentok, tag)) {
 587                 dsl_dataset_rele(*dsp, tag);
 588                 *dsp = NULL;
 589                 return (EBUSY);
 590         }
 591         return (0);
 592 }
 593
 594 int
 595 dsl_dataset_hold(const char *name, void *tag, dsl_dataset_t **dsp)
 596 {
 597         dsl_dir_t *dd;
 598         dsl_pool_t *dp;
 599         const char *snapname;
 600         uint64_t obj;
 601         int err = 0;
 602
 603         err = dsl_dir_open_spa(NULL, name, FTAG, &dd, &snapname);
 604         if (err)
 605                 return (err);
 606
 607         dp = dd->dd_pool;
 608         obj = dd->dd_phys->dd_head_dataset_obj;
 609         rw_enter(&dp->dp_config_rwlock, RW_READER);
 610         if (obj)
 611                 err = dsl_dataset_get_ref(dp, obj, tag, dsp);
 612         else
 613                 err = ENOENT;
 614         if (err)
 615                 goto out;
 616
 617         err = dsl_dataset_hold_ref(*dsp, tag);
 618
 619         /* we may be looking for a snapshot */
 620         if (err == 0 && snapname != NULL) {
 621                 dsl_dataset_t *ds = NULL;
 622
 623                 if (*snapname++ != '@') {
 624                         dsl_dataset_rele(*dsp, tag);
 625                         err = ENOENT;
 626                         goto out;
 627                 }
 628
 629                 dprintf("looking for snapshot '%s'\n", snapname);
 630                 err = dsl_dataset_snap_lookup(*dsp, snapname, &obj);
 631                 if (err == 0)
 632                         err = dsl_dataset_get_ref(dp, obj, tag, &ds);
 633                 dsl_dataset_rele(*dsp, tag);
 634
 635                 ASSERT3U((err == 0), ==, (ds != NULL));
 636
 637                 if (ds) {
 638                         mutex_enter(&ds->ds_lock);
 639                         if (ds->ds_snapname[0] == 0)
 640                                 (void) strlcpy(ds->ds_snapname, snapname,
 641                                     sizeof (ds->ds_snapname));
 642                         mutex_exit(&ds->ds_lock);
 643                         err = dsl_dataset_hold_ref(ds, tag);
 644                         *dsp = err ? NULL : ds;
 645                 }
 646         }
 647 out:
 648         rw_exit(&dp->dp_config_rwlock);
 649         dsl_dir_close(dd, FTAG);
 650         return (err);
 651 }
 652
 653 int
 654 dsl_dataset_own(const char *name, boolean_t inconsistentok,
 655     void *tag, dsl_dataset_t **dsp)
 656 {
 657         int err = dsl_dataset_hold(name, tag, dsp);
 658         if (err)
 659                 return (err);
 660         if (!dsl_dataset_tryown(*dsp, inconsistentok, tag)) {
 661                 dsl_dataset_rele(*dsp, tag);
 662                 return (EBUSY);
 663         }
 664         return (0);
 665 }
 666
 667 void
 668 dsl_dataset_name(dsl_dataset_t *ds, char *name)
 669 {
 670         if (ds == NULL) {
 671                 (void) strcpy(name, "mos");
 672         } else {
 673                 dsl_dir_name(ds->ds_dir, name);
 674                 VERIFY(0 == dsl_dataset_get_snapname(ds));
 675                 if (ds->ds_snapname[0]) {
 676                         (void) strcat(name, "@");
 677                         /*
 678                          * We use a "recursive" mutex so that we
 679                          * can call dprintf_ds() with ds_lock held.
 680                          */
 681                         if (!MUTEX_HELD(&ds->ds_lock)) {
 682                                 mutex_enter(&ds->ds_lock);
 683                                 (void) strcat(name, ds->ds_snapname);
 684                                 mutex_exit(&ds->ds_lock);
 685                         } else {
 686                                 (void) strcat(name, ds->ds_snapname);
 687                         }
 688                 }
 689         }
 690 }
 691
 692 static int
 693 dsl_dataset_namelen(dsl_dataset_t *ds)
 694 {
 695         int result;
 696
 697         if (ds == NULL) {
 698                 result = 3;     /* "mos" */
 699         } else {
 700                 result = dsl_dir_namelen(ds->ds_dir);
 701                 VERIFY(0 == dsl_dataset_get_snapname(ds));
 702                 if (ds->ds_snapname[0]) {
 703                         ++result;       /* adding one for the @-sign */
 704                         if (!MUTEX_HELD(&ds->ds_lock)) {
 705                                 mutex_enter(&ds->ds_lock);
 706                                 result += strlen(ds->ds_snapname);
 707                                 mutex_exit(&ds->ds_lock);
 708                         } else {
 709                                 result += strlen(ds->ds_snapname);
 710                         }
 711                 }
 712         }
 713
 714         return (result);
 715 }
 716
 717 void
 718 dsl_dataset_drop_ref(dsl_dataset_t *ds, void *tag)
 719 {
 720         dmu_buf_rele(ds->ds_dbuf, tag);
 721 }
 722
 723 void
 724 dsl_dataset_rele(dsl_dataset_t *ds, void *tag)
 725 {
 726         if (!dsl_pool_sync_context(ds->ds_dir->dd_pool)) {
 727                 rw_exit(&ds->ds_rwlock);
 728         }
 729         dsl_dataset_drop_ref(ds, tag);
 730 }
 731
 732 void
 733 dsl_dataset_disown(dsl_dataset_t *ds, void *tag)
 734 {
 735         ASSERT((ds->ds_owner == tag && ds->ds_dbuf) ||
 736             (DSL_DATASET_IS_DESTROYED(ds) && ds->ds_dbuf == NULL));
 737
 738         mutex_enter(&ds->ds_lock);
 739         ds->ds_owner = NULL;
 740         if (RW_WRITE_HELD(&ds->ds_rwlock)) {
 741                 rw_exit(&ds->ds_rwlock);
 742                 cv_broadcast(&ds->ds_exclusive_cv);
 743         }
 744         mutex_exit(&ds->ds_lock);
 745         if (ds->ds_dbuf)
 746                 dsl_dataset_drop_ref(ds, tag);
 747         else
 748                 dsl_dataset_evict(NULL, ds);
 749 }
 750
 751 boolean_t
 752 dsl_dataset_tryown(dsl_dataset_t *ds, boolean_t inconsistentok, void *tag)
 753 {
 754         boolean_t gotit = FALSE;
 755
 756         mutex_enter(&ds->ds_lock);
 757         if (ds->ds_owner == NULL &&
 758             (!DS_IS_INCONSISTENT(ds) || inconsistentok)) {
 759                 ds->ds_owner = tag;
 760                 if (!dsl_pool_sync_context(ds->ds_dir->dd_pool))
 761                         rw_exit(&ds->ds_rwlock);
 762                 gotit = TRUE;
 763         }
 764         mutex_exit(&ds->ds_lock);
 765         return (gotit);
 766 }
 767
 768 void
 769 dsl_dataset_make_exclusive(dsl_dataset_t *ds, void *owner)
 770 {
 771         ASSERT3P(owner, ==, ds->ds_owner);
 772         if (!RW_WRITE_HELD(&ds->ds_rwlock))
 773                 rw_enter(&ds->ds_rwlock, RW_WRITER);
 774 }
 775
 776 uint64_t
 777 dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
 778     uint64_t flags, dmu_tx_t *tx)
 779 {
 780         dsl_pool_t *dp = dd->dd_pool;
 781         dmu_buf_t *dbuf;
 782         dsl_dataset_phys_t *dsphys;
 783         uint64_t dsobj;
 784         objset_t *mos = dp->dp_meta_objset;
 785
 786         if (origin == NULL)
 787                 origin = dp->dp_origin_snap;
 788
 789         ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
 790         ASSERT(origin == NULL || origin->ds_phys->ds_num_children > 0);
 791         ASSERT(dmu_tx_is_syncing(tx));
 792         ASSERT(dd->dd_phys->dd_head_dataset_obj == 0);
 793
 794         dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
 795             DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
 796         VERIFY(0 == dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
 797         dmu_buf_will_dirty(dbuf, tx);
 798         dsphys = dbuf->db_data;
 799         bzero(dsphys, sizeof (dsl_dataset_phys_t));
 800         dsphys->ds_dir_obj = dd->dd_object;
 801         dsphys->ds_flags = flags;
 802         dsphys->ds_fsid_guid = unique_create();
 803         (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
 804             sizeof (dsphys->ds_guid));
 805         dsphys->ds_snapnames_zapobj =
 806             zap_create_norm(mos, U8_TEXTPREP_TOUPPER, DMU_OT_DSL_DS_SNAP_MAP,
 807             DMU_OT_NONE, 0, tx);
 808         dsphys->ds_creation_time = gethrestime_sec();
 809         dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
 810
 811         if (origin == NULL) {
 812                 dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
 813         } else {
 814                 dsl_dataset_t *ohds;
 815
 816                 dsphys->ds_prev_snap_obj = origin->ds_object;
 817                 dsphys->ds_prev_snap_txg =
 818                     origin->ds_phys->ds_creation_txg;
 819                 dsphys->ds_used_bytes =
 820                     origin->ds_phys->ds_used_bytes;
 821                 dsphys->ds_compressed_bytes =
 822                     origin->ds_phys->ds_compressed_bytes;
 823                 dsphys->ds_uncompressed_bytes =
 824                     origin->ds_phys->ds_uncompressed_bytes;
 825                 dsphys->ds_bp = origin->ds_phys->ds_bp;
 826                 dsphys->ds_flags |= origin->ds_phys->ds_flags;
 827
 828                 dmu_buf_will_dirty(origin->ds_dbuf, tx);
 829                 origin->ds_phys->ds_num_children++;
 830
 831                 VERIFY3U(0, ==, dsl_dataset_hold_obj(dp,
 832                     origin->ds_dir->dd_phys->dd_head_dataset_obj, FTAG, &ohds));
 833                 dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
 834                     dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
 835                 dsl_dataset_rele(ohds, FTAG);
 836
 837                 if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
 838                         if (origin->ds_phys->ds_next_clones_obj == 0) {
 839                                 origin->ds_phys->ds_next_clones_obj =
 840                                     zap_create(mos,
 841                                     DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
 842                         }
 843                         VERIFY(0 == zap_add_int(mos,
 844                             origin->ds_phys->ds_next_clones_obj,
 845                             dsobj, tx));
 846                 }
 847
 848                 dmu_buf_will_dirty(dd->dd_dbuf, tx);
 849                 dd->dd_phys->dd_origin_obj = origin->ds_object;
 850                 if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
 851                         if (origin->ds_dir->dd_phys->dd_clones == 0) {
 852                                 dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
 853                                 origin->ds_dir->dd_phys->dd_clones =
 854                                     zap_create(mos,
 855                                     DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
 856                         }
 857                         VERIFY3U(0, ==, zap_add_int(mos,
 858                             origin->ds_dir->dd_phys->dd_clones, dsobj, tx));
 859                 }
 860         }
 861
 862         if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
 863                 dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
 864
 865         dmu_buf_rele(dbuf, FTAG);
 866
 867         dmu_buf_will_dirty(dd->dd_dbuf, tx);
 868         dd->dd_phys->dd_head_dataset_obj = dsobj;
 869
 870         return (dsobj);
 871 }
 872
 873 uint64_t
 874 dsl_dataset_create_sync(dsl_dir_t *pdd, const char *lastname,
 875     dsl_dataset_t *origin, uint64_t flags, cred_t *cr, dmu_tx_t *tx)
 876 {
 877         dsl_pool_t *dp = pdd->dd_pool;
 878         uint64_t dsobj, ddobj;
 879         dsl_dir_t *dd;
 880
 881         ASSERT(lastname[0] != '@');
 882
 883         ddobj = dsl_dir_create_sync(dp, pdd, lastname, tx);
 884         VERIFY(0 == dsl_dir_open_obj(dp, ddobj, lastname, FTAG, &dd));
 885
 886         dsobj = dsl_dataset_create_sync_dd(dd, origin, flags, tx);
 887
 888         dsl_deleg_set_create_perms(dd, tx, cr);
 889
 890         dsl_dir_close(dd, FTAG);
 891
 892         /*
 893          * If we are creating a clone, make sure we zero out any stale
 894          * data from the origin snapshots zil header.
 895          */
 896         if (origin != NULL) {
 897                 dsl_dataset_t *ds;
 898                 objset_t *os;
 899
 900                 VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 901                 VERIFY3U(0, ==, dmu_objset_from_ds(ds, &os));
 902                 bzero(&os->os_zil_header, sizeof (os->os_zil_header));
 903                 dsl_dataset_dirty(ds, tx);
 904                 dsl_dataset_rele(ds, FTAG);
 905         }
 906
 907         return (dsobj);
 908 }
 909
 910 struct destroyarg {
 911         dsl_sync_task_group_t *dstg;
 912         char *snapname;
 913         char *failed;
 914         boolean_t defer;
 915 };
 916
 917 static int
 918 dsl_snapshot_destroy_one(const char *name, void *arg)
 919 {
 920         struct destroyarg *da = arg;
 921         dsl_dataset_t *ds;
 922         int err;
 923         char *dsname;
 924
 925         dsname = kmem_asprintf("%s@%s", name, da->snapname);
 926         err = dsl_dataset_own(dsname, B_TRUE, da->dstg, &ds);
 927         strfree(dsname);
 928         if (err == 0) {
 929                 struct dsl_ds_destroyarg *dsda;
 930
 931                 dsl_dataset_make_exclusive(ds, da->dstg);
 932                 dsda = kmem_zalloc(sizeof (struct dsl_ds_destroyarg), KM_SLEEP);
 933                 dsda->ds = ds;
 934                 dsda->defer = da->defer;
 935                 dsl_sync_task_create(da->dstg, dsl_dataset_destroy_check,
 936                     dsl_dataset_destroy_sync, dsda, da->dstg, 0);
 937         } else if (err == ENOENT) {
 938                 err = 0;
 939         } else {
 940                 (void) strcpy(da->failed, name);
 941         }
 942         return (err);
 943 }
 944
 945 /*
 946  * Destroy 'snapname' in all descendants of 'fsname'.
 947  */
 948 #pragma weak dmu_snapshots_destroy = dsl_snapshots_destroy
 949 int
 950 dsl_snapshots_destroy(char *fsname, char *snapname, boolean_t defer)
 951 {
 952         int err;
 953         struct destroyarg da;
 954         dsl_sync_task_t *dst;
 955         spa_t *spa;
 956
 957         err = spa_open(fsname, &spa, FTAG);
 958         if (err)
 959                 return (err);
 960         da.dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
 961         da.snapname = snapname;
 962         da.failed = fsname;
 963         da.defer = defer;
 964
 965         err = dmu_objset_find(fsname,
 966             dsl_snapshot_destroy_one, &da, DS_FIND_CHILDREN);
 967
 968         if (err == 0)
 969                 err = dsl_sync_task_group_wait(da.dstg);
 970
 971         for (dst = list_head(&da.dstg->dstg_tasks); dst;
 972             dst = list_next(&da.dstg->dstg_tasks, dst)) {
 973                 struct dsl_ds_destroyarg *dsda = dst->dst_arg1;
 974                 dsl_dataset_t *ds = dsda->ds;
 975
 976                 /*
 977                  * Return the file system name that triggered the error
 978                  */
 979                 if (dst->dst_err) {
 980                         dsl_dataset_name(ds, fsname);
 981                         *strchr(fsname, '@') = '\0';
 982                 }
 983                 ASSERT3P(dsda->rm_origin, ==, NULL);
 984                 dsl_dataset_disown(ds, da.dstg);
 985                 kmem_free(dsda, sizeof (struct dsl_ds_destroyarg));
 986         }
 987
 988         dsl_sync_task_group_destroy(da.dstg);
 989         spa_close(spa, FTAG);
 990         return (err);
 991 }
 992
 993 static boolean_t
 994 dsl_dataset_might_destroy_origin(dsl_dataset_t *ds)
 995 {
 996         boolean_t might_destroy = B_FALSE;
 997
 998         mutex_enter(&ds->ds_lock);
 999         if (ds->ds_phys->ds_num_children == 2 && ds->ds_userrefs == 0 &&
1000             DS_IS_DEFER_DESTROY(ds))
1001                 might_destroy = B_TRUE;
1002         mutex_exit(&ds->ds_lock);
1003
1004         return (might_destroy);
1005 }
1006
1007 /*
1008  * If we're removing a clone, and these three conditions are true:
1009  *      1) the clone's origin has no other children
1010  *      2) the clone's origin has no user references
1011  *      3) the clone's origin has been marked for deferred destruction
1012  * Then, prepare to remove the origin as part of this sync task group.
1013  */
1014 static int
1015 dsl_dataset_origin_rm_prep(struct dsl_ds_destroyarg *dsda, void *tag)
1016 {
1017         dsl_dataset_t *ds = dsda->ds;
1018         dsl_dataset_t *origin = ds->ds_prev;
1019
1020         if (dsl_dataset_might_destroy_origin(origin)) {
1021                 char *name;
1022                 int namelen;
1023                 int error;
1024
1025                 namelen = dsl_dataset_namelen(origin) + 1;
1026                 name = kmem_alloc(namelen, KM_SLEEP);
1027                 dsl_dataset_name(origin, name);
1028 #ifdef _KERNEL
1029                 error = zfs_unmount_snap(name, NULL);
1030                 if (error) {
1031                         kmem_free(name, namelen);
1032                         return (error);
1033                 }
1034 #endif
1035                 error = dsl_dataset_own(name, B_TRUE, tag, &origin);
1036                 kmem_free(name, namelen);
1037                 if (error)
1038                         return (error);
1039                 dsda->rm_origin = origin;
1040                 dsl_dataset_make_exclusive(origin, tag);
1041         }
1042
1043         return (0);
1044 }
1045
1046 /*
1047  * ds must be opened as OWNER.  On return (whether successful or not),
1048  * ds will be closed and caller can no longer dereference it.
1049  */
1050 int
1051 dsl_dataset_destroy(dsl_dataset_t *ds, void *tag, boolean_t defer)
1052 {
1053         int err;
1054         dsl_sync_task_group_t *dstg;
1055         objset_t *os;
1056         dsl_dir_t *dd;
1057         uint64_t obj;
1058         struct dsl_ds_destroyarg dsda = { 0 };
1059         dsl_dataset_t *dummy_ds;
1060
1061         dsda.ds = ds;
1062
1063         if (dsl_dataset_is_snapshot(ds)) {
1064                 /* Destroying a snapshot is simpler */
1065                 dsl_dataset_make_exclusive(ds, tag);
1066
1067                 dsda.defer = defer;
1068                 err = dsl_sync_task_do(ds->ds_dir->dd_pool,
1069                     dsl_dataset_destroy_check, dsl_dataset_destroy_sync,
1070                     &dsda, tag, 0);
1071                 ASSERT3P(dsda.rm_origin, ==, NULL);
1072                 goto out;
1073         } else if (defer) {
1074                 err = EINVAL;
1075                 goto out;
1076         }
1077
1078         dd = ds->ds_dir;
1079         dummy_ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
1080         dummy_ds->ds_dir = dd;
1081         dummy_ds->ds_object = ds->ds_object;
1082
1083         /*
1084          * Check for errors and mark this ds as inconsistent, in
1085          * case we crash while freeing the objects.
1086          */
1087         err = dsl_sync_task_do(dd->dd_pool, dsl_dataset_destroy_begin_check,
1088             dsl_dataset_destroy_begin_sync, ds, NULL, 0);
1089         if (err)
1090                 goto out_free;
1091
1092         err = dmu_objset_from_ds(ds, &os);
1093         if (err)
1094                 goto out_free;
1095
1096         /*
1097          * remove the objects in open context, so that we won't
1098          * have too much to do in syncing context.
1099          */
1100         for (obj = 0; err == 0; err = dmu_object_next(os, &obj, FALSE,
1101             ds->ds_phys->ds_prev_snap_txg)) {
1102                 /*
1103                  * Ignore errors, if there is not enough disk space
1104                  * we will deal with it in dsl_dataset_destroy_sync().
1105                  */
1106                 (void) dmu_free_object(os, obj);
1107         }
1108         if (err != ESRCH)
1109                 goto out_free;
1110
1111         /*
1112          * Only the ZIL knows how to free log blocks.
1113          */
1114         zil_destroy(dmu_objset_zil(os), B_FALSE);
1115
1116         /*
1117          * Sync out all in-flight IO.
1118          */
1119         txg_wait_synced(dd->dd_pool, 0);
1120
1121         /*
1122          * If we managed to free all the objects in open
1123          * context, the user space accounting should be zero.
1124          */
1125         if (ds->ds_phys->ds_bp.blk_fill == 0 &&
1126             dmu_objset_userused_enabled(os)) {
1127                 ASSERTV(uint64_t count);
1128                 ASSERT(zap_count(os, DMU_USERUSED_OBJECT, &count) != 0 ||
1129                     count == 0);
1130                 ASSERT(zap_count(os, DMU_GROUPUSED_OBJECT, &count) != 0 ||
1131                     count == 0);
1132         }
1133
1134         rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
1135         err = dsl_dir_open_obj(dd->dd_pool, dd->dd_object, NULL, FTAG, &dd);
1136         rw_exit(&dd->dd_pool->dp_config_rwlock);
1137
1138         if (err)
1139                 goto out_free;
1140
1141         /*
1142          * Blow away the dsl_dir + head dataset.
1143          */
1144         dsl_dataset_make_exclusive(ds, tag);
1145         /*
1146          * If we're removing a clone, we might also need to remove its
1147          * origin.
1148          */
1149         do {
1150                 dsda.need_prep = B_FALSE;
1151                 if (dsl_dir_is_clone(dd)) {
1152                         err = dsl_dataset_origin_rm_prep(&dsda, tag);
1153                         if (err) {
1154                                 dsl_dir_close(dd, FTAG);
1155                                 goto out_free;
1156                         }
1157                 }
1158
1159                 dstg = dsl_sync_task_group_create(ds->ds_dir->dd_pool);
1160                 dsl_sync_task_create(dstg, dsl_dataset_destroy_check,
1161                     dsl_dataset_destroy_sync, &dsda, tag, 0);
1162                 dsl_sync_task_create(dstg, dsl_dir_destroy_check,
1163                     dsl_dir_destroy_sync, dummy_ds, FTAG, 0);
1164                 err = dsl_sync_task_group_wait(dstg);
1165                 dsl_sync_task_group_destroy(dstg);
1166
1167                 /*
1168                  * We could be racing against 'zfs release' or 'zfs destroy -d'
1169                  * on the origin snap, in which case we can get EBUSY if we
1170                  * needed to destroy the origin snap but were not ready to
1171                  * do so.
1172                  */
1173                 if (dsda.need_prep) {
1174                         ASSERT(err == EBUSY);
1175                         ASSERT(dsl_dir_is_clone(dd));
1176                         ASSERT(dsda.rm_origin == NULL);
1177                 }
1178         } while (dsda.need_prep);
1179
1180         if (dsda.rm_origin != NULL)
1181                 dsl_dataset_disown(dsda.rm_origin, tag);
1182
1183         /* if it is successful, dsl_dir_destroy_sync will close the dd */
1184         if (err)
1185                 dsl_dir_close(dd, FTAG);
1186
1187 out_free:
1188         kmem_free(dummy_ds, sizeof (dsl_dataset_t));
1189 out:
1190         dsl_dataset_disown(ds, tag);
1191         return (err);
1192 }
1193
1194 blkptr_t *
1195 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1196 {
1197         return (&ds->ds_phys->ds_bp);
1198 }
1199
1200 void
1201 dsl_dataset_set_blkptr(dsl_dataset_t *ds, blkptr_t *bp, dmu_tx_t *tx)
1202 {
1203         ASSERT(dmu_tx_is_syncing(tx));
1204         /* If it's the meta-objset, set dp_meta_rootbp */
1205         if (ds == NULL) {
1206                 tx->tx_pool->dp_meta_rootbp = *bp;
1207         } else {
1208                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1209                 ds->ds_phys->ds_bp = *bp;
1210         }
1211 }
1212
1213 spa_t *
1214 dsl_dataset_get_spa(dsl_dataset_t *ds)
1215 {
1216         return (ds->ds_dir->dd_pool->dp_spa);
1217 }
1218
1219 void
1220 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1221 {
1222         dsl_pool_t *dp;
1223
1224         if (ds == NULL) /* this is the meta-objset */
1225                 return;
1226
1227         ASSERT(ds->ds_objset != NULL);
1228
1229         if (ds->ds_phys->ds_next_snap_obj != 0)
1230                 panic("dirtying snapshot!");
1231
1232         dp = ds->ds_dir->dd_pool;
1233
1234         if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg) == 0) {
1235                 /* up the hold count until we can be written out */
1236                 dmu_buf_add_ref(ds->ds_dbuf, ds);
1237         }
1238 }
1239
1240 /*
1241  * The unique space in the head dataset can be calculated by subtracting
1242  * the space used in the most recent snapshot, that is still being used
1243  * in this file system, from the space currently in use.  To figure out
1244  * the space in the most recent snapshot still in use, we need to take
1245  * the total space used in the snapshot and subtract out the space that
1246  * has been freed up since the snapshot was taken.
1247  */
1248 static void
1249 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
1250 {
1251         uint64_t mrs_used;
1252         uint64_t dlused, dlcomp, dluncomp;
1253
1254         ASSERT(!dsl_dataset_is_snapshot(ds));
1255
1256         if (ds->ds_phys->ds_prev_snap_obj != 0)
1257                 mrs_used = ds->ds_prev->ds_phys->ds_used_bytes;
1258         else
1259                 mrs_used = 0;
1260
1261         dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
1262
1263         ASSERT3U(dlused, <=, mrs_used);
1264         ds->ds_phys->ds_unique_bytes =
1265             ds->ds_phys->ds_used_bytes - (mrs_used - dlused);
1266
1267         if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
1268             SPA_VERSION_UNIQUE_ACCURATE)
1269                 ds->ds_phys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1270 }
1271
1272 struct killarg {
1273         dsl_dataset_t *ds;
1274         dmu_tx_t *tx;
1275 };
1276
1277 /* ARGSUSED */
1278 static int
1279 kill_blkptr(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf,
1280     const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
1281 {
1282         struct killarg *ka = arg;
1283         dmu_tx_t *tx = ka->tx;
1284
1285         if (bp == NULL)
1286                 return (0);
1287
1288         if (zb->zb_level == ZB_ZIL_LEVEL) {
1289                 ASSERT(zilog != NULL);
1290                 /*
1291                  * It's a block in the intent log.  It has no
1292                  * accounting, so just free it.
1293                  */
1294                 dsl_free(ka->tx->tx_pool, ka->tx->tx_txg, bp);
1295         } else {
1296                 ASSERT(zilog == NULL);
1297                 ASSERT3U(bp->blk_birth, >, ka->ds->ds_phys->ds_prev_snap_txg);
1298                 (void) dsl_dataset_block_kill(ka->ds, bp, tx, B_FALSE);
1299         }
1300
1301         return (0);
1302 }
1303
1304 /* ARGSUSED */
1305 static int
1306 dsl_dataset_destroy_begin_check(void *arg1, void *arg2, dmu_tx_t *tx)
1307 {
1308         dsl_dataset_t *ds = arg1;
1309         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1310         uint64_t count;
1311         int err;
1312
1313         /*
1314          * Can't delete a head dataset if there are snapshots of it.
1315          * (Except if the only snapshots are from the branch we cloned
1316          * from.)
1317          */
1318         if (ds->ds_prev != NULL &&
1319             ds->ds_prev->ds_phys->ds_next_snap_obj == ds->ds_object)
1320                 return (EBUSY);
1321
1322         /*
1323          * This is really a dsl_dir thing, but check it here so that
1324          * we'll be less likely to leave this dataset inconsistent &
1325          * nearly destroyed.
1326          */
1327         err = zap_count(mos, ds->ds_dir->dd_phys->dd_child_dir_zapobj, &count);
1328         if (err)
1329                 return (err);
1330         if (count != 0)
1331                 return (EEXIST);
1332
1333         return (0);
1334 }
1335
1336 /* ARGSUSED */
1337 static void
1338 dsl_dataset_destroy_begin_sync(void *arg1, void *arg2, dmu_tx_t *tx)
1339 {
1340         dsl_dataset_t *ds = arg1;
1341         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1342
1343         /* Mark it as inconsistent on-disk, in case we crash */
1344         dmu_buf_will_dirty(ds->ds_dbuf, tx);
1345         ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT;
1346
1347         spa_history_log_internal(LOG_DS_DESTROY_BEGIN, dp->dp_spa, tx,
1348             "dataset = %llu", ds->ds_object);
1349 }
1350
1351 static int
1352 dsl_dataset_origin_check(struct dsl_ds_destroyarg *dsda, void *tag,
1353     dmu_tx_t *tx)
1354 {
1355         dsl_dataset_t *ds = dsda->ds;
1356         dsl_dataset_t *ds_prev = ds->ds_prev;
1357
1358         if (dsl_dataset_might_destroy_origin(ds_prev)) {
1359                 struct dsl_ds_destroyarg ndsda = {0};
1360
1361                 /*
1362                  * If we're not prepared to remove the origin, don't remove
1363                  * the clone either.
1364                  */
1365                 if (dsda->rm_origin == NULL) {
1366                         dsda->need_prep = B_TRUE;
1367                         return (EBUSY);
1368                 }
1369
1370                 ndsda.ds = ds_prev;
1371                 ndsda.is_origin_rm = B_TRUE;
1372                 return (dsl_dataset_destroy_check(&ndsda, tag, tx));
1373         }
1374
1375         /*
1376          * If we're not going to remove the origin after all,
1377          * undo the open context setup.
1378          */
1379         if (dsda->rm_origin != NULL) {
1380                 dsl_dataset_disown(dsda->rm_origin, tag);
1381                 dsda->rm_origin = NULL;
1382         }
1383
1384         return (0);
1385 }
1386
1387 /*
1388  * If you add new checks here, you may need to add
1389  * additional checks to the "temporary" case in
1390  * snapshot_check() in dmu_objset.c.
1391  */
1392 /* ARGSUSED */
1393 int
1394 dsl_dataset_destroy_check(void *arg1, void *arg2, dmu_tx_t *tx)
1395 {
1396         struct dsl_ds_destroyarg *dsda = arg1;
1397         dsl_dataset_t *ds = dsda->ds;
1398
1399         /* we have an owner hold, so noone else can destroy us */
1400         ASSERT(!DSL_DATASET_IS_DESTROYED(ds));
1401
1402         /*
1403          * Only allow deferred destroy on pools that support it.
1404          * NOTE: deferred destroy is only supported on snapshots.
1405          */
1406         if (dsda->defer) {
1407                 if (spa_version(ds->ds_dir->dd_pool->dp_spa) <
1408                     SPA_VERSION_USERREFS)
1409                         return (ENOTSUP);
1410                 ASSERT(dsl_dataset_is_snapshot(ds));
1411                 return (0);
1412         }
1413
1414         /*
1415          * Can't delete a head dataset if there are snapshots of it.
1416          * (Except if the only snapshots are from the branch we cloned
1417          * from.)
1418          */
1419         if (ds->ds_prev != NULL &&
1420             ds->ds_prev->ds_phys->ds_next_snap_obj == ds->ds_object)
1421                 return (EBUSY);
1422
1423         /*
1424          * If we made changes this txg, traverse_dsl_dataset won't find
1425          * them.  Try again.
1426          */
1427         if (ds->ds_phys->ds_bp.blk_birth >= tx->tx_txg)
1428                 return (EAGAIN);
1429
1430         if (dsl_dataset_is_snapshot(ds)) {
1431                 /*
1432                  * If this snapshot has an elevated user reference count,
1433                  * we can't destroy it yet.
1434                  */
1435                 if (ds->ds_userrefs > 0 && !dsda->releasing)
1436                         return (EBUSY);
1437
1438                 mutex_enter(&ds->ds_lock);
1439                 /*
1440                  * Can't delete a branch point. However, if we're destroying
1441                  * a clone and removing its origin due to it having a user
1442                  * hold count of 0 and having been marked for deferred destroy,
1443                  * it's OK for the origin to have a single clone.
1444                  */
1445                 if (ds->ds_phys->ds_num_children >
1446                     (dsda->is_origin_rm ? 2 : 1)) {
1447                         mutex_exit(&ds->ds_lock);
1448                         return (EEXIST);
1449                 }
1450                 mutex_exit(&ds->ds_lock);
1451         } else if (dsl_dir_is_clone(ds->ds_dir)) {
1452                 return (dsl_dataset_origin_check(dsda, arg2, tx));
1453         }
1454
1455         /* XXX we should do some i/o error checking... */
1456         return (0);
1457 }
1458
1459 struct refsarg {
1460         kmutex_t lock;
1461         boolean_t gone;
1462         kcondvar_t cv;
1463 };
1464
1465 /* ARGSUSED */
1466 static void
1467 dsl_dataset_refs_gone(dmu_buf_t *db, void *argv)
1468 {
1469         struct refsarg *arg = argv;
1470
1471         mutex_enter(&arg->lock);
1472         arg->gone = TRUE;
1473         cv_signal(&arg->cv);
1474         mutex_exit(&arg->lock);
1475 }
1476
1477 static void
1478 dsl_dataset_drain_refs(dsl_dataset_t *ds, void *tag)
1479 {
1480         struct refsarg arg;
1481
1482         mutex_init(&arg.lock, NULL, MUTEX_DEFAULT, NULL);
1483         cv_init(&arg.cv, NULL, CV_DEFAULT, NULL);
1484         arg.gone = FALSE;
1485         (void) dmu_buf_update_user(ds->ds_dbuf, ds, &arg, &ds->ds_phys,
1486             dsl_dataset_refs_gone);
1487         dmu_buf_rele(ds->ds_dbuf, tag);
1488         mutex_enter(&arg.lock);
1489         while (!arg.gone)
1490                 cv_wait(&arg.cv, &arg.lock);
1491         ASSERT(arg.gone);
1492         mutex_exit(&arg.lock);
1493         ds->ds_dbuf = NULL;
1494         ds->ds_phys = NULL;
1495         mutex_destroy(&arg.lock);
1496         cv_destroy(&arg.cv);
1497 }
1498
1499 static void
1500 remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj, dmu_tx_t *tx)
1501 {
1502         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1503         int err;
1504         ASSERTV(uint64_t count);
1505
1506         ASSERT(ds->ds_phys->ds_num_children >= 2);
1507         err = zap_remove_int(mos, ds->ds_phys->ds_next_clones_obj, obj, tx);
1508         /*
1509          * The err should not be ENOENT, but a bug in a previous version
1510          * of the code could cause upgrade_clones_cb() to not set
1511          * ds_next_snap_obj when it should, leading to a missing entry.
1512          * If we knew that the pool was created after
1513          * SPA_VERSION_NEXT_CLONES, we could assert that it isn't
1514          * ENOENT.  However, at least we can check that we don't have
1515          * too many entries in the next_clones_obj even after failing to
1516          * remove this one.
1517          */
1518         if (err != ENOENT) {
1519                 VERIFY3U(err, ==, 0);
1520         }
1521         ASSERT3U(0, ==, zap_count(mos, ds->ds_phys->ds_next_clones_obj,
1522             &count));
1523         ASSERT3U(count, <=, ds->ds_phys->ds_num_children - 2);
1524 }
1525
1526 static void
1527 dsl_dataset_remove_clones_key(dsl_dataset_t *ds, uint64_t mintxg, dmu_tx_t *tx)
1528 {
1529         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1530         zap_cursor_t zc;
1531         zap_attribute_t za;
1532
1533         /*
1534          * If it is the old version, dd_clones doesn't exist so we can't
1535          * find the clones, but deadlist_remove_key() is a no-op so it
1536          * doesn't matter.
1537          */
1538         if (ds->ds_dir->dd_phys->dd_clones == 0)
1539                 return;
1540
1541         for (zap_cursor_init(&zc, mos, ds->ds_dir->dd_phys->dd_clones);
1542             zap_cursor_retrieve(&zc, &za) == 0;
1543             zap_cursor_advance(&zc)) {
1544                 dsl_dataset_t *clone;
1545
1546                 VERIFY3U(0, ==, dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
1547                     za.za_first_integer, FTAG, &clone));
1548                 if (clone->ds_dir->dd_origin_txg > mintxg) {
1549                         dsl_deadlist_remove_key(&clone->ds_deadlist,
1550                             mintxg, tx);
1551                         dsl_dataset_remove_clones_key(clone, mintxg, tx);
1552                 }
1553                 dsl_dataset_rele(clone, FTAG);
1554         }
1555         zap_cursor_fini(&zc);
1556 }
1557
1558 struct process_old_arg {
1559         dsl_dataset_t *ds;
1560         dsl_dataset_t *ds_prev;
1561         boolean_t after_branch_point;
1562         zio_t *pio;
1563         uint64_t used, comp, uncomp;
1564 };
1565
1566 static int
1567 process_old_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1568 {
1569         struct process_old_arg *poa = arg;
1570         dsl_pool_t *dp = poa->ds->ds_dir->dd_pool;
1571
1572         if (bp->blk_birth <= poa->ds->ds_phys->ds_prev_snap_txg) {
1573                 dsl_deadlist_insert(&poa->ds->ds_deadlist, bp, tx);
1574                 if (poa->ds_prev && !poa->after_branch_point &&
1575                     bp->blk_birth >
1576                     poa->ds_prev->ds_phys->ds_prev_snap_txg) {
1577                         poa->ds_prev->ds_phys->ds_unique_bytes +=
1578                             bp_get_dsize_sync(dp->dp_spa, bp);
1579                 }
1580         } else {
1581                 poa->used += bp_get_dsize_sync(dp->dp_spa, bp);
1582                 poa->comp += BP_GET_PSIZE(bp);
1583                 poa->uncomp += BP_GET_UCSIZE(bp);
1584                 dsl_free_sync(poa->pio, dp, tx->tx_txg, bp);
1585         }
1586         return (0);
1587 }
1588
1589 static void
1590 process_old_deadlist(dsl_dataset_t *ds, dsl_dataset_t *ds_prev,
1591     dsl_dataset_t *ds_next, boolean_t after_branch_point, dmu_tx_t *tx)
1592 {
1593         struct process_old_arg poa = { 0 };
1594         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1595         objset_t *mos = dp->dp_meta_objset;
1596
1597         ASSERT(ds->ds_deadlist.dl_oldfmt);
1598         ASSERT(ds_next->ds_deadlist.dl_oldfmt);
1599
1600         poa.ds = ds;
1601         poa.ds_prev = ds_prev;
1602         poa.after_branch_point = after_branch_point;
1603         poa.pio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
1604         VERIFY3U(0, ==, bpobj_iterate(&ds_next->ds_deadlist.dl_bpobj,
1605             process_old_cb, &poa, tx));
1606         VERIFY3U(zio_wait(poa.pio), ==, 0);
1607         ASSERT3U(poa.used, ==, ds->ds_phys->ds_unique_bytes);
1608
1609         /* change snapused */
1610         dsl_dir_diduse_space(ds->ds_dir, DD_USED_SNAP,
1611             -poa.used, -poa.comp, -poa.uncomp, tx);
1612
1613         /* swap next's deadlist to our deadlist */
1614         dsl_deadlist_close(&ds->ds_deadlist);
1615         dsl_deadlist_close(&ds_next->ds_deadlist);
1616         SWITCH64(ds_next->ds_phys->ds_deadlist_obj,
1617             ds->ds_phys->ds_deadlist_obj);
1618         dsl_deadlist_open(&ds->ds_deadlist, mos, ds->ds_phys->ds_deadlist_obj);
1619         dsl_deadlist_open(&ds_next->ds_deadlist, mos,
1620             ds_next->ds_phys->ds_deadlist_obj);
1621 }
1622
1623 void
1624 dsl_dataset_destroy_sync(void *arg1, void *tag, dmu_tx_t *tx)
1625 {
1626         struct dsl_ds_destroyarg *dsda = arg1;
1627         dsl_dataset_t *ds = dsda->ds;
1628         int err;
1629         int after_branch_point = FALSE;
1630         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1631         objset_t *mos = dp->dp_meta_objset;
1632         dsl_dataset_t *ds_prev = NULL;
1633         boolean_t wont_destroy;
1634         uint64_t obj;
1635
1636         wont_destroy = (dsda->defer &&
1637             (ds->ds_userrefs > 0 || ds->ds_phys->ds_num_children > 1));
1638
1639         ASSERT(ds->ds_owner || wont_destroy);
1640         ASSERT(dsda->defer || ds->ds_phys->ds_num_children <= 1);
1641         ASSERT(ds->ds_prev == NULL ||
1642             ds->ds_prev->ds_phys->ds_next_snap_obj != ds->ds_object);
1643         ASSERT3U(ds->ds_phys->ds_bp.blk_birth, <=, tx->tx_txg);
1644
1645         if (wont_destroy) {
1646                 ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
1647                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1648                 ds->ds_phys->ds_flags |= DS_FLAG_DEFER_DESTROY;
1649                 return;
1650         }
1651
1652         /* signal any waiters that this dataset is going away */
1653         mutex_enter(&ds->ds_lock);
1654         ds->ds_owner = dsl_reaper;
1655         cv_broadcast(&ds->ds_exclusive_cv);
1656         mutex_exit(&ds->ds_lock);
1657
1658         /* Remove our reservation */
1659         if (ds->ds_reserved != 0) {
1660                 dsl_prop_setarg_t psa;
1661                 uint64_t value = 0;
1662
1663                 dsl_prop_setarg_init_uint64(&psa, "refreservation",
1664                     (ZPROP_SRC_NONE | ZPROP_SRC_LOCAL | ZPROP_SRC_RECEIVED),
1665                     &value);
1666                 psa.psa_effective_value = 0;    /* predict default value */
1667
1668                 dsl_dataset_set_reservation_sync(ds, &psa, tx);
1669                 ASSERT3U(ds->ds_reserved, ==, 0);
1670         }
1671
1672         ASSERT(RW_WRITE_HELD(&dp->dp_config_rwlock));
1673
1674         dsl_scan_ds_destroyed(ds, tx);
1675
1676         obj = ds->ds_object;
1677
1678         if (ds->ds_phys->ds_prev_snap_obj != 0) {
1679                 if (ds->ds_prev) {
1680                         ds_prev = ds->ds_prev;
1681                 } else {
1682                         VERIFY(0 == dsl_dataset_hold_obj(dp,
1683                             ds->ds_phys->ds_prev_snap_obj, FTAG, &ds_prev));
1684                 }
1685                 after_branch_point =
1686                     (ds_prev->ds_phys->ds_next_snap_obj != obj);
1687
1688                 dmu_buf_will_dirty(ds_prev->ds_dbuf, tx);
1689                 if (after_branch_point &&
1690                     ds_prev->ds_phys->ds_next_clones_obj != 0) {
1691                         remove_from_next_clones(ds_prev, obj, tx);
1692                         if (ds->ds_phys->ds_next_snap_obj != 0) {
1693                                 VERIFY(0 == zap_add_int(mos,
1694                                     ds_prev->ds_phys->ds_next_clones_obj,
1695                                     ds->ds_phys->ds_next_snap_obj, tx));
1696                         }
1697                 }
1698                 if (after_branch_point &&
1699                     ds->ds_phys->ds_next_snap_obj == 0) {
1700                         /* This clone is toast. */
1701                         ASSERT(ds_prev->ds_phys->ds_num_children > 1);
1702                         ds_prev->ds_phys->ds_num_children--;
1703
1704                         /*
1705                          * If the clone's origin has no other clones, no
1706                          * user holds, and has been marked for deferred
1707                          * deletion, then we should have done the necessary
1708                          * destroy setup for it.
1709                          */
1710                         if (ds_prev->ds_phys->ds_num_children == 1 &&
1711                             ds_prev->ds_userrefs == 0 &&
1712                             DS_IS_DEFER_DESTROY(ds_prev)) {
1713                                 ASSERT3P(dsda->rm_origin, !=, NULL);
1714                         } else {
1715                                 ASSERT3P(dsda->rm_origin, ==, NULL);
1716                         }
1717                 } else if (!after_branch_point) {
1718                         ds_prev->ds_phys->ds_next_snap_obj =
1719                             ds->ds_phys->ds_next_snap_obj;
1720                 }
1721         }
1722
1723         if (dsl_dataset_is_snapshot(ds)) {
1724                 dsl_dataset_t *ds_next;
1725                 uint64_t old_unique;
1726                 uint64_t used = 0, comp = 0, uncomp = 0;
1727
1728                 VERIFY(0 == dsl_dataset_hold_obj(dp,
1729                     ds->ds_phys->ds_next_snap_obj, FTAG, &ds_next));
1730                 ASSERT3U(ds_next->ds_phys->ds_prev_snap_obj, ==, obj);
1731
1732                 old_unique = ds_next->ds_phys->ds_unique_bytes;
1733
1734                 dmu_buf_will_dirty(ds_next->ds_dbuf, tx);
1735                 ds_next->ds_phys->ds_prev_snap_obj =
1736                     ds->ds_phys->ds_prev_snap_obj;
1737                 ds_next->ds_phys->ds_prev_snap_txg =
1738                     ds->ds_phys->ds_prev_snap_txg;
1739                 ASSERT3U(ds->ds_phys->ds_prev_snap_txg, ==,
1740                     ds_prev ? ds_prev->ds_phys->ds_creation_txg : 0);
1741
1742
1743                 if (ds_next->ds_deadlist.dl_oldfmt) {
1744                         process_old_deadlist(ds, ds_prev, ds_next,
1745                             after_branch_point, tx);
1746                 } else {
1747                         /* Adjust prev's unique space. */
1748                         if (ds_prev && !after_branch_point) {
1749                                 dsl_deadlist_space_range(&ds_next->ds_deadlist,
1750                                     ds_prev->ds_phys->ds_prev_snap_txg,
1751                                     ds->ds_phys->ds_prev_snap_txg,
1752                                     &used, &comp, &uncomp);
1753                                 ds_prev->ds_phys->ds_unique_bytes += used;
1754                         }
1755
1756                         /* Adjust snapused. */
1757                         dsl_deadlist_space_range(&ds_next->ds_deadlist,
1758                             ds->ds_phys->ds_prev_snap_txg, UINT64_MAX,
1759                             &used, &comp, &uncomp);
1760                         dsl_dir_diduse_space(ds->ds_dir, DD_USED_SNAP,
1761                             -used, -comp, -uncomp, tx);
1762
1763                         /* Move blocks to be freed to pool's free list. */
1764                         dsl_deadlist_move_bpobj(&ds_next->ds_deadlist,
1765                             &dp->dp_free_bpobj, ds->ds_phys->ds_prev_snap_txg,
1766                             tx);
1767                         dsl_dir_diduse_space(tx->tx_pool->dp_free_dir,
1768                             DD_USED_HEAD, used, comp, uncomp, tx);
1769                         dsl_dir_dirty(tx->tx_pool->dp_free_dir, tx);
1770
1771                         /* Merge our deadlist into next's and free it. */
1772                         dsl_deadlist_merge(&ds_next->ds_deadlist,
1773                             ds->ds_phys->ds_deadlist_obj, tx);
1774                 }
1775                 dsl_deadlist_close(&ds->ds_deadlist);
1776                 dsl_deadlist_free(mos, ds->ds_phys->ds_deadlist_obj, tx);
1777
1778                 /* Collapse range in clone heads */
1779                 dsl_dataset_remove_clones_key(ds,
1780                     ds->ds_phys->ds_creation_txg, tx);
1781
1782                 if (dsl_dataset_is_snapshot(ds_next)) {
1783                         dsl_dataset_t *ds_nextnext;
1784                         dsl_dataset_t *hds;
1785
1786                         /*
1787                          * Update next's unique to include blocks which
1788                          * were previously shared by only this snapshot
1789                          * and it.  Those blocks will be born after the
1790                          * prev snap and before this snap, and will have
1791                          * died after the next snap and before the one
1792                          * after that (ie. be on the snap after next's
1793                          * deadlist).
1794                          */
1795                         VERIFY(0 == dsl_dataset_hold_obj(dp,
1796                             ds_next->ds_phys->ds_next_snap_obj,
1797                             FTAG, &ds_nextnext));
1798                         dsl_deadlist_space_range(&ds_nextnext->ds_deadlist,
1799                             ds->ds_phys->ds_prev_snap_txg,
1800                             ds->ds_phys->ds_creation_txg,
1801                             &used, &comp, &uncomp);
1802                         ds_next->ds_phys->ds_unique_bytes += used;
1803                         dsl_dataset_rele(ds_nextnext, FTAG);
1804                         ASSERT3P(ds_next->ds_prev, ==, NULL);
1805
1806                         /* Collapse range in this head. */
1807                         VERIFY3U(0, ==, dsl_dataset_hold_obj(dp,
1808                             ds->ds_dir->dd_phys->dd_head_dataset_obj,
1809                             FTAG, &hds));
1810                         dsl_deadlist_remove_key(&hds->ds_deadlist,
1811                             ds->ds_phys->ds_creation_txg, tx);
1812                         dsl_dataset_rele(hds, FTAG);
1813
1814                 } else {
1815                         ASSERT3P(ds_next->ds_prev, ==, ds);
1816                         dsl_dataset_drop_ref(ds_next->ds_prev, ds_next);
1817                         ds_next->ds_prev = NULL;
1818                         if (ds_prev) {
1819                                 VERIFY(0 == dsl_dataset_get_ref(dp,
1820                                     ds->ds_phys->ds_prev_snap_obj,
1821                                     ds_next, &ds_next->ds_prev));
1822                         }
1823
1824                         dsl_dataset_recalc_head_uniq(ds_next);
1825
1826                         /*
1827                          * Reduce the amount of our unconsmed refreservation
1828                          * being charged to our parent by the amount of
1829                          * new unique data we have gained.
1830                          */
1831                         if (old_unique < ds_next->ds_reserved) {
1832                                 int64_t mrsdelta;
1833                                 uint64_t new_unique =
1834                                     ds_next->ds_phys->ds_unique_bytes;
1835
1836                                 ASSERT(old_unique <= new_unique);
1837                                 mrsdelta = MIN(new_unique - old_unique,
1838                                     ds_next->ds_reserved - old_unique);
1839                                 dsl_dir_diduse_space(ds->ds_dir,
1840                                     DD_USED_REFRSRV, -mrsdelta, 0, 0, tx);
1841                         }
1842                 }
1843                 dsl_dataset_rele(ds_next, FTAG);
1844         } else {
1845                 /*
1846                  * There's no next snapshot, so this is a head dataset.
1847                  * Destroy the deadlist.  Unless it's a clone, the
1848                  * deadlist should be empty.  (If it's a clone, it's
1849                  * safe to ignore the deadlist contents.)
1850                  */
1851                 struct killarg ka;
1852
1853                 dsl_deadlist_close(&ds->ds_deadlist);
1854                 dsl_deadlist_free(mos, ds->ds_phys->ds_deadlist_obj, tx);
1855                 ds->ds_phys->ds_deadlist_obj = 0;
1856
1857                 /*
1858                  * Free everything that we point to (that's born after
1859                  * the previous snapshot, if we are a clone)
1860                  *
1861                  * NB: this should be very quick, because we already
1862                  * freed all the objects in open context.
1863                  */
1864                 ka.ds = ds;
1865                 ka.tx = tx;
1866                 err = traverse_dataset(ds, ds->ds_phys->ds_prev_snap_txg,
1867                     TRAVERSE_POST, kill_blkptr, &ka);
1868                 ASSERT3U(err, ==, 0);
1869                 ASSERT(!DS_UNIQUE_IS_ACCURATE(ds) ||
1870                     ds->ds_phys->ds_unique_bytes == 0);
1871
1872                 if (ds->ds_prev != NULL) {
1873                         if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
1874                                 VERIFY3U(0, ==, zap_remove_int(mos,
1875                                     ds->ds_prev->ds_dir->dd_phys->dd_clones,
1876                                     ds->ds_object, tx));
1877                         }
1878                         dsl_dataset_rele(ds->ds_prev, ds);
1879                         ds->ds_prev = ds_prev = NULL;
1880                 }
1881         }
1882
1883         /*
1884          * This must be done after the dsl_traverse(), because it will
1885          * re-open the objset.
1886          */
1887         if (ds->ds_objset) {
1888                 dmu_objset_evict(ds->ds_objset);
1889                 ds->ds_objset = NULL;
1890         }
1891
1892         if (ds->ds_dir->dd_phys->dd_head_dataset_obj == ds->ds_object) {
1893                 /* Erase the link in the dir */
1894                 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx);
1895                 ds->ds_dir->dd_phys->dd_head_dataset_obj = 0;
1896                 ASSERT(ds->ds_phys->ds_snapnames_zapobj != 0);
1897                 err = zap_destroy(mos, ds->ds_phys->ds_snapnames_zapobj, tx);
1898                 ASSERT(err == 0);
1899         } else {
1900                 /* remove from snapshot namespace */
1901                 dsl_dataset_t *ds_head;
1902                 ASSERT(ds->ds_phys->ds_snapnames_zapobj == 0);
1903                 VERIFY(0 == dsl_dataset_hold_obj(dp,
1904                     ds->ds_dir->dd_phys->dd_head_dataset_obj, FTAG, &ds_head));
1905                 VERIFY(0 == dsl_dataset_get_snapname(ds));
1906 #ifdef ZFS_DEBUG
1907                 {
1908                         uint64_t val;
1909
1910                         err = dsl_dataset_snap_lookup(ds_head,
1911                             ds->ds_snapname, &val);
1912                         ASSERT3U(err, ==, 0);
1913                         ASSERT3U(val, ==, obj);
1914                 }
1915 #endif
1916                 err = dsl_dataset_snap_remove(ds_head, ds->ds_snapname, tx);
1917                 ASSERT(err == 0);
1918                 dsl_dataset_rele(ds_head, FTAG);
1919         }
1920
1921         if (ds_prev && ds->ds_prev != ds_prev)
1922                 dsl_dataset_rele(ds_prev, FTAG);
1923
1924         spa_prop_clear_bootfs(dp->dp_spa, ds->ds_object, tx);
1925         spa_history_log_internal(LOG_DS_DESTROY, dp->dp_spa, tx,
1926             "dataset = %llu", ds->ds_object);
1927
1928         if (ds->ds_phys->ds_next_clones_obj != 0) {
1929                 ASSERTV(uint64_t count);
1930                 ASSERT(0 == zap_count(mos,
1931                     ds->ds_phys->ds_next_clones_obj, &count) && count == 0);
1932                 VERIFY(0 == dmu_object_free(mos,
1933                     ds->ds_phys->ds_next_clones_obj, tx));
1934         }
1935         if (ds->ds_phys->ds_props_obj != 0)
1936                 VERIFY(0 == zap_destroy(mos, ds->ds_phys->ds_props_obj, tx));
1937         if (ds->ds_phys->ds_userrefs_obj != 0)
1938                 VERIFY(0 == zap_destroy(mos, ds->ds_phys->ds_userrefs_obj, tx));
1939         dsl_dir_close(ds->ds_dir, ds);
1940         ds->ds_dir = NULL;
1941         dsl_dataset_drain_refs(ds, tag);
1942         VERIFY(0 == dmu_object_free(mos, obj, tx));
1943
1944         if (dsda->rm_origin) {
1945                 /*
1946                  * Remove the origin of the clone we just destroyed.
1947                  */
1948                 struct dsl_ds_destroyarg ndsda = {0};
1949
1950                 ndsda.ds = dsda->rm_origin;
1951                 dsl_dataset_destroy_sync(&ndsda, tag, tx);
1952         }
1953 }
1954
1955 static int
1956 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1957 {
1958         uint64_t asize;
1959
1960         if (!dmu_tx_is_syncing(tx))
1961                 return (0);
1962
1963         /*
1964          * If there's an fs-only reservation, any blocks that might become
1965          * owned by the snapshot dataset must be accommodated by space
1966          * outside of the reservation.
1967          */
1968         ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1969         asize = MIN(ds->ds_phys->ds_unique_bytes, ds->ds_reserved);
1970         if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1971                 return (ENOSPC);
1972
1973         /*
1974          * Propogate any reserved space for this snapshot to other
1975          * snapshot checks in this sync group.
1976          */
1977         if (asize > 0)
1978                 dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1979
1980         return (0);
1981 }
1982
1983 int
1984 dsl_dataset_snapshot_check(void *arg1, void *arg2, dmu_tx_t *tx)
1985 {
1986         dsl_dataset_t *ds = arg1;
1987         const char *snapname = arg2;
1988         int err;
1989         uint64_t value;
1990
1991         /*
1992          * We don't allow multiple snapshots of the same txg.  If there
1993          * is already one, try again.
1994          */
1995         if (ds->ds_phys->ds_prev_snap_txg >= tx->tx_txg)
1996                 return (EAGAIN);
1997
1998         /*
1999          * Check for conflicting name snapshot name.
2000          */
2001         err = dsl_dataset_snap_lookup(ds, snapname, &value);
2002         if (err == 0)
2003                 return (EEXIST);
2004         if (err != ENOENT)
2005                 return (err);
2006
2007         /*
2008          * Check that the dataset's name is not too long.  Name consists
2009          * of the dataset's length + 1 for the @-sign + snapshot name's length
2010          */
2011         if (dsl_dataset_namelen(ds) + 1 + strlen(snapname) >= MAXNAMELEN)
2012                 return (ENAMETOOLONG);
2013
2014         err = dsl_dataset_snapshot_reserve_space(ds, tx);
2015         if (err)
2016                 return (err);
2017
2018         ds->ds_trysnap_txg = tx->tx_txg;
2019         return (0);
2020 }
2021
2022 void
2023 dsl_dataset_snapshot_sync(void *arg1, void *arg2, dmu_tx_t *tx)
2024 {
2025         dsl_dataset_t *ds = arg1;
2026         const char *snapname = arg2;
2027         dsl_pool_t *dp = ds->ds_dir->dd_pool;
2028         dmu_buf_t *dbuf;
2029         dsl_dataset_phys_t *dsphys;
2030         uint64_t dsobj, crtxg;
2031         objset_t *mos = dp->dp_meta_objset;
2032         int err;
2033
2034         ASSERT(RW_WRITE_HELD(&dp->dp_config_rwlock));
2035
2036         /*
2037          * The origin's ds_creation_txg has to be < TXG_INITIAL
2038          */
2039         if (strcmp(snapname, ORIGIN_DIR_NAME) == 0)
2040                 crtxg = 1;
2041         else
2042                 crtxg = tx->tx_txg;
2043
2044         dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
2045             DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
2046         VERIFY(0 == dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
2047         dmu_buf_will_dirty(dbuf, tx);
2048         dsphys = dbuf->db_data;
2049         bzero(dsphys, sizeof (dsl_dataset_phys_t));
2050         dsphys->ds_dir_obj = ds->ds_dir->dd_object;
2051         dsphys->ds_fsid_guid = unique_create();
2052         (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
2053             sizeof (dsphys->ds_guid));
2054         dsphys->ds_prev_snap_obj = ds->ds_phys->ds_prev_snap_obj;
2055         dsphys->ds_prev_snap_txg = ds->ds_phys->ds_prev_snap_txg;
2056         dsphys->ds_next_snap_obj = ds->ds_object;
2057         dsphys->ds_num_children = 1;
2058         dsphys->ds_creation_time = gethrestime_sec();
2059         dsphys->ds_creation_txg = crtxg;
2060         dsphys->ds_deadlist_obj = ds->ds_phys->ds_deadlist_obj;
2061         dsphys->ds_used_bytes = ds->ds_phys->ds_used_bytes;
2062         dsphys->ds_compressed_bytes = ds->ds_phys->ds_compressed_bytes;
2063         dsphys->ds_uncompressed_bytes = ds->ds_phys->ds_uncompressed_bytes;
2064         dsphys->ds_flags = ds->ds_phys->ds_flags;
2065         dsphys->ds_bp = ds->ds_phys->ds_bp;
2066         dmu_buf_rele(dbuf, FTAG);
2067
2068         ASSERT3U(ds->ds_prev != 0, ==, ds->ds_phys->ds_prev_snap_obj != 0);
2069         if (ds->ds_prev) {
2070                 uint64_t next_clones_obj =
2071                     ds->ds_prev->ds_phys->ds_next_clones_obj;
2072                 ASSERT(ds->ds_prev->ds_phys->ds_next_snap_obj ==
2073                     ds->ds_object ||
2074                     ds->ds_prev->ds_phys->ds_num_children > 1);
2075                 if (ds->ds_prev->ds_phys->ds_next_snap_obj == ds->ds_object) {
2076                         dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
2077                         ASSERT3U(ds->ds_phys->ds_prev_snap_txg, ==,
2078                             ds->ds_prev->ds_phys->ds_creation_txg);
2079                         ds->ds_prev->ds_phys->ds_next_snap_obj = dsobj;
2080                 } else if (next_clones_obj != 0) {
2081                         remove_from_next_clones(ds->ds_prev,
2082                             dsphys->ds_next_snap_obj, tx);
2083                         VERIFY3U(0, ==, zap_add_int(mos,
2084                             next_clones_obj, dsobj, tx));
2085                 }
2086         }
2087
2088         /*
2089          * If we have a reference-reservation on this dataset, we will
2090          * need to increase the amount of refreservation being charged
2091          * since our unique space is going to zero.
2092          */
2093         if (ds->ds_reserved) {
2094                 int64_t delta;
2095                 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
2096                 delta = MIN(ds->ds_phys->ds_unique_bytes, ds->ds_reserved);
2097                 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
2098                     delta, 0, 0, tx);
2099         }
2100
2101         dmu_buf_will_dirty(ds->ds_dbuf, tx);
2102         zfs_dbgmsg("taking snapshot %s@%s/%llu; newkey=%llu",
2103             ds->ds_dir->dd_myname, snapname, dsobj,
2104             ds->ds_phys->ds_prev_snap_txg);
2105         ds->ds_phys->ds_deadlist_obj = dsl_deadlist_clone(&ds->ds_deadlist,
2106             UINT64_MAX, ds->ds_phys->ds_prev_snap_obj, tx);
2107         dsl_deadlist_close(&ds->ds_deadlist);
2108         dsl_deadlist_open(&ds->ds_deadlist, mos, ds->ds_phys->ds_deadlist_obj);
2109         dsl_deadlist_add_key(&ds->ds_deadlist,
2110             ds->ds_phys->ds_prev_snap_txg, tx);
2111
2112         ASSERT3U(ds->ds_phys->ds_prev_snap_txg, <, tx->tx_txg);
2113         ds->ds_phys->ds_prev_snap_obj = dsobj;
2114         ds->ds_phys->ds_prev_snap_txg = crtxg;
2115         ds->ds_phys->ds_unique_bytes = 0;
2116         if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
2117                 ds->ds_phys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
2118
2119         err = zap_add(mos, ds->ds_phys->ds_snapnames_zapobj,
2120             snapname, 8, 1, &dsobj, tx);
2121         ASSERT(err == 0);
2122
2123         if (ds->ds_prev)
2124                 dsl_dataset_drop_ref(ds->ds_prev, ds);
2125         VERIFY(0 == dsl_dataset_get_ref(dp,
2126             ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev));
2127
2128         dsl_scan_ds_snapshotted(ds, tx);
2129
2130         dsl_dir_snap_cmtime_update(ds->ds_dir);
2131
2132         spa_history_log_internal(LOG_DS_SNAPSHOT, dp->dp_spa, tx,
2133             "dataset = %llu", dsobj);
2134 }
2135
2136 void
2137 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx)
2138 {
2139         ASSERT(dmu_tx_is_syncing(tx));
2140         ASSERT(ds->ds_objset != NULL);
2141         ASSERT(ds->ds_phys->ds_next_snap_obj == 0);
2142
2143         /*
2144          * in case we had to change ds_fsid_guid when we opened it,
2145          * sync it out now.
2146          */
2147         dmu_buf_will_dirty(ds->ds_dbuf, tx);
2148         ds->ds_phys->ds_fsid_guid = ds->ds_fsid_guid;
2149
2150         dsl_dir_dirty(ds->ds_dir, tx);
2151         dmu_objset_sync(ds->ds_objset, zio, tx);
2152 }
2153
2154 void
2155 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
2156 {
2157         uint64_t refd, avail, uobjs, aobjs, ratio;
2158
2159         dsl_dir_stats(ds->ds_dir, nv);
2160
2161         dsl_dataset_space(ds, &refd, &avail, &uobjs, &aobjs);
2162         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE, avail);
2163         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFERENCED, refd);
2164
2165         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATION,
2166             ds->ds_phys->ds_creation_time);
2167         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATETXG,
2168             ds->ds_phys->ds_creation_txg);
2169         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFQUOTA,
2170             ds->ds_quota);
2171         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRESERVATION,
2172             ds->ds_reserved);
2173         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_GUID,
2174             ds->ds_phys->ds_guid);
2175         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_UNIQUE,
2176             ds->ds_phys->ds_unique_bytes);
2177         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_OBJSETID,
2178             ds->ds_object);
2179         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USERREFS,
2180             ds->ds_userrefs);
2181         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_DEFER_DESTROY,
2182             DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
2183
2184         ratio = ds->ds_phys->ds_compressed_bytes == 0 ? 100 :
2185             (ds->ds_phys->ds_uncompressed_bytes * 100 /
2186             ds->ds_phys->ds_compressed_bytes);
2187         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRATIO, ratio);
2188
2189         if (ds->ds_phys->ds_next_snap_obj) {
2190                 /*
2191                  * This is a snapshot; override the dd's space used with
2192                  * our unique space and compression ratio.
2193                  */
2194                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
2195                     ds->ds_phys->ds_unique_bytes);
2196                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO, ratio);
2197         }
2198 }
2199
2200 void
2201 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
2202 {
2203         stat->dds_creation_txg = ds->ds_phys->ds_creation_txg;
2204         stat->dds_inconsistent = ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT;
2205         stat->dds_guid = ds->ds_phys->ds_guid;
2206         if (ds->ds_phys->ds_next_snap_obj) {
2207                 stat->dds_is_snapshot = B_TRUE;
2208                 stat->dds_num_clones = ds->ds_phys->ds_num_children - 1;
2209         } else {
2210                 stat->dds_is_snapshot = B_FALSE;
2211                 stat->dds_num_clones = 0;
2212         }
2213
2214         /* clone origin is really a dsl_dir thing... */
2215         rw_enter(&ds->ds_dir->dd_pool->dp_config_rwlock, RW_READER);
2216         if (dsl_dir_is_clone(ds->ds_dir)) {
2217                 dsl_dataset_t *ods;
2218
2219                 VERIFY(0 == dsl_dataset_get_ref(ds->ds_dir->dd_pool,
2220                     ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &ods));
2221                 dsl_dataset_name(ods, stat->dds_origin);
2222                 dsl_dataset_drop_ref(ods, FTAG);
2223         } else {
2224                 stat->dds_origin[0] = '\0';
2225         }
2226         rw_exit(&ds->ds_dir->dd_pool->dp_config_rwlock);
2227 }
2228
2229 uint64_t
2230 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
2231 {
2232         return (ds->ds_fsid_guid);
2233 }
2234
2235 void
2236 dsl_dataset_space(dsl_dataset_t *ds,
2237     uint64_t *refdbytesp, uint64_t *availbytesp,
2238     uint64_t *usedobjsp, uint64_t *availobjsp)
2239 {
2240         *refdbytesp = ds->ds_phys->ds_used_bytes;
2241         *availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
2242         if (ds->ds_reserved > ds->ds_phys->ds_unique_bytes)
2243                 *availbytesp += ds->ds_reserved - ds->ds_phys->ds_unique_bytes;
2244         if (ds->ds_quota != 0) {
2245                 /*
2246                  * Adjust available bytes according to refquota
2247                  */
2248                 if (*refdbytesp < ds->ds_quota)
2249                         *availbytesp = MIN(*availbytesp,
2250                             ds->ds_quota - *refdbytesp);
2251                 else
2252                         *availbytesp = 0;
2253         }
2254         *usedobjsp = ds->ds_phys->ds_bp.blk_fill;
2255         *availobjsp = DN_MAX_OBJECT - *usedobjsp;
2256 }
2257
2258 boolean_t
2259 dsl_dataset_modified_since_lastsnap(dsl_dataset_t *ds)
2260 {
2261         ASSERTV(dsl_pool_t *dp = ds->ds_dir->dd_pool);
2262
2263         ASSERT(RW_LOCK_HELD(&dp->dp_config_rwlock) ||
2264             dsl_pool_sync_context(dp));
2265         if (ds->ds_prev == NULL)
2266                 return (B_FALSE);
2267         if (ds->ds_phys->ds_bp.blk_birth >
2268             ds->ds_prev->ds_phys->ds_creation_txg) {
2269                 objset_t *os, *os_prev;
2270                 /*
2271                  * It may be that only the ZIL differs, because it was
2272                  * reset in the head.  Don't count that as being
2273                  * modified.
2274                  */
2275                 if (dmu_objset_from_ds(ds, &os) != 0)
2276                         return (B_TRUE);
2277                 if (dmu_objset_from_ds(ds->ds_prev, &os_prev) != 0)
2278                         return (B_TRUE);
2279                 return (bcmp(&os->os_phys->os_meta_dnode,
2280                     &os_prev->os_phys->os_meta_dnode,
2281                     sizeof (os->os_phys->os_meta_dnode)) != 0);
2282         }
2283         return (B_FALSE);
2284 }
2285
2286 /* ARGSUSED */
2287 static int
2288 dsl_dataset_snapshot_rename_check(void *arg1, void *arg2, dmu_tx_t *tx)
2289 {
2290         dsl_dataset_t *ds = arg1;
2291         char *newsnapname = arg2;
2292         dsl_dir_t *dd = ds->ds_dir;
2293         dsl_dataset_t *hds;
2294         uint64_t val;
2295         int err;
2296
2297         err = dsl_dataset_hold_obj(dd->dd_pool,
2298             dd->dd_phys->dd_head_dataset_obj, FTAG, &hds);
2299         if (err)
2300                 return (err);
2301
2302         /* new name better not be in use */
2303         err = dsl_dataset_snap_lookup(hds, newsnapname, &val);
2304         dsl_dataset_rele(hds, FTAG);
2305
2306         if (err == 0)
2307                 err = EEXIST;
2308         else if (err == ENOENT)
2309                 err = 0;
2310
2311         /* dataset name + 1 for the "@" + the new snapshot name must fit */
2312         if (dsl_dir_namelen(ds->ds_dir) + 1 + strlen(newsnapname) >= MAXNAMELEN)
2313                 err = ENAMETOOLONG;
2314
2315         return (err);
2316 }
2317
2318 static void
2319 dsl_dataset_snapshot_rename_sync(void *arg1, void *arg2, dmu_tx_t *tx)
2320 {
2321         dsl_dataset_t *ds = arg1;
2322         const char *newsnapname = arg2;
2323         dsl_dir_t *dd = ds->ds_dir;
2324         objset_t *mos = dd->dd_pool->dp_meta_objset;
2325         dsl_dataset_t *hds;
2326         int err;
2327
2328         ASSERT(ds->ds_phys->ds_next_snap_obj != 0);
2329
2330         VERIFY(0 == dsl_dataset_hold_obj(dd->dd_pool,
2331             dd->dd_phys->dd_head_dataset_obj, FTAG, &hds));
2332
2333         VERIFY(0 == dsl_dataset_get_snapname(ds));
2334         err = dsl_dataset_snap_remove(hds, ds->ds_snapname, tx);
2335         ASSERT3U(err, ==, 0);
2336         mutex_enter(&ds->ds_lock);
2337         (void) strcpy(ds->ds_snapname, newsnapname);
2338         mutex_exit(&ds->ds_lock);
2339         err = zap_add(mos, hds->ds_phys->ds_snapnames_zapobj,
2340             ds->ds_snapname, 8, 1, &ds->ds_object, tx);
2341         ASSERT3U(err, ==, 0);
2342
2343         spa_history_log_internal(LOG_DS_RENAME, dd->dd_pool->dp_spa, tx,
2344             "dataset = %llu", ds->ds_object);
2345         dsl_dataset_rele(hds, FTAG);
2346 }
2347
2348 struct renamesnaparg {
2349         dsl_sync_task_group_t *dstg;
2350         char failed[MAXPATHLEN];
2351         char *oldsnap;
2352         char *newsnap;
2353 };
2354
2355 static int
2356 dsl_snapshot_rename_one(const char *name, void *arg)
2357 {
2358         struct renamesnaparg *ra = arg;
2359         dsl_dataset_t *ds = NULL;
2360         char *snapname;
2361         int err;
2362
2363         snapname = kmem_asprintf("%s@%s", name, ra->oldsnap);
2364         (void) strlcpy(ra->failed, snapname, sizeof (ra->failed));
2365
2366         /*
2367          * For recursive snapshot renames the parent won't be changing
2368          * so we just pass name for both the to/from argument.
2369          */
2370         err = zfs_secpolicy_rename_perms(snapname, snapname, CRED());
2371         if (err != 0) {
2372                 strfree(snapname);
2373                 return (err == ENOENT ? 0 : err);
2374         }
2375
2376 #ifdef _KERNEL
2377         /*
2378          * For all filesystems undergoing rename, we'll need to unmount it.
2379          */
2380         (void) zfs_unmount_snap(snapname, NULL);
2381 #endif
2382         err = dsl_dataset_hold(snapname, ra->dstg, &ds);
2383         strfree(snapname);
2384         if (err != 0)
2385                 return (err == ENOENT ? 0 : err);
2386
2387         dsl_sync_task_create(ra->dstg, dsl_dataset_snapshot_rename_check,
2388             dsl_dataset_snapshot_rename_sync, ds, ra->newsnap, 0);
2389
2390         return (0);
2391 }
2392
2393 static int
2394 dsl_recursive_rename(char *oldname, const char *newname)
2395 {
2396         int err;
2397         struct renamesnaparg *ra;
2398         dsl_sync_task_t *dst;
2399         spa_t *spa;
2400         char *cp, *fsname = spa_strdup(oldname);
2401         int len = strlen(oldname) + 1;
2402
2403         /* truncate the snapshot name to get the fsname */
2404         cp = strchr(fsname, '@');
2405         *cp = '\0';
2406
2407         err = spa_open(fsname, &spa, FTAG);
2408         if (err) {
2409                 kmem_free(fsname, len);
2410                 return (err);
2411         }
2412         ra = kmem_alloc(sizeof (struct renamesnaparg), KM_SLEEP);
2413         ra->dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
2414
2415         ra->oldsnap = strchr(oldname, '@') + 1;
2416         ra->newsnap = strchr(newname, '@') + 1;
2417         *ra->failed = '\0';
2418
2419         err = dmu_objset_find(fsname, dsl_snapshot_rename_one, ra,
2420             DS_FIND_CHILDREN);
2421         kmem_free(fsname, len);
2422
2423         if (err == 0) {
2424                 err = dsl_sync_task_group_wait(ra->dstg);
2425         }
2426
2427         for (dst = list_head(&ra->dstg->dstg_tasks); dst;
2428             dst = list_next(&ra->dstg->dstg_tasks, dst)) {
2429                 dsl_dataset_t *ds = dst->dst_arg1;
2430                 if (dst->dst_err) {
2431                         dsl_dir_name(ds->ds_dir, ra->failed);
2432                         (void) strlcat(ra->failed, "@", sizeof (ra->failed));
2433                         (void) strlcat(ra->failed, ra->newsnap,
2434                             sizeof (ra->failed));
2435                 }
2436                 dsl_dataset_rele(ds, ra->dstg);
2437         }
2438
2439         if (err)
2440                 (void) strlcpy(oldname, ra->failed, sizeof (ra->failed));
2441
2442         dsl_sync_task_group_destroy(ra->dstg);
2443         kmem_free(ra, sizeof (struct renamesnaparg));
2444         spa_close(spa, FTAG);
2445         return (err);
2446 }
2447
2448 static int
2449 dsl_valid_rename(const char *oldname, void *arg)
2450 {
2451         int delta = *(int *)arg;
2452
2453         if (strlen(oldname) + delta >= MAXNAMELEN)
2454                 return (ENAMETOOLONG);
2455
2456         return (0);
2457 }
2458
2459 #pragma weak dmu_objset_rename = dsl_dataset_rename
2460 int
2461 dsl_dataset_rename(char *oldname, const char *newname, boolean_t recursive)
2462 {
2463         dsl_dir_t *dd;
2464         dsl_dataset_t *ds;
2465         const char *tail;
2466         int err;
2467
2468         err = dsl_dir_open(oldname, FTAG, &dd, &tail);
2469         if (err)
2470                 return (err);
2471
2472         if (tail == NULL) {
2473                 int delta = strlen(newname) - strlen(oldname);
2474
2475                 /* if we're growing, validate child name lengths */
2476                 if (delta > 0)
2477                         err = dmu_objset_find(oldname, dsl_valid_rename,
2478                             &delta, DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
2479
2480                 if (err == 0)
2481                         err = dsl_dir_rename(dd, newname);
2482                 dsl_dir_close(dd, FTAG);
2483                 return (err);
2484         }
2485
2486         if (tail[0] != '@') {
2487                 /* the name ended in a nonexistent component */
2488                 dsl_dir_close(dd, FTAG);
2489                 return (ENOENT);
2490         }
2491
2492         dsl_dir_close(dd, FTAG);
2493
2494         /* new name must be snapshot in same filesystem */
2495         tail = strchr(newname, '@');
2496         if (tail == NULL)
2497                 return (EINVAL);
2498         tail++;
2499         if (strncmp(oldname, newname, tail - newname) != 0)
2500                 return (EXDEV);
2501
2502         if (recursive) {
2503                 err = dsl_recursive_rename(oldname, newname);
2504         } else {
2505                 err = dsl_dataset_hold(oldname, FTAG, &ds);
2506                 if (err)
2507                         return (err);
2508
2509                 err = dsl_sync_task_do(ds->ds_dir->dd_pool,
2510                     dsl_dataset_snapshot_rename_check,
2511                     dsl_dataset_snapshot_rename_sync, ds, (char *)tail, 1);
2512
2513                 dsl_dataset_rele(ds, FTAG);
2514         }
2515
2516         return (err);
2517 }
2518
2519 struct promotenode {
2520         list_node_t link;
2521         dsl_dataset_t *ds;
2522 };
2523
2524 struct promotearg {
2525         list_t shared_snaps, origin_snaps, clone_snaps;
2526         dsl_dataset_t *origin_origin;
2527         uint64_t used, comp, uncomp, unique, cloneusedsnap, originusedsnap;
2528         char *err_ds;
2529 };
2530
2531 static int snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep);
2532
2533 static int
2534 dsl_dataset_promote_check(void *arg1, void *arg2, dmu_tx_t *tx)
2535 {
2536         dsl_dataset_t *hds = arg1;
2537         struct promotearg *pa = arg2;
2538         struct promotenode *snap = list_head(&pa->shared_snaps);
2539         dsl_dataset_t *origin_ds = snap->ds;
2540         int err;
2541         uint64_t unused;
2542
2543         /* Check that it is a real clone */
2544         if (!dsl_dir_is_clone(hds->ds_dir))
2545                 return (EINVAL);
2546
2547         /* Since this is so expensive, don't do the preliminary check */
2548         if (!dmu_tx_is_syncing(tx))
2549                 return (0);
2550
2551         if (hds->ds_phys->ds_flags & DS_FLAG_NOPROMOTE)
2552                 return (EXDEV);
2553
2554         /* compute origin's new unique space */
2555         snap = list_tail(&pa->clone_snaps);
2556         ASSERT3U(snap->ds->ds_phys->ds_prev_snap_obj, ==, origin_ds->ds_object);
2557         dsl_deadlist_space_range(&snap->ds->ds_deadlist,
2558             origin_ds->ds_phys->ds_prev_snap_txg, UINT64_MAX,
2559             &pa->unique, &unused, &unused);
2560
2561         /*
2562          * Walk the snapshots that we are moving
2563          *
2564          * Compute space to transfer.  Consider the incremental changes
2565          * to used for each snapshot:
2566          * (my used) = (prev's used) + (blocks born) - (blocks killed)
2567          * So each snapshot gave birth to:
2568          * (blocks born) = (my used) - (prev's used) + (blocks killed)
2569          * So a sequence would look like:
2570          * (uN - u(N-1) + kN) + ... + (u1 - u0 + k1) + (u0 - 0 + k0)
2571          * Which simplifies to:
2572          * uN + kN + kN-1 + ... + k1 + k0
2573          * Note however, if we stop before we reach the ORIGIN we get:
2574          * uN + kN + kN-1 + ... + kM - uM-1
2575          */
2576         pa->used = origin_ds->ds_phys->ds_used_bytes;
2577         pa->comp = origin_ds->ds_phys->ds_compressed_bytes;
2578         pa->uncomp = origin_ds->ds_phys->ds_uncompressed_bytes;
2579         for (snap = list_head(&pa->shared_snaps); snap;
2580             snap = list_next(&pa->shared_snaps, snap)) {
2581                 uint64_t val, dlused, dlcomp, dluncomp;
2582                 dsl_dataset_t *ds = snap->ds;
2583
2584                 /* Check that the snapshot name does not conflict */
2585                 VERIFY(0 == dsl_dataset_get_snapname(ds));
2586                 err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
2587                 if (err == 0) {
2588                         err = EEXIST;
2589                         goto out;
2590                 }
2591                 if (err != ENOENT)
2592                         goto out;
2593
2594                 /* The very first snapshot does not have a deadlist */
2595                 if (ds->ds_phys->ds_prev_snap_obj == 0)
2596                         continue;
2597
2598                 dsl_deadlist_space(&ds->ds_deadlist,
2599                     &dlused, &dlcomp, &dluncomp);
2600                 pa->used += dlused;
2601                 pa->comp += dlcomp;
2602                 pa->uncomp += dluncomp;
2603         }
2604
2605         /*
2606          * If we are a clone of a clone then we never reached ORIGIN,
2607          * so we need to subtract out the clone origin's used space.
2608          */
2609         if (pa->origin_origin) {
2610                 pa->used -= pa->origin_origin->ds_phys->ds_used_bytes;
2611                 pa->comp -= pa->origin_origin->ds_phys->ds_compressed_bytes;
2612                 pa->uncomp -= pa->origin_origin->ds_phys->ds_uncompressed_bytes;
2613         }
2614
2615         /* Check that there is enough space here */
2616         err = dsl_dir_transfer_possible(origin_ds->ds_dir, hds->ds_dir,
2617             pa->used);
2618         if (err)
2619                 return (err);
2620
2621         /*
2622          * Compute the amounts of space that will be used by snapshots
2623          * after the promotion (for both origin and clone).  For each,
2624          * it is the amount of space that will be on all of their
2625          * deadlists (that was not born before their new origin).
2626          */
2627         if (hds->ds_dir->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) {
2628                 uint64_t space;
2629
2630                 /*
2631                  * Note, typically this will not be a clone of a clone,
2632                  * so dd_origin_txg will be < TXG_INITIAL, so
2633                  * these snaplist_space() -> dsl_deadlist_space_range()
2634                  * calls will be fast because they do not have to
2635                  * iterate over all bps.
2636                  */
2637                 snap = list_head(&pa->origin_snaps);
2638                 err = snaplist_space(&pa->shared_snaps,
2639                     snap->ds->ds_dir->dd_origin_txg, &pa->cloneusedsnap);
2640                 if (err)
2641                         return (err);
2642
2643                 err = snaplist_space(&pa->clone_snaps,
2644                     snap->ds->ds_dir->dd_origin_txg, &space);
2645                 if (err)
2646                         return (err);
2647                 pa->cloneusedsnap += space;
2648         }
2649         if (origin_ds->ds_dir->dd_phys->dd_flags & DD_FLAG_USED_BREAKDOWN) {
2650                 err = snaplist_space(&pa->origin_snaps,
2651                     origin_ds->ds_phys->ds_creation_txg, &pa->originusedsnap);
2652                 if (err)
2653                         return (err);
2654         }
2655
2656         return (0);
2657 out:
2658         pa->err_ds =  snap->ds->ds_snapname;
2659         return (err);
2660 }
2661
2662 static void
2663 dsl_dataset_promote_sync(void *arg1, void *arg2, dmu_tx_t *tx)
2664 {
2665         dsl_dataset_t *hds = arg1;
2666         struct promotearg *pa = arg2;
2667         struct promotenode *snap = list_head(&pa->shared_snaps);
2668         dsl_dataset_t *origin_ds = snap->ds;
2669         dsl_dataset_t *origin_head;
2670         dsl_dir_t *dd = hds->ds_dir;
2671         dsl_pool_t *dp = hds->ds_dir->dd_pool;
2672         dsl_dir_t *odd = NULL;
2673         uint64_t oldnext_obj;
2674         int64_t delta;
2675
2676         ASSERT(0 == (hds->ds_phys->ds_flags & DS_FLAG_NOPROMOTE));
2677
2678         snap = list_head(&pa->origin_snaps);
2679         origin_head = snap->ds;
2680
2681         /*
2682          * We need to explicitly open odd, since origin_ds's dd will be
2683          * changing.
2684          */
2685         VERIFY(0 == dsl_dir_open_obj(dp, origin_ds->ds_dir->dd_object,
2686             NULL, FTAG, &odd));
2687
2688         /* change origin's next snap */
2689         dmu_buf_will_dirty(origin_ds->ds_dbuf, tx);
2690         oldnext_obj = origin_ds->ds_phys->ds_next_snap_obj;
2691         snap = list_tail(&pa->clone_snaps);
2692         ASSERT3U(snap->ds->ds_phys->ds_prev_snap_obj, ==, origin_ds->ds_object);
2693         origin_ds->ds_phys->ds_next_snap_obj = snap->ds->ds_object;
2694
2695         /* change the origin's next clone */
2696         if (origin_ds->ds_phys->ds_next_clones_obj) {
2697                 remove_from_next_clones(origin_ds, snap->ds->ds_object, tx);
2698                 VERIFY3U(0, ==, zap_add_int(dp->dp_meta_objset,
2699                     origin_ds->ds_phys->ds_next_clones_obj,
2700                     oldnext_obj, tx));
2701         }
2702
2703         /* change origin */
2704         dmu_buf_will_dirty(dd->dd_dbuf, tx);
2705         ASSERT3U(dd->dd_phys->dd_origin_obj, ==, origin_ds->ds_object);
2706         dd->dd_phys->dd_origin_obj = odd->dd_phys->dd_origin_obj;
2707         dd->dd_origin_txg = origin_head->ds_dir->dd_origin_txg;
2708         dmu_buf_will_dirty(odd->dd_dbuf, tx);
2709         odd->dd_phys->dd_origin_obj = origin_ds->ds_object;
2710         origin_head->ds_dir->dd_origin_txg =
2711             origin_ds->ds_phys->ds_creation_txg;
2712
2713         /* change dd_clone entries */
2714         if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2715                 VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset,
2716                     odd->dd_phys->dd_clones, hds->ds_object, tx));
2717                 VERIFY3U(0, ==, zap_add_int(dp->dp_meta_objset,
2718                     pa->origin_origin->ds_dir->dd_phys->dd_clones,
2719                     hds->ds_object, tx));
2720
2721                 VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset,
2722                     pa->origin_origin->ds_dir->dd_phys->dd_clones,
2723                     origin_head->ds_object, tx));
2724                 if (dd->dd_phys->dd_clones == 0) {
2725                         dd->dd_phys->dd_clones = zap_create(dp->dp_meta_objset,
2726                             DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
2727                 }
2728                 VERIFY3U(0, ==, zap_add_int(dp->dp_meta_objset,
2729                     dd->dd_phys->dd_clones, origin_head->ds_object, tx));
2730
2731         }
2732
2733         /* move snapshots to this dir */
2734         for (snap = list_head(&pa->shared_snaps); snap;
2735             snap = list_next(&pa->shared_snaps, snap)) {
2736                 dsl_dataset_t *ds = snap->ds;
2737
2738                 /* unregister props as dsl_dir is changing */
2739                 if (ds->ds_objset) {
2740                         dmu_objset_evict(ds->ds_objset);
2741                         ds->ds_objset = NULL;
2742                 }
2743                 /* move snap name entry */
2744                 VERIFY(0 == dsl_dataset_get_snapname(ds));
2745                 VERIFY(0 == dsl_dataset_snap_remove(origin_head,
2746                     ds->ds_snapname, tx));
2747                 VERIFY(0 == zap_add(dp->dp_meta_objset,
2748                     hds->ds_phys->ds_snapnames_zapobj, ds->ds_snapname,
2749                     8, 1, &ds->ds_object, tx));
2750
2751                 /* change containing dsl_dir */
2752                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
2753                 ASSERT3U(ds->ds_phys->ds_dir_obj, ==, odd->dd_object);
2754                 ds->ds_phys->ds_dir_obj = dd->dd_object;
2755                 ASSERT3P(ds->ds_dir, ==, odd);
2756                 dsl_dir_close(ds->ds_dir, ds);
2757                 VERIFY(0 == dsl_dir_open_obj(dp, dd->dd_object,
2758                     NULL, ds, &ds->ds_dir));
2759
2760                 /* move any clone references */
2761                 if (ds->ds_phys->ds_next_clones_obj &&
2762                     spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2763                         zap_cursor_t zc;
2764                         zap_attribute_t za;
2765
2766                         for (zap_cursor_init(&zc, dp->dp_meta_objset,
2767                             ds->ds_phys->ds_next_clones_obj);
2768                             zap_cursor_retrieve(&zc, &za) == 0;
2769                             zap_cursor_advance(&zc)) {
2770                                 dsl_dataset_t *cnds;
2771                                 uint64_t o;
2772
2773                                 if (za.za_first_integer == oldnext_obj) {
2774                                         /*
2775                                          * We've already moved the
2776                                          * origin's reference.
2777                                          */
2778                                         continue;
2779                                 }
2780
2781                                 VERIFY3U(0, ==, dsl_dataset_hold_obj(dp,
2782                                     za.za_first_integer, FTAG, &cnds));
2783                                 o = cnds->ds_dir->dd_phys->dd_head_dataset_obj;
2784
2785                                 VERIFY3U(zap_remove_int(dp->dp_meta_objset,
2786                                     odd->dd_phys->dd_clones, o, tx), ==, 0);
2787                                 VERIFY3U(zap_add_int(dp->dp_meta_objset,
2788                                     dd->dd_phys->dd_clones, o, tx), ==, 0);
2789                                 dsl_dataset_rele(cnds, FTAG);
2790                         }
2791                         zap_cursor_fini(&zc);
2792                 }
2793
2794                 ASSERT3U(dsl_prop_numcb(ds), ==, 0);
2795         }
2796
2797         /*
2798          * Change space accounting.
2799          * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either
2800          * both be valid, or both be 0 (resulting in delta == 0).  This
2801          * is true for each of {clone,origin} independently.
2802          */
2803
2804         delta = pa->cloneusedsnap -
2805             dd->dd_phys->dd_used_breakdown[DD_USED_SNAP];
2806         ASSERT3S(delta, >=, 0);
2807         ASSERT3U(pa->used, >=, delta);
2808         dsl_dir_diduse_space(dd, DD_USED_SNAP, delta, 0, 0, tx);
2809         dsl_dir_diduse_space(dd, DD_USED_HEAD,
2810             pa->used - delta, pa->comp, pa->uncomp, tx);
2811
2812         delta = pa->originusedsnap -
2813             odd->dd_phys->dd_used_breakdown[DD_USED_SNAP];
2814         ASSERT3S(delta, <=, 0);
2815         ASSERT3U(pa->used, >=, -delta);
2816         dsl_dir_diduse_space(odd, DD_USED_SNAP, delta, 0, 0, tx);
2817         dsl_dir_diduse_space(odd, DD_USED_HEAD,
2818             -pa->used - delta, -pa->comp, -pa->uncomp, tx);
2819
2820         origin_ds->ds_phys->ds_unique_bytes = pa->unique;
2821
2822         /* log history record */
2823         spa_history_log_internal(LOG_DS_PROMOTE, dd->dd_pool->dp_spa, tx,
2824             "dataset = %llu", hds->ds_object);
2825
2826         dsl_dir_close(odd, FTAG);
2827 }
2828
2829 static char *snaplist_tag = "snaplist";
2830 /*
2831  * Make a list of dsl_dataset_t's for the snapshots between first_obj
2832  * (exclusive) and last_obj (inclusive).  The list will be in reverse
2833  * order (last_obj will be the list_head()).  If first_obj == 0, do all
2834  * snapshots back to this dataset's origin.
2835  */
2836 static int
2837 snaplist_make(dsl_pool_t *dp, boolean_t own,
2838     uint64_t first_obj, uint64_t last_obj, list_t *l)
2839 {
2840         uint64_t obj = last_obj;
2841
2842         ASSERT(RW_LOCK_HELD(&dp->dp_config_rwlock));
2843
2844         list_create(l, sizeof (struct promotenode),
2845             offsetof(struct promotenode, link));
2846
2847         while (obj != first_obj) {
2848                 dsl_dataset_t *ds;
2849                 struct promotenode *snap;
2850                 int err;
2851
2852                 if (own) {
2853                         err = dsl_dataset_own_obj(dp, obj,
2854                             0, snaplist_tag, &ds);
2855                         if (err == 0)
2856                                 dsl_dataset_make_exclusive(ds, snaplist_tag);
2857                 } else {
2858                         err = dsl_dataset_hold_obj(dp, obj, snaplist_tag, &ds);
2859                 }
2860                 if (err == ENOENT) {
2861                         /* lost race with snapshot destroy */
2862                         struct promotenode *last = list_tail(l);
2863                         ASSERT(obj != last->ds->ds_phys->ds_prev_snap_obj);
2864                         obj = last->ds->ds_phys->ds_prev_snap_obj;
2865                         continue;
2866                 } else if (err) {
2867                         return (err);
2868                 }
2869
2870                 if (first_obj == 0)
2871                         first_obj = ds->ds_dir->dd_phys->dd_origin_obj;
2872
2873                 snap = kmem_alloc(sizeof (struct promotenode), KM_SLEEP);
2874                 snap->ds = ds;
2875                 list_insert_tail(l, snap);
2876                 obj = ds->ds_phys->ds_prev_snap_obj;
2877         }
2878
2879         return (0);
2880 }
2881
2882 static int
2883 snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep)
2884 {
2885         struct promotenode *snap;
2886
2887         *spacep = 0;
2888         for (snap = list_head(l); snap; snap = list_next(l, snap)) {
2889                 uint64_t used, comp, uncomp;
2890                 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
2891                     mintxg, UINT64_MAX, &used, &comp, &uncomp);
2892                 *spacep += used;
2893         }
2894         return (0);
2895 }
2896
2897 static void
2898 snaplist_destroy(list_t *l, boolean_t own)
2899 {
2900         struct promotenode *snap;
2901
2902         if (!l || !list_link_active(&l->list_head))
2903                 return;
2904
2905         while ((snap = list_tail(l)) != NULL) {
2906                 list_remove(l, snap);
2907                 if (own)
2908                         dsl_dataset_disown(snap->ds, snaplist_tag);
2909                 else
2910                         dsl_dataset_rele(snap->ds, snaplist_tag);
2911                 kmem_free(snap, sizeof (struct promotenode));
2912         }
2913         list_destroy(l);
2914 }
2915
2916 /*
2917  * Promote a clone.  Nomenclature note:
2918  * "clone" or "cds": the original clone which is being promoted
2919  * "origin" or "ods": the snapshot which is originally clone's origin
2920  * "origin head" or "ohds": the dataset which is the head
2921  * (filesystem/volume) for the origin
2922  * "origin origin": the origin of the origin's filesystem (typically
2923  * NULL, indicating that the clone is not a clone of a clone).
2924  */
2925 int
2926 dsl_dataset_promote(const char *name, char *conflsnap)
2927 {
2928         dsl_dataset_t *ds;
2929         dsl_dir_t *dd;
2930         dsl_pool_t *dp;
2931         dmu_object_info_t doi;
2932         struct promotearg pa;
2933         struct promotenode *snap;
2934         int err;
2935
2936         bzero(&pa, sizeof(struct promotearg));
2937         err = dsl_dataset_hold(name, FTAG, &ds);
2938         if (err)
2939                 return (err);
2940         dd = ds->ds_dir;
2941         dp = dd->dd_pool;
2942
2943         err = dmu_object_info(dp->dp_meta_objset,
2944             ds->ds_phys->ds_snapnames_zapobj, &doi);
2945         if (err) {
2946                 dsl_dataset_rele(ds, FTAG);
2947                 return (err);
2948         }
2949
2950         if (dsl_dataset_is_snapshot(ds) || dd->dd_phys->dd_origin_obj == 0) {
2951                 dsl_dataset_rele(ds, FTAG);
2952                 return (EINVAL);
2953         }
2954
2955         /*
2956          * We are going to inherit all the snapshots taken before our
2957          * origin (i.e., our new origin will be our parent's origin).
2958          * Take ownership of them so that we can rename them into our
2959          * namespace.
2960          */
2961         rw_enter(&dp->dp_config_rwlock, RW_READER);
2962
2963         err = snaplist_make(dp, B_TRUE, 0, dd->dd_phys->dd_origin_obj,
2964             &pa.shared_snaps);
2965         if (err != 0)
2966                 goto out;
2967
2968         err = snaplist_make(dp, B_FALSE, 0, ds->ds_object, &pa.clone_snaps);
2969         if (err != 0)
2970                 goto out;
2971
2972         snap = list_head(&pa.shared_snaps);
2973         ASSERT3U(snap->ds->ds_object, ==, dd->dd_phys->dd_origin_obj);
2974         err = snaplist_make(dp, B_FALSE, dd->dd_phys->dd_origin_obj,
2975             snap->ds->ds_dir->dd_phys->dd_head_dataset_obj, &pa.origin_snaps);
2976         if (err != 0)
2977                 goto out;
2978
2979         if (snap->ds->ds_dir->dd_phys->dd_origin_obj != 0) {
2980                 err = dsl_dataset_hold_obj(dp,
2981                     snap->ds->ds_dir->dd_phys->dd_origin_obj,
2982                     FTAG, &pa.origin_origin);
2983                 if (err != 0)
2984                         goto out;
2985         }
2986
2987 out:
2988         rw_exit(&dp->dp_config_rwlock);
2989
2990         /*
2991          * Add in 128x the snapnames zapobj size, since we will be moving
2992          * a bunch of snapnames to the promoted ds, and dirtying their
2993          * bonus buffers.
2994          */
2995         if (err == 0) {
2996                 err = dsl_sync_task_do(dp, dsl_dataset_promote_check,
2997                     dsl_dataset_promote_sync, ds, &pa,
2998                     2 + 2 * doi.doi_physical_blocks_512);
2999                 if (err && pa.err_ds && conflsnap)
3000                         (void) strncpy(conflsnap, pa.err_ds, MAXNAMELEN);
3001         }
3002
3003         snaplist_destroy(&pa.shared_snaps, B_TRUE);
3004         snaplist_destroy(&pa.clone_snaps, B_FALSE);
3005         snaplist_destroy(&pa.origin_snaps, B_FALSE);
3006         if (pa.origin_origin)
3007                 dsl_dataset_rele(pa.origin_origin, FTAG);
3008         dsl_dataset_rele(ds, FTAG);
3009         return (err);
3010 }
3011
3012 struct cloneswaparg {
3013         dsl_dataset_t *cds; /* clone dataset */
3014         dsl_dataset_t *ohds; /* origin's head dataset */
3015         boolean_t force;
3016         int64_t unused_refres_delta; /* change in unconsumed refreservation */
3017 };
3018
3019 /* ARGSUSED */
3020 static int
3021 dsl_dataset_clone_swap_check(void *arg1, void *arg2, dmu_tx_t *tx)
3022 {
3023         struct cloneswaparg *csa = arg1;
3024
3025         /* they should both be heads */
3026         if (dsl_dataset_is_snapshot(csa->cds) ||
3027             dsl_dataset_is_snapshot(csa->ohds))
3028                 return (EINVAL);
3029
3030         /* the branch point should be just before them */
3031         if (csa->cds->ds_prev != csa->ohds->ds_prev)
3032                 return (EINVAL);
3033
3034         /* cds should be the clone (unless they are unrelated) */
3035         if (csa->cds->ds_prev != NULL &&
3036             csa->cds->ds_prev != csa->cds->ds_dir->dd_pool->dp_origin_snap &&
3037             csa->ohds->ds_object !=
3038             csa->cds->ds_prev->ds_phys->ds_next_snap_obj)
3039                 return (EINVAL);
3040
3041         /* the clone should be a child of the origin */
3042         if (csa->cds->ds_dir->dd_parent != csa->ohds->ds_dir)
3043                 return (EINVAL);
3044
3045         /* ohds shouldn't be modified unless 'force' */
3046         if (!csa->force && dsl_dataset_modified_since_lastsnap(csa->ohds))
3047                 return (ETXTBSY);
3048
3049         /* adjust amount of any unconsumed refreservation */
3050         csa->unused_refres_delta =
3051             (int64_t)MIN(csa->ohds->ds_reserved,
3052             csa->ohds->ds_phys->ds_unique_bytes) -
3053             (int64_t)MIN(csa->ohds->ds_reserved,
3054             csa->cds->ds_phys->ds_unique_bytes);
3055
3056         if (csa->unused_refres_delta > 0 &&
3057             csa->unused_refres_delta >
3058             dsl_dir_space_available(csa->ohds->ds_dir, NULL, 0, TRUE))
3059                 return (ENOSPC);
3060
3061         if (csa->ohds->ds_quota != 0 &&
3062             csa->cds->ds_phys->ds_unique_bytes > csa->ohds->ds_quota)
3063                 return (EDQUOT);
3064
3065         return (0);
3066 }
3067
3068 /* ARGSUSED */
3069 static void
3070 dsl_dataset_clone_swap_sync(void *arg1, void *arg2, dmu_tx_t *tx)
3071 {
3072         struct cloneswaparg *csa = arg1;
3073         dsl_pool_t *dp = csa->cds->ds_dir->dd_pool;
3074
3075         ASSERT(csa->cds->ds_reserved == 0);
3076         ASSERT(csa->ohds->ds_quota == 0 ||
3077             csa->cds->ds_phys->ds_unique_bytes <= csa->ohds->ds_quota);
3078
3079         dmu_buf_will_dirty(csa->cds->ds_dbuf, tx);
3080         dmu_buf_will_dirty(csa->ohds->ds_dbuf, tx);
3081
3082         if (csa->cds->ds_objset != NULL) {
3083                 dmu_objset_evict(csa->cds->ds_objset);
3084                 csa->cds->ds_objset = NULL;
3085         }
3086
3087         if (csa->ohds->ds_objset != NULL) {
3088                 dmu_objset_evict(csa->ohds->ds_objset);
3089                 csa->ohds->ds_objset = NULL;
3090         }
3091
3092         /*
3093          * Reset origin's unique bytes, if it exists.
3094          */
3095         if (csa->cds->ds_prev) {
3096                 dsl_dataset_t *origin = csa->cds->ds_prev;
3097                 uint64_t comp, uncomp;
3098
3099                 dmu_buf_will_dirty(origin->ds_dbuf, tx);
3100                 dsl_deadlist_space_range(&csa->cds->ds_deadlist,
3101                     origin->ds_phys->ds_prev_snap_txg, UINT64_MAX,
3102                     &origin->ds_phys->ds_unique_bytes, &comp, &uncomp);
3103         }
3104
3105         /* swap blkptrs */
3106         {
3107                 blkptr_t tmp;
3108                 tmp = csa->ohds->ds_phys->ds_bp;
3109                 csa->ohds->ds_phys->ds_bp = csa->cds->ds_phys->ds_bp;
3110                 csa->cds->ds_phys->ds_bp = tmp;
3111         }
3112
3113         /* set dd_*_bytes */
3114         {
3115                 int64_t dused, dcomp, duncomp;
3116                 uint64_t cdl_used, cdl_comp, cdl_uncomp;
3117                 uint64_t odl_used, odl_comp, odl_uncomp;
3118
3119                 ASSERT3U(csa->cds->ds_dir->dd_phys->
3120                     dd_used_breakdown[DD_USED_SNAP], ==, 0);
3121
3122                 dsl_deadlist_space(&csa->cds->ds_deadlist,
3123                     &cdl_used, &cdl_comp, &cdl_uncomp);
3124                 dsl_deadlist_space(&csa->ohds->ds_deadlist,
3125                     &odl_used, &odl_comp, &odl_uncomp);
3126
3127                 dused = csa->cds->ds_phys->ds_used_bytes + cdl_used -
3128                     (csa->ohds->ds_phys->ds_used_bytes + odl_used);
3129                 dcomp = csa->cds->ds_phys->ds_compressed_bytes + cdl_comp -
3130                     (csa->ohds->ds_phys->ds_compressed_bytes + odl_comp);
3131                 duncomp = csa->cds->ds_phys->ds_uncompressed_bytes +
3132                     cdl_uncomp -
3133                     (csa->ohds->ds_phys->ds_uncompressed_bytes + odl_uncomp);
3134
3135                 dsl_dir_diduse_space(csa->ohds->ds_dir, DD_USED_HEAD,
3136                     dused, dcomp, duncomp, tx);
3137                 dsl_dir_diduse_space(csa->cds->ds_dir, DD_USED_HEAD,
3138                     -dused, -dcomp, -duncomp, tx);
3139
3140                 /*
3141                  * The difference in the space used by snapshots is the
3142                  * difference in snapshot space due to the head's
3143                  * deadlist (since that's the only thing that's
3144                  * changing that affects the snapused).
3145                  */
3146                 dsl_deadlist_space_range(&csa->cds->ds_deadlist,
3147                     csa->ohds->ds_dir->dd_origin_txg, UINT64_MAX,
3148                     &cdl_used, &cdl_comp, &cdl_uncomp);
3149                 dsl_deadlist_space_range(&csa->ohds->ds_deadlist,
3150                     csa->ohds->ds_dir->dd_origin_txg, UINT64_MAX,
3151                     &odl_used, &odl_comp, &odl_uncomp);
3152                 dsl_dir_transfer_space(csa->ohds->ds_dir, cdl_used - odl_used,
3153                     DD_USED_HEAD, DD_USED_SNAP, tx);
3154         }
3155
3156         /* swap ds_*_bytes */
3157         SWITCH64(csa->ohds->ds_phys->ds_used_bytes,
3158             csa->cds->ds_phys->ds_used_bytes);
3159         SWITCH64(csa->ohds->ds_phys->ds_compressed_bytes,
3160             csa->cds->ds_phys->ds_compressed_bytes);
3161         SWITCH64(csa->ohds->ds_phys->ds_uncompressed_bytes,
3162             csa->cds->ds_phys->ds_uncompressed_bytes);
3163         SWITCH64(csa->ohds->ds_phys->ds_unique_bytes,
3164             csa->cds->ds_phys->ds_unique_bytes);
3165
3166         /* apply any parent delta for change in unconsumed refreservation */
3167         dsl_dir_diduse_space(csa->ohds->ds_dir, DD_USED_REFRSRV,
3168             csa->unused_refres_delta, 0, 0, tx);
3169
3170         /*
3171          * Swap deadlists.
3172          */
3173         dsl_deadlist_close(&csa->cds->ds_deadlist);
3174         dsl_deadlist_close(&csa->ohds->ds_deadlist);
3175         SWITCH64(csa->ohds->ds_phys->ds_deadlist_obj,
3176             csa->cds->ds_phys->ds_deadlist_obj);
3177         dsl_deadlist_open(&csa->cds->ds_deadlist, dp->dp_meta_objset,
3178             csa->cds->ds_phys->ds_deadlist_obj);
3179         dsl_deadlist_open(&csa->ohds->ds_deadlist, dp->dp_meta_objset,
3180             csa->ohds->ds_phys->ds_deadlist_obj);
3181
3182         dsl_scan_ds_clone_swapped(csa->ohds, csa->cds, tx);
3183 }
3184
3185 /*
3186  * Swap 'clone' with its origin head datasets.  Used at the end of "zfs
3187  * recv" into an existing fs to swizzle the file system to the new
3188  * version, and by "zfs rollback".  Can also be used to swap two
3189  * independent head datasets if neither has any snapshots.
3190  */
3191 int
3192 dsl_dataset_clone_swap(dsl_dataset_t *clone, dsl_dataset_t *origin_head,
3193     boolean_t force)
3194 {
3195         struct cloneswaparg csa;
3196         int error;
3197
3198         ASSERT(clone->ds_owner);
3199         ASSERT(origin_head->ds_owner);
3200 retry:
3201         /*
3202          * Need exclusive access for the swap. If we're swapping these
3203          * datasets back after an error, we already hold the locks.
3204          */
3205         if (!RW_WRITE_HELD(&clone->ds_rwlock))
3206                 rw_enter(&clone->ds_rwlock, RW_WRITER);
3207         if (!RW_WRITE_HELD(&origin_head->ds_rwlock) &&
3208             !rw_tryenter(&origin_head->ds_rwlock, RW_WRITER)) {
3209                 rw_exit(&clone->ds_rwlock);
3210                 rw_enter(&origin_head->ds_rwlock, RW_WRITER);
3211                 if (!rw_tryenter(&clone->ds_rwlock, RW_WRITER)) {
3212                         rw_exit(&origin_head->ds_rwlock);
3213                         goto retry;
3214                 }
3215         }
3216         csa.cds = clone;
3217         csa.ohds = origin_head;
3218         csa.force = force;
3219         error = dsl_sync_task_do(clone->ds_dir->dd_pool,
3220             dsl_dataset_clone_swap_check,
3221             dsl_dataset_clone_swap_sync, &csa, NULL, 9);
3222         return (error);
3223 }
3224
3225 /*
3226  * Given a pool name and a dataset object number in that pool,
3227  * return the name of that dataset.
3228  */
3229 int
3230 dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf)
3231 {
3232         spa_t *spa;
3233         dsl_pool_t *dp;
3234         dsl_dataset_t *ds;
3235         int error;
3236
3237         if ((error = spa_open(pname, &spa, FTAG)) != 0)
3238                 return (error);
3239         dp = spa_get_dsl(spa);
3240         rw_enter(&dp->dp_config_rwlock, RW_READER);
3241         if ((error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds)) == 0) {
3242                 dsl_dataset_name(ds, buf);
3243                 dsl_dataset_rele(ds, FTAG);
3244         }
3245         rw_exit(&dp->dp_config_rwlock);
3246         spa_close(spa, FTAG);
3247
3248         return (error);
3249 }
3250
3251 int
3252 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
3253     uint64_t asize, uint64_t inflight, uint64_t *used, uint64_t *ref_rsrv)
3254 {
3255         int error = 0;
3256
3257         ASSERT3S(asize, >, 0);
3258
3259         /*
3260          * *ref_rsrv is the portion of asize that will come from any
3261          * unconsumed refreservation space.
3262          */
3263         *ref_rsrv = 0;
3264
3265         mutex_enter(&ds->ds_lock);
3266         /*
3267          * Make a space adjustment for reserved bytes.
3268          */
3269         if (ds->ds_reserved > ds->ds_phys->ds_unique_bytes) {
3270                 ASSERT3U(*used, >=,
3271                     ds->ds_reserved - ds->ds_phys->ds_unique_bytes);
3272                 *used -= (ds->ds_reserved - ds->ds_phys->ds_unique_bytes);
3273                 *ref_rsrv =
3274                     asize - MIN(asize, parent_delta(ds, asize + inflight));
3275         }
3276
3277         if (!check_quota || ds->ds_quota == 0) {
3278                 mutex_exit(&ds->ds_lock);
3279                 return (0);
3280         }
3281         /*
3282          * If they are requesting more space, and our current estimate
3283          * is over quota, they get to try again unless the actual
3284          * on-disk is over quota and there are no pending changes (which
3285          * may free up space for us).
3286          */
3287         if (ds->ds_phys->ds_used_bytes + inflight >= ds->ds_quota) {
3288                 if (inflight > 0 || ds->ds_phys->ds_used_bytes < ds->ds_quota)
3289                         error = ERESTART;
3290                 else
3291                         error = EDQUOT;
3292
3293                 DMU_TX_STAT_BUMP(dmu_tx_quota);
3294         }
3295         mutex_exit(&ds->ds_lock);
3296
3297         return (error);
3298 }
3299
3300 /* ARGSUSED */
3301 static int
3302 dsl_dataset_set_quota_check(void *arg1, void *arg2, dmu_tx_t *tx)
3303 {
3304         dsl_dataset_t *ds = arg1;
3305         dsl_prop_setarg_t *psa = arg2;
3306         int err;
3307
3308         if (spa_version(ds->ds_dir->dd_pool->dp_spa) < SPA_VERSION_REFQUOTA)
3309                 return (ENOTSUP);
3310
3311         if ((err = dsl_prop_predict_sync(ds->ds_dir, psa)) != 0)
3312                 return (err);
3313
3314         if (psa->psa_effective_value == 0)
3315                 return (0);
3316
3317         if (psa->psa_effective_value < ds->ds_phys->ds_used_bytes ||
3318             psa->psa_effective_value < ds->ds_reserved)
3319                 return (ENOSPC);
3320
3321         return (0);
3322 }
3323
3324 extern void dsl_prop_set_sync(void *, void *, dmu_tx_t *);
3325
3326 void
3327 dsl_dataset_set_quota_sync(void *arg1, void *arg2, dmu_tx_t *tx)
3328 {
3329         dsl_dataset_t *ds = arg1;
3330         dsl_prop_setarg_t *psa = arg2;
3331         uint64_t effective_value = psa->psa_effective_value;
3332
3333         dsl_prop_set_sync(ds, psa, tx);
3334         DSL_PROP_CHECK_PREDICTION(ds->ds_dir, psa);
3335
3336         if (ds->ds_quota != effective_value) {
3337                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
3338                 ds->ds_quota = effective_value;
3339
3340                 spa_history_log_internal(LOG_DS_REFQUOTA,
3341                     ds->ds_dir->dd_pool->dp_spa, tx, "%lld dataset = %llu ",
3342                     (longlong_t)ds->ds_quota, ds->ds_object);
3343         }
3344 }
3345
3346 int
3347 dsl_dataset_set_quota(const char *dsname, zprop_source_t source, uint64_t quota)
3348 {
3349         dsl_dataset_t *ds;
3350         dsl_prop_setarg_t psa;
3351         int err;
3352
3353         dsl_prop_setarg_init_uint64(&psa, "refquota", source, &quota);
3354
3355         err = dsl_dataset_hold(dsname, FTAG, &ds);
3356         if (err)
3357                 return (err);
3358
3359         /*
3360          * If someone removes a file, then tries to set the quota, we
3361          * want to make sure the file freeing takes effect.
3362          */
3363         txg_wait_open(ds->ds_dir->dd_pool, 0);
3364
3365         err = dsl_sync_task_do(ds->ds_dir->dd_pool,
3366             dsl_dataset_set_quota_check, dsl_dataset_set_quota_sync,
3367             ds, &psa, 0);
3368
3369         dsl_dataset_rele(ds, FTAG);
3370         return (err);
3371 }
3372
3373 static int
3374 dsl_dataset_set_reservation_check(void *arg1, void *arg2, dmu_tx_t *tx)
3375 {
3376         dsl_dataset_t *ds = arg1;
3377         dsl_prop_setarg_t *psa = arg2;
3378         uint64_t effective_value;
3379         uint64_t unique;
3380         int err;
3381
3382         if (spa_version(ds->ds_dir->dd_pool->dp_spa) <
3383             SPA_VERSION_REFRESERVATION)
3384                 return (ENOTSUP);
3385
3386         if (dsl_dataset_is_snapshot(ds))
3387                 return (EINVAL);
3388
3389         if ((err = dsl_prop_predict_sync(ds->ds_dir, psa)) != 0)
3390                 return (err);
3391
3392         effective_value = psa->psa_effective_value;
3393
3394         /*
3395          * If we are doing the preliminary check in open context, the
3396          * space estimates may be inaccurate.
3397          */
3398         if (!dmu_tx_is_syncing(tx))
3399                 return (0);
3400
3401         mutex_enter(&ds->ds_lock);
3402         if (!DS_UNIQUE_IS_ACCURATE(ds))
3403                 dsl_dataset_recalc_head_uniq(ds);
3404         unique = ds->ds_phys->ds_unique_bytes;
3405         mutex_exit(&ds->ds_lock);
3406
3407         if (MAX(unique, effective_value) > MAX(unique, ds->ds_reserved)) {
3408                 uint64_t delta = MAX(unique, effective_value) -
3409                     MAX(unique, ds->ds_reserved);
3410
3411                 if (delta > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
3412                         return (ENOSPC);
3413                 if (ds->ds_quota > 0 &&
3414                     effective_value > ds->ds_quota)
3415                         return (ENOSPC);
3416         }
3417
3418         return (0);
3419 }
3420
3421 static void
3422 dsl_dataset_set_reservation_sync(void *arg1, void *arg2, dmu_tx_t *tx)
3423 {
3424         dsl_dataset_t *ds = arg1;
3425         dsl_prop_setarg_t *psa = arg2;
3426         uint64_t effective_value = psa->psa_effective_value;
3427         uint64_t unique;
3428         int64_t delta;
3429
3430         dsl_prop_set_sync(ds, psa, tx);
3431         DSL_PROP_CHECK_PREDICTION(ds->ds_dir, psa);
3432
3433         dmu_buf_will_dirty(ds->ds_dbuf, tx);
3434
3435         mutex_enter(&ds->ds_dir->dd_lock);
3436         mutex_enter(&ds->ds_lock);
3437         ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
3438         unique = ds->ds_phys->ds_unique_bytes;
3439         delta = MAX(0, (int64_t)(effective_value - unique)) -
3440             MAX(0, (int64_t)(ds->ds_reserved - unique));
3441         ds->ds_reserved = effective_value;
3442         mutex_exit(&ds->ds_lock);
3443
3444         dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
3445         mutex_exit(&ds->ds_dir->dd_lock);
3446
3447         spa_history_log_internal(LOG_DS_REFRESERV,
3448             ds->ds_dir->dd_pool->dp_spa, tx, "%lld dataset = %llu",
3449             (longlong_t)effective_value, ds->ds_object);
3450 }
3451
3452 int
3453 dsl_dataset_set_reservation(const char *dsname, zprop_source_t source,
3454     uint64_t reservation)
3455 {
3456         dsl_dataset_t *ds;
3457         dsl_prop_setarg_t psa;
3458         int err;
3459
3460         dsl_prop_setarg_init_uint64(&psa, "refreservation", source,
3461             &reservation);
3462
3463         err = dsl_dataset_hold(dsname, FTAG, &ds);
3464         if (err)
3465                 return (err);
3466
3467         err = dsl_sync_task_do(ds->ds_dir->dd_pool,
3468             dsl_dataset_set_reservation_check,
3469             dsl_dataset_set_reservation_sync, ds, &psa, 0);
3470
3471         dsl_dataset_rele(ds, FTAG);
3472         return (err);
3473 }
3474
3475 typedef struct zfs_hold_cleanup_arg {
3476         dsl_pool_t *dp;
3477         uint64_t dsobj;
3478         char htag[MAXNAMELEN];
3479 } zfs_hold_cleanup_arg_t;
3480
3481 static void
3482 dsl_dataset_user_release_onexit(void *arg)
3483 {
3484         zfs_hold_cleanup_arg_t *ca = arg;
3485
3486         (void) dsl_dataset_user_release_tmp(ca->dp, ca->dsobj, ca->htag,
3487             B_TRUE);
3488         kmem_free(ca, sizeof (zfs_hold_cleanup_arg_t));
3489 }
3490
3491 void
3492 dsl_register_onexit_hold_cleanup(dsl_dataset_t *ds, const char *htag,
3493     minor_t minor)
3494 {
3495         zfs_hold_cleanup_arg_t *ca;
3496
3497         ca = kmem_alloc(sizeof (zfs_hold_cleanup_arg_t), KM_SLEEP);
3498         ca->dp = ds->ds_dir->dd_pool;
3499         ca->dsobj = ds->ds_object;
3500         (void) strlcpy(ca->htag, htag, sizeof (ca->htag));
3501         VERIFY3U(0, ==, zfs_onexit_add_cb(minor,
3502             dsl_dataset_user_release_onexit, ca, NULL));
3503 }
3504
3505 /*
3506  * If you add new checks here, you may need to add
3507  * additional checks to the "temporary" case in
3508  * snapshot_check() in dmu_objset.c.
3509  */
3510 static int
3511 dsl_dataset_user_hold_check(void *arg1, void *arg2, dmu_tx_t *tx)
3512 {
3513         dsl_dataset_t *ds = arg1;
3514         struct dsl_ds_holdarg *ha = arg2;
3515         char *htag = ha->htag;
3516         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
3517         int error = 0;
3518
3519         if (spa_version(ds->ds_dir->dd_pool->dp_spa) < SPA_VERSION_USERREFS)
3520                 return (ENOTSUP);
3521
3522         if (!dsl_dataset_is_snapshot(ds))
3523                 return (EINVAL);
3524
3525         /* tags must be unique */
3526         mutex_enter(&ds->ds_lock);
3527         if (ds->ds_phys->ds_userrefs_obj) {
3528                 error = zap_lookup(mos, ds->ds_phys->ds_userrefs_obj, htag,
3529                     8, 1, tx);
3530                 if (error == 0)
3531                         error = EEXIST;
3532                 else if (error == ENOENT)
3533                         error = 0;
3534         }
3535         mutex_exit(&ds->ds_lock);
3536
3537         if (error == 0 && ha->temphold &&
3538             strlen(htag) + MAX_TAG_PREFIX_LEN >= MAXNAMELEN)
3539                 error = E2BIG;
3540
3541         return (error);
3542 }
3543
3544 void
3545 dsl_dataset_user_hold_sync(void *arg1, void *arg2, dmu_tx_t *tx)
3546 {
3547         dsl_dataset_t *ds = arg1;
3548         struct dsl_ds_holdarg *ha = arg2;
3549         char *htag = ha->htag;
3550         dsl_pool_t *dp = ds->ds_dir->dd_pool;
3551         objset_t *mos = dp->dp_meta_objset;
3552         uint64_t now = gethrestime_sec();
3553         uint64_t zapobj;
3554
3555         mutex_enter(&ds->ds_lock);
3556         if (ds->ds_phys->ds_userrefs_obj == 0) {
3557                 /*
3558                  * This is the first user hold for this dataset.  Create
3559                  * the userrefs zap object.
3560                  */
3561                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
3562                 zapobj = ds->ds_phys->ds_userrefs_obj =
3563                     zap_create(mos, DMU_OT_USERREFS, DMU_OT_NONE, 0, tx);
3564         } else {
3565                 zapobj = ds->ds_phys->ds_userrefs_obj;
3566         }
3567         ds->ds_userrefs++;
3568         mutex_exit(&ds->ds_lock);
3569
3570         VERIFY(0 == zap_add(mos, zapobj, htag, 8, 1, &now, tx));
3571
3572         if (ha->temphold) {
3573                 VERIFY(0 == dsl_pool_user_hold(dp, ds->ds_object,
3574                     htag, &now, tx));
3575         }
3576
3577         spa_history_log_internal(LOG_DS_USER_HOLD,
3578             dp->dp_spa, tx, "<%s> temp = %d dataset = %llu", htag,
3579             (int)ha->temphold, ds->ds_object);
3580 }
3581
3582 static int
3583 dsl_dataset_user_hold_one(const char *dsname, void *arg)
3584 {
3585         struct dsl_ds_holdarg *ha = arg;
3586         dsl_dataset_t *ds;
3587         int error;
3588         char *name;
3589
3590         /* alloc a buffer to hold dsname@snapname plus terminating NULL */
3591         name = kmem_asprintf("%s@%s", dsname, ha->snapname);
3592         error = dsl_dataset_hold(name, ha->dstg, &ds);
3593         strfree(name);
3594         if (error == 0) {
3595                 ha->gotone = B_TRUE;
3596                 dsl_sync_task_create(ha->dstg, dsl_dataset_user_hold_check,
3597                     dsl_dataset_user_hold_sync, ds, ha, 0);
3598         } else if (error == ENOENT && ha->recursive) {
3599                 error = 0;
3600         } else {
3601                 (void) strlcpy(ha->failed, dsname, sizeof (ha->failed));
3602         }
3603         return (error);
3604 }
3605
3606 int
3607 dsl_dataset_user_hold_for_send(dsl_dataset_t *ds, char *htag,
3608     boolean_t temphold)
3609 {
3610         struct dsl_ds_holdarg *ha;
3611         int error;
3612
3613         ha = kmem_zalloc(sizeof (struct dsl_ds_holdarg), KM_SLEEP);
3614         ha->htag = htag;
3615         ha->temphold = temphold;
3616         error = dsl_sync_task_do(ds->ds_dir->dd_pool,
3617             dsl_dataset_user_hold_check, dsl_dataset_user_hold_sync,
3618             ds, ha, 0);
3619         kmem_free(ha, sizeof (struct dsl_ds_holdarg));
3620
3621         return (error);
3622 }
3623
3624 int
3625 dsl_dataset_user_hold(char *dsname, char *snapname, char *htag,
3626     boolean_t recursive, boolean_t temphold, int cleanup_fd)
3627 {
3628         struct dsl_ds_holdarg *ha;
3629         dsl_sync_task_t *dst;
3630         spa_t *spa;
3631         int error;
3632         minor_t minor = 0;
3633
3634         if (cleanup_fd != -1) {
3635                 /* Currently we only support cleanup-on-exit of tempholds. */
3636                 if (!temphold)
3637                         return (EINVAL);
3638                 error = zfs_onexit_fd_hold(cleanup_fd, &minor);
3639                 if (error)
3640                         return (error);
3641         }
3642
3643         ha = kmem_zalloc(sizeof (struct dsl_ds_holdarg), KM_SLEEP);
3644
3645         (void) strlcpy(ha->failed, dsname, sizeof (ha->failed));
3646
3647         error = spa_open(dsname, &spa, FTAG);
3648         if (error) {
3649                 kmem_free(ha, sizeof (struct dsl_ds_holdarg));
3650                 if (cleanup_fd != -1)
3651                         zfs_onexit_fd_rele(cleanup_fd);
3652                 return (error);
3653         }
3654
3655         ha->dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
3656         ha->htag = htag;
3657         ha->snapname = snapname;
3658         ha->recursive = recursive;
3659         ha->temphold = temphold;
3660
3661         if (recursive) {
3662                 error = dmu_objset_find(dsname, dsl_dataset_user_hold_one,
3663                     ha, DS_FIND_CHILDREN);
3664         } else {
3665                 error = dsl_dataset_user_hold_one(dsname, ha);
3666         }
3667         if (error == 0)
3668                 error = dsl_sync_task_group_wait(ha->dstg);
3669
3670         for (dst = list_head(&ha->dstg->dstg_tasks); dst;
3671             dst = list_next(&ha->dstg->dstg_tasks, dst)) {
3672                 dsl_dataset_t *ds = dst->dst_arg1;
3673
3674                 if (dst->dst_err) {
3675                         dsl_dataset_name(ds, ha->failed);
3676                         *strchr(ha->failed, '@') = '\0';
3677                 } else if (error == 0 && minor != 0 && temphold) {
3678                         /*
3679                          * If this hold is to be released upon process exit,
3680                          * register that action now.
3681                          */
3682                         dsl_register_onexit_hold_cleanup(ds, htag, minor);
3683                 }
3684                 dsl_dataset_rele(ds, ha->dstg);
3685         }
3686
3687         if (error == 0 && recursive && !ha->gotone)
3688                 error = ENOENT;
3689
3690         if (error)
3691                 (void) strlcpy(dsname, ha->failed, sizeof (ha->failed));
3692
3693         dsl_sync_task_group_destroy(ha->dstg);
3694
3695         kmem_free(ha, sizeof (struct dsl_ds_holdarg));
3696         spa_close(spa, FTAG);
3697         if (cleanup_fd != -1)
3698                 zfs_onexit_fd_rele(cleanup_fd);
3699         return (error);
3700 }
3701
3702 struct dsl_ds_releasearg {
3703         dsl_dataset_t *ds;
3704         const char *htag;
3705         boolean_t own;          /* do we own or just hold ds? */
3706 };
3707
3708 static int
3709 dsl_dataset_release_might_destroy(dsl_dataset_t *ds, const char *htag,
3710     boolean_t *might_destroy)
3711 {
3712         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
3713         uint64_t zapobj;
3714         uint64_t tmp;
3715         int error;
3716
3717         *might_destroy = B_FALSE;
3718
3719         mutex_enter(&ds->ds_lock);
3720         zapobj = ds->ds_phys->ds_userrefs_obj;
3721         if (zapobj == 0) {
3722                 /* The tag can't possibly exist */
3723                 mutex_exit(&ds->ds_lock);
3724                 return (ESRCH);
3725         }
3726
3727         /* Make sure the tag exists */
3728         error = zap_lookup(mos, zapobj, htag, 8, 1, &tmp);
3729         if (error) {
3730                 mutex_exit(&ds->ds_lock);
3731                 if (error == ENOENT)
3732                         error = ESRCH;
3733                 return (error);
3734         }
3735
3736         if (ds->ds_userrefs == 1 && ds->ds_phys->ds_num_children == 1 &&
3737             DS_IS_DEFER_DESTROY(ds))
3738                 *might_destroy = B_TRUE;
3739
3740         mutex_exit(&ds->ds_lock);
3741         return (0);
3742 }
3743
3744 static int
3745 dsl_dataset_user_release_check(void *arg1, void *tag, dmu_tx_t *tx)
3746 {
3747         struct dsl_ds_releasearg *ra = arg1;
3748         dsl_dataset_t *ds = ra->ds;
3749         boolean_t might_destroy;
3750         int error;
3751
3752         if (spa_version(ds->ds_dir->dd_pool->dp_spa) < SPA_VERSION_USERREFS)
3753                 return (ENOTSUP);
3754
3755         error = dsl_dataset_release_might_destroy(ds, ra->htag, &might_destroy);
3756         if (error)
3757                 return (error);
3758
3759         if (might_destroy) {
3760                 struct dsl_ds_destroyarg dsda = {0};
3761
3762                 if (dmu_tx_is_syncing(tx)) {
3763                         /*
3764                          * If we're not prepared to remove the snapshot,
3765                          * we can't allow the release to happen right now.
3766                          */
3767                         if (!ra->own)
3768                                 return (EBUSY);
3769                 }
3770                 dsda.ds = ds;
3771                 dsda.releasing = B_TRUE;
3772                 return (dsl_dataset_destroy_check(&dsda, tag, tx));
3773         }
3774
3775         return (0);
3776 }
3777
3778 static void
3779 dsl_dataset_user_release_sync(void *arg1, void *tag, dmu_tx_t *tx)
3780 {
3781         struct dsl_ds_releasearg *ra = arg1;
3782         dsl_dataset_t *ds = ra->ds;
3783         dsl_pool_t *dp = ds->ds_dir->dd_pool;
3784         objset_t *mos = dp->dp_meta_objset;
3785         uint64_t zapobj;
3786         uint64_t dsobj = ds->ds_object;
3787         uint64_t refs;
3788         int error;
3789
3790         mutex_enter(&ds->ds_lock);
3791         ds->ds_userrefs--;
3792         refs = ds->ds_userrefs;
3793         mutex_exit(&ds->ds_lock);
3794         error = dsl_pool_user_release(dp, ds->ds_object, ra->htag, tx);
3795         VERIFY(error == 0 || error == ENOENT);
3796         zapobj = ds->ds_phys->ds_userrefs_obj;
3797         VERIFY(0 == zap_remove(mos, zapobj, ra->htag, tx));
3798         if (ds->ds_userrefs == 0 && ds->ds_phys->ds_num_children == 1 &&
3799             DS_IS_DEFER_DESTROY(ds)) {
3800                 struct dsl_ds_destroyarg dsda = {0};
3801
3802                 ASSERT(ra->own);
3803                 dsda.ds = ds;
3804                 dsda.releasing = B_TRUE;
3805                 /* We already did the destroy_check */
3806                 dsl_dataset_destroy_sync(&dsda, tag, tx);
3807         }
3808
3809         spa_history_log_internal(LOG_DS_USER_RELEASE,
3810             dp->dp_spa, tx, "<%s> %lld dataset = %llu",
3811             ra->htag, (longlong_t)refs, dsobj);
3812 }
3813
3814 static int
3815 dsl_dataset_user_release_one(const char *dsname, void *arg)
3816 {
3817         struct dsl_ds_holdarg *ha = arg;
3818         struct dsl_ds_releasearg *ra;
3819         dsl_dataset_t *ds;
3820         int error;
3821         void *dtag = ha->dstg;
3822         char *name;
3823         boolean_t own = B_FALSE;
3824         boolean_t might_destroy;
3825
3826         /* alloc a buffer to hold dsname@snapname, plus the terminating NULL */
3827         name = kmem_asprintf("%s@%s", dsname, ha->snapname);
3828         error = dsl_dataset_hold(name, dtag, &ds);
3829         strfree(name);
3830         if (error == ENOENT && ha->recursive)
3831                 return (0);
3832         (void) strlcpy(ha->failed, dsname, sizeof (ha->failed));
3833         if (error)
3834                 return (error);
3835
3836         ha->gotone = B_TRUE;
3837
3838         ASSERT(dsl_dataset_is_snapshot(ds));
3839
3840         error = dsl_dataset_release_might_destroy(ds, ha->htag, &might_destroy);
3841         if (error) {
3842                 dsl_dataset_rele(ds, dtag);
3843                 return (error);
3844         }
3845
3846         if (might_destroy) {
3847 #ifdef _KERNEL
3848                 name = kmem_asprintf("%s@%s", dsname, ha->snapname);
3849                 error = zfs_unmount_snap(name, NULL);
3850                 strfree(name);
3851                 if (error) {
3852                         dsl_dataset_rele(ds, dtag);
3853                         return (error);
3854                 }
3855 #endif
3856                 if (!dsl_dataset_tryown(ds, B_TRUE, dtag)) {
3857                         dsl_dataset_rele(ds, dtag);
3858                         return (EBUSY);
3859                 } else {
3860                         own = B_TRUE;
3861                         dsl_dataset_make_exclusive(ds, dtag);
3862                 }
3863         }
3864
3865         ra = kmem_alloc(sizeof (struct dsl_ds_releasearg), KM_SLEEP);
3866         ra->ds = ds;
3867         ra->htag = ha->htag;
3868         ra->own = own;
3869         dsl_sync_task_create(ha->dstg, dsl_dataset_user_release_check,
3870             dsl_dataset_user_release_sync, ra, dtag, 0);
3871
3872         return (0);
3873 }
3874
3875 int
3876 dsl_dataset_user_release(char *dsname, char *snapname, char *htag,
3877     boolean_t recursive)
3878 {
3879         struct dsl_ds_holdarg *ha;
3880         dsl_sync_task_t *dst;
3881         spa_t *spa;
3882         int error;
3883
3884 top:
3885         ha = kmem_zalloc(sizeof (struct dsl_ds_holdarg), KM_SLEEP);
3886
3887         (void) strlcpy(ha->failed, dsname, sizeof (ha->failed));
3888
3889         error = spa_open(dsname, &spa, FTAG);
3890         if (error) {
3891                 kmem_free(ha, sizeof (struct dsl_ds_holdarg));
3892                 return (error);
3893         }
3894
3895         ha->dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
3896         ha->htag = htag;
3897         ha->snapname = snapname;
3898         ha->recursive = recursive;
3899         if (recursive) {
3900                 error = dmu_objset_find(dsname, dsl_dataset_user_release_one,
3901                     ha, DS_FIND_CHILDREN);
3902         } else {
3903                 error = dsl_dataset_user_release_one(dsname, ha);
3904         }
3905         if (error == 0)
3906                 error = dsl_sync_task_group_wait(ha->dstg);
3907
3908         for (dst = list_head(&ha->dstg->dstg_tasks); dst;
3909             dst = list_next(&ha->dstg->dstg_tasks, dst)) {
3910                 struct dsl_ds_releasearg *ra = dst->dst_arg1;
3911                 dsl_dataset_t *ds = ra->ds;
3912
3913                 if (dst->dst_err)
3914                         dsl_dataset_name(ds, ha->failed);
3915
3916                 if (ra->own)
3917                         dsl_dataset_disown(ds, ha->dstg);
3918                 else
3919                         dsl_dataset_rele(ds, ha->dstg);
3920
3921                 kmem_free(ra, sizeof (struct dsl_ds_releasearg));
3922         }
3923
3924         if (error == 0 && recursive && !ha->gotone)
3925                 error = ENOENT;
3926
3927         if (error && error != EBUSY)
3928                 (void) strlcpy(dsname, ha->failed, sizeof (ha->failed));
3929
3930         dsl_sync_task_group_destroy(ha->dstg);
3931         kmem_free(ha, sizeof (struct dsl_ds_holdarg));
3932         spa_close(spa, FTAG);
3933
3934         /*
3935          * We can get EBUSY if we were racing with deferred destroy and
3936          * dsl_dataset_user_release_check() hadn't done the necessary
3937          * open context setup.  We can also get EBUSY if we're racing
3938          * with destroy and that thread is the ds_owner.  Either way
3939          * the busy condition should be transient, and we should retry
3940          * the release operation.
3941          */
3942         if (error == EBUSY)
3943                 goto top;
3944
3945         return (error);
3946 }
3947
3948 /*
3949  * Called at spa_load time (with retry == B_FALSE) to release a stale
3950  * temporary user hold. Also called by the onexit code (with retry == B_TRUE).
3951  */
3952 int
3953 dsl_dataset_user_release_tmp(dsl_pool_t *dp, uint64_t dsobj, char *htag,
3954     boolean_t retry)
3955 {
3956         dsl_dataset_t *ds;
3957         char *snap;
3958         char *name;
3959         int namelen;
3960         int error;
3961
3962         do {
3963                 rw_enter(&dp->dp_config_rwlock, RW_READER);
3964                 error = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
3965                 rw_exit(&dp->dp_config_rwlock);
3966                 if (error)
3967                         return (error);
3968                 namelen = dsl_dataset_namelen(ds)+1;
3969                 name = kmem_alloc(namelen, KM_SLEEP);
3970                 dsl_dataset_name(ds, name);
3971                 dsl_dataset_rele(ds, FTAG);
3972
3973                 snap = strchr(name, '@');
3974                 *snap = '\0';
3975                 ++snap;
3976                 error = dsl_dataset_user_release(name, snap, htag, B_FALSE);
3977                 kmem_free(name, namelen);
3978
3979                 /*
3980                  * The object can't have been destroyed because we have a hold,
3981                  * but it might have been renamed, resulting in ENOENT.  Retry
3982                  * if we've been requested to do so.
3983                  *
3984                  * It would be nice if we could use the dsobj all the way
3985                  * through and avoid ENOENT entirely.  But we might need to
3986                  * unmount the snapshot, and there's currently no way to lookup
3987                  * a vfsp using a ZFS object id.
3988                  */
3989         } while ((error == ENOENT) && retry);
3990
3991         return (error);
3992 }
3993
3994 int
3995 dsl_dataset_get_holds(const char *dsname, nvlist_t **nvp)
3996 {
3997         dsl_dataset_t *ds;
3998         int err;
3999
4000         err = dsl_dataset_hold(dsname, FTAG, &ds);
4001         if (err)
4002                 return (err);
4003
4004         VERIFY(0 == nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP));
4005         if (ds->ds_phys->ds_userrefs_obj != 0) {
4006                 zap_attribute_t *za;
4007                 zap_cursor_t zc;
4008
4009                 za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);
4010                 for (zap_cursor_init(&zc, ds->ds_dir->dd_pool->dp_meta_objset,
4011                     ds->ds_phys->ds_userrefs_obj);
4012                     zap_cursor_retrieve(&zc, za) == 0;
4013                     zap_cursor_advance(&zc)) {
4014                         VERIFY(0 == nvlist_add_uint64(*nvp, za->za_name,
4015                             za->za_first_integer));
4016                 }
4017                 zap_cursor_fini(&zc);
4018                 kmem_free(za, sizeof (zap_attribute_t));
4019         }
4020         dsl_dataset_rele(ds, FTAG);
4021         return (0);
4022 }
4023
4024 /*
4025  * Note, this fuction is used as the callback for dmu_objset_find().  We
4026  * always return 0 so that we will continue to find and process
4027  * inconsistent datasets, even if we encounter an error trying to
4028  * process one of them.
4029  */
4030 /* ARGSUSED */
4031 int
4032 dsl_destroy_inconsistent(const char *dsname, void *arg)
4033 {
4034         dsl_dataset_t *ds;
4035
4036         if (dsl_dataset_own(dsname, B_TRUE, FTAG, &ds) == 0) {
4037                 if (DS_IS_INCONSISTENT(ds))
4038                         (void) dsl_dataset_destroy(ds, FTAG, B_FALSE);
4039                 else
4040                         dsl_dataset_disown(ds, FTAG);
4041         }
4042         return (0);
4043 }
4044
4045 #if defined(_KERNEL) && defined(HAVE_SPL)
4046 EXPORT_SYMBOL(dsl_dataset_hold);
4047 EXPORT_SYMBOL(dsl_dataset_hold_obj);
4048 EXPORT_SYMBOL(dsl_dataset_own);
4049 EXPORT_SYMBOL(dsl_dataset_own_obj);
4050 EXPORT_SYMBOL(dsl_dataset_name);
4051 EXPORT_SYMBOL(dsl_dataset_rele);
4052 EXPORT_SYMBOL(dsl_dataset_disown);
4053 EXPORT_SYMBOL(dsl_dataset_drop_ref);
4054 EXPORT_SYMBOL(dsl_dataset_tryown);
4055 EXPORT_SYMBOL(dsl_dataset_make_exclusive);
4056 EXPORT_SYMBOL(dsl_dataset_create_sync);
4057 EXPORT_SYMBOL(dsl_dataset_create_sync_dd);
4058 EXPORT_SYMBOL(dsl_dataset_destroy);
4059 EXPORT_SYMBOL(dsl_snapshots_destroy);
4060 EXPORT_SYMBOL(dsl_dataset_destroy_check);
4061 EXPORT_SYMBOL(dsl_dataset_destroy_sync);
4062 EXPORT_SYMBOL(dsl_dataset_snapshot_check);
4063 EXPORT_SYMBOL(dsl_dataset_snapshot_sync);
4064 EXPORT_SYMBOL(dsl_dataset_rename);
4065 EXPORT_SYMBOL(dsl_dataset_promote);
4066 EXPORT_SYMBOL(dsl_dataset_clone_swap);
4067 EXPORT_SYMBOL(dsl_dataset_user_hold);
4068 EXPORT_SYMBOL(dsl_dataset_user_release);
4069 EXPORT_SYMBOL(dsl_dataset_user_release_tmp);
4070 EXPORT_SYMBOL(dsl_dataset_get_holds);
4071 EXPORT_SYMBOL(dsl_dataset_get_blkptr);
4072 EXPORT_SYMBOL(dsl_dataset_set_blkptr);
4073 EXPORT_SYMBOL(dsl_dataset_get_spa);
4074 EXPORT_SYMBOL(dsl_dataset_modified_since_lastsnap);
4075 EXPORT_SYMBOL(dsl_dataset_sync);
4076 EXPORT_SYMBOL(dsl_dataset_block_born);
4077 EXPORT_SYMBOL(dsl_dataset_block_kill);
4078 EXPORT_SYMBOL(dsl_dataset_block_freeable);
4079 EXPORT_SYMBOL(dsl_dataset_prev_snap_txg);
4080 EXPORT_SYMBOL(dsl_dataset_dirty);
4081 EXPORT_SYMBOL(dsl_dataset_stats);
4082 EXPORT_SYMBOL(dsl_dataset_fast_stat);
4083 EXPORT_SYMBOL(dsl_dataset_space);
4084 EXPORT_SYMBOL(dsl_dataset_fsid_guid);
4085 EXPORT_SYMBOL(dsl_dsobj_to_dsname);
4086 EXPORT_SYMBOL(dsl_dataset_check_quota);
4087 EXPORT_SYMBOL(dsl_dataset_set_quota);
4088 EXPORT_SYMBOL(dsl_dataset_set_quota_sync);
4089 EXPORT_SYMBOL(dsl_dataset_set_reservation);
4090 EXPORT_SYMBOL(dsl_destroy_inconsistent);
4091 #endif