sys/cddl/contrib/opensolaris/uts/common/fs/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  * Portions Copyright (c) 2011 Martin Matuska <mm@FreeBSD.org>
  24  * Copyright (c) 2011, 2015 by Delphix. All rights reserved.
  25  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
  26  * Copyright (c) 2014 RackTop Systems.
  27  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
  28  * Copyright (c) 2014 Integros [integros.com]
  29  * Copyright 2016, OmniTI Computer Consulting, Inc. All rights reserved.
  30  */
  31
  32 #include <sys/dmu_objset.h>
  33 #include <sys/dsl_dataset.h>
  34 #include <sys/dsl_dir.h>
  35 #include <sys/dsl_prop.h>
  36 #include <sys/dsl_synctask.h>
  37 #include <sys/dmu_traverse.h>
  38 #include <sys/dmu_impl.h>
  39 #include <sys/dmu_send.h>
  40 #include <sys/dmu_tx.h>
  41 #include <sys/arc.h>
  42 #include <sys/zio.h>
  43 #include <sys/zap.h>
  44 #include <sys/zfeature.h>
  45 #include <sys/unique.h>
  46 #include <sys/zfs_context.h>
  47 #include <sys/zfs_ioctl.h>
  48 #include <sys/spa.h>
  49 #include <sys/zfs_znode.h>
  50 #include <sys/zfs_onexit.h>
  51 #include <sys/zvol.h>
  52 #include <sys/dsl_scan.h>
  53 #include <sys/dsl_deadlist.h>
  54 #include <sys/dsl_destroy.h>
  55 #include <sys/dsl_userhold.h>
  56 #include <sys/dsl_bookmark.h>
  57 #include <sys/dmu_send.h>
  58 #include <sys/zio_checksum.h>
  59 #include <sys/zio_compress.h>
  60 #include <zfs_fletcher.h>
  61
  62 SYSCTL_DECL(_vfs_zfs);
  63
  64 /*
  65  * The SPA supports block sizes up to 16MB.  However, very large blocks
  66  * can have an impact on i/o latency (e.g. tying up a spinning disk for
  67  * ~300ms), and also potentially on the memory allocator.  Therefore,
  68  * we do not allow the recordsize to be set larger than zfs_max_recordsize
  69  * (default 1MB).  Larger blocks can be created by changing this tunable,
  70  * and pools with larger blocks can always be imported and used, regardless
  71  * of this setting.
  72  */
  73 int zfs_max_recordsize = 1 * 1024 * 1024;
  74 SYSCTL_INT(_vfs_zfs, OID_AUTO, max_recordsize, CTLFLAG_RWTUN,
  75     &zfs_max_recordsize, 0,
  76     "Maximum block size.  Expect dragons when tuning this.");
  77
  78 #define SWITCH64(x, y) \
  79         { \
  80                 uint64_t __tmp = (x); \
  81                 (x) = (y); \
  82                 (y) = __tmp; \
  83         }
  84
  85 #define DS_REF_MAX      (1ULL << 62)
  86
  87 extern inline dsl_dataset_phys_t *dsl_dataset_phys(dsl_dataset_t *ds);
  88
  89 extern int spa_asize_inflation;
  90
  91 /*
  92  * Figure out how much of this delta should be propogated to the dsl_dir
  93  * layer.  If there's a refreservation, that space has already been
  94  * partially accounted for in our ancestors.
  95  */
  96 static int64_t
  97 parent_delta(dsl_dataset_t *ds, int64_t delta)
  98 {
  99         dsl_dataset_phys_t *ds_phys;
 100         uint64_t old_bytes, new_bytes;
 101
 102         if (ds->ds_reserved == 0)
 103                 return (delta);
 104
 105         ds_phys = dsl_dataset_phys(ds);
 106         old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
 107         new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
 108
 109         ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
 110         return (new_bytes - old_bytes);
 111 }
 112
 113 void
 114 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
 115 {
 116         int used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
 117         int compressed = BP_GET_PSIZE(bp);
 118         int uncompressed = BP_GET_UCSIZE(bp);
 119         int64_t delta;
 120
 121         dprintf_bp(bp, "ds=%p", ds);
 122
 123         ASSERT(dmu_tx_is_syncing(tx));
 124         /* It could have been compressed away to nothing */
 125         if (BP_IS_HOLE(bp))
 126                 return;
 127         ASSERT(BP_GET_TYPE(bp) != DMU_OT_NONE);
 128         ASSERT(DMU_OT_IS_VALID(BP_GET_TYPE(bp)));
 129         if (ds == NULL) {
 130                 dsl_pool_mos_diduse_space(tx->tx_pool,
 131                     used, compressed, uncompressed);
 132                 return;
 133         }
 134
 135         dmu_buf_will_dirty(ds->ds_dbuf, tx);
 136         mutex_enter(&ds->ds_lock);
 137         delta = parent_delta(ds, used);
 138         dsl_dataset_phys(ds)->ds_referenced_bytes += used;
 139         dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
 140         dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
 141         dsl_dataset_phys(ds)->ds_unique_bytes += used;
 142
 143         if (BP_GET_LSIZE(bp) > SPA_OLD_MAXBLOCKSIZE) {
 144                 ds->ds_feature_activation_needed[SPA_FEATURE_LARGE_BLOCKS] =
 145                     B_TRUE;
 146         }
 147
 148         spa_feature_t f = zio_checksum_to_feature(BP_GET_CHECKSUM(bp));
 149         if (f != SPA_FEATURE_NONE)
 150                 ds->ds_feature_activation_needed[f] = B_TRUE;
 151
 152         mutex_exit(&ds->ds_lock);
 153         dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD, delta,
 154             compressed, uncompressed, tx);
 155         dsl_dir_transfer_space(ds->ds_dir, used - delta,
 156             DD_USED_REFRSRV, DD_USED_HEAD, NULL);
 157 }
 158
 159 int
 160 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
 161     boolean_t async)
 162 {
 163         int used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
 164         int compressed = BP_GET_PSIZE(bp);
 165         int uncompressed = BP_GET_UCSIZE(bp);
 166
 167         if (BP_IS_HOLE(bp))
 168                 return (0);
 169
 170         ASSERT(dmu_tx_is_syncing(tx));
 171         ASSERT(bp->blk_birth <= tx->tx_txg);
 172
 173         if (ds == NULL) {
 174                 dsl_free(tx->tx_pool, tx->tx_txg, bp);
 175                 dsl_pool_mos_diduse_space(tx->tx_pool,
 176                     -used, -compressed, -uncompressed);
 177                 return (used);
 178         }
 179         ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
 180
 181         ASSERT(!ds->ds_is_snapshot);
 182         dmu_buf_will_dirty(ds->ds_dbuf, tx);
 183
 184         if (bp->blk_birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
 185                 int64_t delta;
 186
 187                 dprintf_bp(bp, "freeing ds=%llu", ds->ds_object);
 188                 dsl_free(tx->tx_pool, tx->tx_txg, bp);
 189
 190                 mutex_enter(&ds->ds_lock);
 191                 ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
 192                     !DS_UNIQUE_IS_ACCURATE(ds));
 193                 delta = parent_delta(ds, -used);
 194                 dsl_dataset_phys(ds)->ds_unique_bytes -= used;
 195                 mutex_exit(&ds->ds_lock);
 196                 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD,
 197                     delta, -compressed, -uncompressed, tx);
 198                 dsl_dir_transfer_space(ds->ds_dir, -used - delta,
 199                     DD_USED_REFRSRV, DD_USED_HEAD, NULL);
 200         } else {
 201                 dprintf_bp(bp, "putting on dead list: %s", "");
 202                 if (async) {
 203                         /*
 204                          * We are here as part of zio's write done callback,
 205                          * which means we're a zio interrupt thread.  We can't
 206                          * call dsl_deadlist_insert() now because it may block
 207                          * waiting for I/O.  Instead, put bp on the deferred
 208                          * queue and let dsl_pool_sync() finish the job.
 209                          */
 210                         bplist_append(&ds->ds_pending_deadlist, bp);
 211                 } else {
 212                         dsl_deadlist_insert(&ds->ds_deadlist, bp, tx);
 213                 }
 214                 ASSERT3U(ds->ds_prev->ds_object, ==,
 215                     dsl_dataset_phys(ds)->ds_prev_snap_obj);
 216                 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
 217                 /* if (bp->blk_birth > prev prev snap txg) prev unique += bs */
 218                 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
 219                     ds->ds_object && bp->blk_birth >
 220                     dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
 221                         dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
 222                         mutex_enter(&ds->ds_prev->ds_lock);
 223                         dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
 224                         mutex_exit(&ds->ds_prev->ds_lock);
 225                 }
 226                 if (bp->blk_birth > ds->ds_dir->dd_origin_txg) {
 227                         dsl_dir_transfer_space(ds->ds_dir, used,
 228                             DD_USED_HEAD, DD_USED_SNAP, tx);
 229                 }
 230         }
 231         mutex_enter(&ds->ds_lock);
 232         ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
 233         dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
 234         ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
 235         dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
 236         ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
 237         dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
 238         mutex_exit(&ds->ds_lock);
 239
 240         return (used);
 241 }
 242
 243 uint64_t
 244 dsl_dataset_prev_snap_txg(dsl_dataset_t *ds)
 245 {
 246         uint64_t trysnap = 0;
 247
 248         if (ds == NULL)
 249                 return (0);
 250         /*
 251          * The snapshot creation could fail, but that would cause an
 252          * incorrect FALSE return, which would only result in an
 253          * overestimation of the amount of space that an operation would
 254          * consume, which is OK.
 255          *
 256          * There's also a small window where we could miss a pending
 257          * snapshot, because we could set the sync task in the quiescing
 258          * phase.  So this should only be used as a guess.
 259          */
 260         if (ds->ds_trysnap_txg >
 261             spa_last_synced_txg(ds->ds_dir->dd_pool->dp_spa))
 262                 trysnap = ds->ds_trysnap_txg;
 263         return (MAX(dsl_dataset_phys(ds)->ds_prev_snap_txg, trysnap));
 264 }
 265
 266 boolean_t
 267 dsl_dataset_block_freeable(dsl_dataset_t *ds, const blkptr_t *bp,
 268     uint64_t blk_birth)
 269 {
 270         if (blk_birth <= dsl_dataset_prev_snap_txg(ds) ||
 271             (bp != NULL && BP_IS_HOLE(bp)))
 272                 return (B_FALSE);
 273
 274         ddt_prefetch(dsl_dataset_get_spa(ds), bp);
 275
 276         return (B_TRUE);
 277 }
 278
 279 static void
 280 dsl_dataset_evict(void *dbu)
 281 {
 282         dsl_dataset_t *ds = dbu;
 283
 284         ASSERT(ds->ds_owner == NULL);
 285
 286         ds->ds_dbuf = NULL;
 287
 288         unique_remove(ds->ds_fsid_guid);
 289
 290         if (ds->ds_objset != NULL)
 291                 dmu_objset_evict(ds->ds_objset);
 292
 293         if (ds->ds_prev) {
 294                 dsl_dataset_rele(ds->ds_prev, ds);
 295                 ds->ds_prev = NULL;
 296         }
 297
 298         bplist_destroy(&ds->ds_pending_deadlist);
 299         if (ds->ds_deadlist.dl_os != NULL)
 300                 dsl_deadlist_close(&ds->ds_deadlist);
 301         if (ds->ds_dir)
 302                 dsl_dir_async_rele(ds->ds_dir, ds);
 303
 304         ASSERT(!list_link_active(&ds->ds_synced_link));
 305
 306         list_destroy(&ds->ds_prop_cbs);
 307         if (mutex_owned(&ds->ds_lock))
 308                 mutex_exit(&ds->ds_lock);
 309         mutex_destroy(&ds->ds_lock);
 310         if (mutex_owned(&ds->ds_opening_lock))
 311                 mutex_exit(&ds->ds_opening_lock);
 312         mutex_destroy(&ds->ds_opening_lock);
 313         mutex_destroy(&ds->ds_sendstream_lock);
 314         refcount_destroy(&ds->ds_longholds);
 315
 316         kmem_free(ds, sizeof (dsl_dataset_t));
 317 }
 318
 319 int
 320 dsl_dataset_get_snapname(dsl_dataset_t *ds)
 321 {
 322         dsl_dataset_phys_t *headphys;
 323         int err;
 324         dmu_buf_t *headdbuf;
 325         dsl_pool_t *dp = ds->ds_dir->dd_pool;
 326         objset_t *mos = dp->dp_meta_objset;
 327
 328         if (ds->ds_snapname[0])
 329                 return (0);
 330         if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
 331                 return (0);
 332
 333         err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
 334             FTAG, &headdbuf);
 335         if (err != 0)
 336                 return (err);
 337         headphys = headdbuf->db_data;
 338         err = zap_value_search(dp->dp_meta_objset,
 339             headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
 340         dmu_buf_rele(headdbuf, FTAG);
 341         return (err);
 342 }
 343
 344 int
 345 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
 346 {
 347         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 348         uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
 349         matchtype_t mt;
 350         int err;
 351
 352         if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
 353                 mt = MT_FIRST;
 354         else
 355                 mt = MT_EXACT;
 356
 357         err = zap_lookup_norm(mos, snapobj, name, 8, 1,
 358             value, mt, NULL, 0, NULL);
 359         if (err == ENOTSUP && mt == MT_FIRST)
 360                 err = zap_lookup(mos, snapobj, name, 8, 1, value);
 361         return (err);
 362 }
 363
 364 int
 365 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
 366     boolean_t adj_cnt)
 367 {
 368         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 369         uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
 370         matchtype_t mt;
 371         int err;
 372
 373         dsl_dir_snap_cmtime_update(ds->ds_dir);
 374
 375         if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
 376                 mt = MT_FIRST;
 377         else
 378                 mt = MT_EXACT;
 379
 380         err = zap_remove_norm(mos, snapobj, name, mt, tx);
 381         if (err == ENOTSUP && mt == MT_FIRST)
 382                 err = zap_remove(mos, snapobj, name, tx);
 383
 384         if (err == 0 && adj_cnt)
 385                 dsl_fs_ss_count_adjust(ds->ds_dir, -1,
 386                     DD_FIELD_SNAPSHOT_COUNT, tx);
 387
 388         return (err);
 389 }
 390
 391 boolean_t
 392 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, void *tag)
 393 {
 394         dmu_buf_t *dbuf = ds->ds_dbuf;
 395         boolean_t result = B_FALSE;
 396
 397         if (dbuf != NULL && dmu_buf_try_add_ref(dbuf, dp->dp_meta_objset,
 398             ds->ds_object, DMU_BONUS_BLKID, tag)) {
 399
 400                 if (ds == dmu_buf_get_user(dbuf))
 401                         result = B_TRUE;
 402                 else
 403                         dmu_buf_rele(dbuf, tag);
 404         }
 405
 406         return (result);
 407 }
 408
 409 int
 410 dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag,
 411     dsl_dataset_t **dsp)
 412 {
 413         objset_t *mos = dp->dp_meta_objset;
 414         dmu_buf_t *dbuf;
 415         dsl_dataset_t *ds;
 416         int err;
 417         dmu_object_info_t doi;
 418
 419         ASSERT(dsl_pool_config_held(dp));
 420
 421         err = dmu_bonus_hold(mos, dsobj, tag, &dbuf);
 422         if (err != 0)
 423                 return (err);
 424
 425         /* Make sure dsobj has the correct object type. */
 426         dmu_object_info_from_db(dbuf, &doi);
 427         if (doi.doi_bonus_type != DMU_OT_DSL_DATASET) {
 428                 dmu_buf_rele(dbuf, tag);
 429                 return (SET_ERROR(EINVAL));
 430         }
 431
 432         ds = dmu_buf_get_user(dbuf);
 433         if (ds == NULL) {
 434                 dsl_dataset_t *winner = NULL;
 435
 436                 ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
 437                 ds->ds_dbuf = dbuf;
 438                 ds->ds_object = dsobj;
 439                 ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
 440
 441                 mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
 442                 mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
 443                 mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
 444                 refcount_create(&ds->ds_longholds);
 445
 446                 bplist_create(&ds->ds_pending_deadlist);
 447                 dsl_deadlist_open(&ds->ds_deadlist,
 448                     mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
 449
 450                 list_create(&ds->ds_sendstreams, sizeof (dmu_sendarg_t),
 451                     offsetof(dmu_sendarg_t, dsa_link));
 452
 453                 list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
 454                     offsetof(dsl_prop_cb_record_t, cbr_ds_node));
 455
 456                 if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
 457                         for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 458                                 if (!(spa_feature_table[f].fi_flags &
 459                                     ZFEATURE_FLAG_PER_DATASET))
 460                                         continue;
 461                                 err = zap_contains(mos, dsobj,
 462                                     spa_feature_table[f].fi_guid);
 463                                 if (err == 0) {
 464                                         ds->ds_feature_inuse[f] = B_TRUE;
 465                                 } else {
 466                                         ASSERT3U(err, ==, ENOENT);
 467                                         err = 0;
 468                                 }
 469                         }
 470                 }
 471
 472                 err = dsl_dir_hold_obj(dp,
 473                     dsl_dataset_phys(ds)->ds_dir_obj, NULL, ds, &ds->ds_dir);
 474                 if (err != 0) {
 475                         mutex_destroy(&ds->ds_lock);
 476                         mutex_destroy(&ds->ds_opening_lock);
 477                         mutex_destroy(&ds->ds_sendstream_lock);
 478                         refcount_destroy(&ds->ds_longholds);
 479                         bplist_destroy(&ds->ds_pending_deadlist);
 480                         dsl_deadlist_close(&ds->ds_deadlist);
 481                         kmem_free(ds, sizeof (dsl_dataset_t));
 482                         dmu_buf_rele(dbuf, tag);
 483                         return (err);
 484                 }
 485
 486                 if (!ds->ds_is_snapshot) {
 487                         ds->ds_snapname[0] = '\0';
 488                         if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
 489                                 err = dsl_dataset_hold_obj(dp,
 490                                     dsl_dataset_phys(ds)->ds_prev_snap_obj,
 491                                     ds, &ds->ds_prev);
 492                         }
 493                         if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
 494                                 int zaperr = zap_lookup(mos, ds->ds_object,
 495                                     DS_FIELD_BOOKMARK_NAMES,
 496                                     sizeof (ds->ds_bookmarks), 1,
 497                                     &ds->ds_bookmarks);
 498                                 if (zaperr != ENOENT)
 499                                         VERIFY0(zaperr);
 500                         }
 501                 } else {
 502                         if (zfs_flags & ZFS_DEBUG_SNAPNAMES)
 503                                 err = dsl_dataset_get_snapname(ds);
 504                         if (err == 0 &&
 505                             dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
 506                                 err = zap_count(
 507                                     ds->ds_dir->dd_pool->dp_meta_objset,
 508                                     dsl_dataset_phys(ds)->ds_userrefs_obj,
 509                                     &ds->ds_userrefs);
 510                         }
 511                 }
 512
 513                 if (err == 0 && !ds->ds_is_snapshot) {
 514                         err = dsl_prop_get_int_ds(ds,
 515                             zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
 516                             &ds->ds_reserved);
 517                         if (err == 0) {
 518                                 err = dsl_prop_get_int_ds(ds,
 519                                     zfs_prop_to_name(ZFS_PROP_REFQUOTA),
 520                                     &ds->ds_quota);
 521                         }
 522                 } else {
 523                         ds->ds_reserved = ds->ds_quota = 0;
 524                 }
 525
 526                 dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict, &ds->ds_dbuf);
 527                 if (err == 0)
 528                         winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
 529
 530                 if (err != 0 || winner != NULL) {
 531                         bplist_destroy(&ds->ds_pending_deadlist);
 532                         dsl_deadlist_close(&ds->ds_deadlist);
 533                         if (ds->ds_prev)
 534                                 dsl_dataset_rele(ds->ds_prev, ds);
 535                         dsl_dir_rele(ds->ds_dir, ds);
 536                         mutex_destroy(&ds->ds_lock);
 537                         mutex_destroy(&ds->ds_opening_lock);
 538                         mutex_destroy(&ds->ds_sendstream_lock);
 539                         refcount_destroy(&ds->ds_longholds);
 540                         kmem_free(ds, sizeof (dsl_dataset_t));
 541                         if (err != 0) {
 542                                 dmu_buf_rele(dbuf, tag);
 543                                 return (err);
 544                         }
 545                         ds = winner;
 546                 } else {
 547                         ds->ds_fsid_guid =
 548                             unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
 549                 }
 550         }
 551         ASSERT3P(ds->ds_dbuf, ==, dbuf);
 552         ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
 553         ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
 554             spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
 555             dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
 556         *dsp = ds;
 557         return (0);
 558 }
 559
 560 int
 561 dsl_dataset_hold(dsl_pool_t *dp, const char *name,
 562     void *tag, dsl_dataset_t **dsp)
 563 {
 564         dsl_dir_t *dd;
 565         const char *snapname;
 566         uint64_t obj;
 567         int err = 0;
 568         dsl_dataset_t *ds;
 569
 570         err = dsl_dir_hold(dp, name, FTAG, &dd, &snapname);
 571         if (err != 0)
 572                 return (err);
 573
 574         ASSERT(dsl_pool_config_held(dp));
 575         obj = dsl_dir_phys(dd)->dd_head_dataset_obj;
 576         if (obj != 0)
 577                 err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
 578         else
 579                 err = SET_ERROR(ENOENT);
 580
 581         /* we may be looking for a snapshot */
 582         if (err == 0 && snapname != NULL) {
 583                 dsl_dataset_t *snap_ds;
 584
 585                 if (*snapname++ != '@') {
 586                         dsl_dataset_rele(ds, tag);
 587                         dsl_dir_rele(dd, FTAG);
 588                         return (SET_ERROR(ENOENT));
 589                 }
 590
 591                 dprintf("looking for snapshot '%s'\n", snapname);
 592                 err = dsl_dataset_snap_lookup(ds, snapname, &obj);
 593                 if (err == 0)
 594                         err = dsl_dataset_hold_obj(dp, obj, tag, &snap_ds);
 595                 dsl_dataset_rele(ds, tag);
 596
 597                 if (err == 0) {
 598                         mutex_enter(&snap_ds->ds_lock);
 599                         if (snap_ds->ds_snapname[0] == 0)
 600                                 (void) strlcpy(snap_ds->ds_snapname, snapname,
 601                                     sizeof (snap_ds->ds_snapname));
 602                         mutex_exit(&snap_ds->ds_lock);
 603                         ds = snap_ds;
 604                 }
 605         }
 606         if (err == 0)
 607                 *dsp = ds;
 608         dsl_dir_rele(dd, FTAG);
 609         return (err);
 610 }
 611
 612 int
 613 dsl_dataset_own_obj(dsl_pool_t *dp, uint64_t dsobj,
 614     void *tag, dsl_dataset_t **dsp)
 615 {
 616         int err = dsl_dataset_hold_obj(dp, dsobj, tag, dsp);
 617         if (err != 0)
 618                 return (err);
 619         if (!dsl_dataset_tryown(*dsp, tag)) {
 620                 dsl_dataset_rele(*dsp, tag);
 621                 *dsp = NULL;
 622                 return (SET_ERROR(EBUSY));
 623         }
 624         return (0);
 625 }
 626
 627 int
 628 dsl_dataset_own(dsl_pool_t *dp, const char *name,
 629     void *tag, dsl_dataset_t **dsp)
 630 {
 631         int err = dsl_dataset_hold(dp, name, tag, dsp);
 632         if (err != 0)
 633                 return (err);
 634         if (!dsl_dataset_tryown(*dsp, tag)) {
 635                 dsl_dataset_rele(*dsp, tag);
 636                 return (SET_ERROR(EBUSY));
 637         }
 638         return (0);
 639 }
 640
 641 /*
 642  * See the comment above dsl_pool_hold() for details.  In summary, a long
 643  * hold is used to prevent destruction of a dataset while the pool hold
 644  * is dropped, allowing other concurrent operations (e.g. spa_sync()).
 645  *
 646  * The dataset and pool must be held when this function is called.  After it
 647  * is called, the pool hold may be released while the dataset is still held
 648  * and accessed.
 649  */
 650 void
 651 dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag)
 652 {
 653         ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
 654         (void) refcount_add(&ds->ds_longholds, tag);
 655 }
 656
 657 void
 658 dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag)
 659 {
 660         (void) refcount_remove(&ds->ds_longholds, tag);
 661 }
 662
 663 /* Return B_TRUE if there are any long holds on this dataset. */
 664 boolean_t
 665 dsl_dataset_long_held(dsl_dataset_t *ds)
 666 {
 667         return (!refcount_is_zero(&ds->ds_longholds));
 668 }
 669
 670 void
 671 dsl_dataset_name(dsl_dataset_t *ds, char *name)
 672 {
 673         if (ds == NULL) {
 674                 (void) strcpy(name, "mos");
 675         } else {
 676                 dsl_dir_name(ds->ds_dir, name);
 677                 VERIFY0(dsl_dataset_get_snapname(ds));
 678                 if (ds->ds_snapname[0]) {
 679                         (void) strcat(name, "@");
 680                         /*
 681                          * We use a "recursive" mutex so that we
 682                          * can call dprintf_ds() with ds_lock held.
 683                          */
 684                         if (!MUTEX_HELD(&ds->ds_lock)) {
 685                                 mutex_enter(&ds->ds_lock);
 686                                 (void) strcat(name, ds->ds_snapname);
 687                                 mutex_exit(&ds->ds_lock);
 688                         } else {
 689                                 (void) strcat(name, ds->ds_snapname);
 690                         }
 691                 }
 692         }
 693 }
 694
 695 void
 696 dsl_dataset_rele(dsl_dataset_t *ds, void *tag)
 697 {
 698         dmu_buf_rele(ds->ds_dbuf, tag);
 699 }
 700
 701 void
 702 dsl_dataset_disown(dsl_dataset_t *ds, void *tag)
 703 {
 704         ASSERT3P(ds->ds_owner, ==, tag);
 705         ASSERT(ds->ds_dbuf != NULL);
 706
 707         mutex_enter(&ds->ds_lock);
 708         ds->ds_owner = NULL;
 709         mutex_exit(&ds->ds_lock);
 710         dsl_dataset_long_rele(ds, tag);
 711         dsl_dataset_rele(ds, tag);
 712 }
 713
 714 boolean_t
 715 dsl_dataset_tryown(dsl_dataset_t *ds, void *tag)
 716 {
 717         boolean_t gotit = FALSE;
 718
 719         ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
 720         mutex_enter(&ds->ds_lock);
 721         if (ds->ds_owner == NULL && !DS_IS_INCONSISTENT(ds)) {
 722                 ds->ds_owner = tag;
 723                 dsl_dataset_long_hold(ds, tag);
 724                 gotit = TRUE;
 725         }
 726         mutex_exit(&ds->ds_lock);
 727         return (gotit);
 728 }
 729
 730 boolean_t
 731 dsl_dataset_has_owner(dsl_dataset_t *ds)
 732 {
 733         boolean_t rv;
 734         mutex_enter(&ds->ds_lock);
 735         rv = (ds->ds_owner != NULL);
 736         mutex_exit(&ds->ds_lock);
 737         return (rv);
 738 }
 739
 740 static void
 741 dsl_dataset_activate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
 742 {
 743         spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 744         objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
 745         uint64_t zero = 0;
 746
 747         VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
 748
 749         spa_feature_incr(spa, f, tx);
 750         dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
 751
 752         VERIFY0(zap_add(mos, dsobj, spa_feature_table[f].fi_guid,
 753             sizeof (zero), 1, &zero, tx));
 754 }
 755
 756 void
 757 dsl_dataset_deactivate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
 758 {
 759         spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 760         objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
 761
 762         VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
 763
 764         VERIFY0(zap_remove(mos, dsobj, spa_feature_table[f].fi_guid, tx));
 765         spa_feature_decr(spa, f, tx);
 766 }
 767
 768 uint64_t
 769 dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
 770     uint64_t flags, dmu_tx_t *tx)
 771 {
 772         dsl_pool_t *dp = dd->dd_pool;
 773         dmu_buf_t *dbuf;
 774         dsl_dataset_phys_t *dsphys;
 775         uint64_t dsobj;
 776         objset_t *mos = dp->dp_meta_objset;
 777
 778         if (origin == NULL)
 779                 origin = dp->dp_origin_snap;
 780
 781         ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
 782         ASSERT(origin == NULL || dsl_dataset_phys(origin)->ds_num_children > 0);
 783         ASSERT(dmu_tx_is_syncing(tx));
 784         ASSERT(dsl_dir_phys(dd)->dd_head_dataset_obj == 0);
 785
 786         dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
 787             DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
 788         VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
 789         dmu_buf_will_dirty(dbuf, tx);
 790         dsphys = dbuf->db_data;
 791         bzero(dsphys, sizeof (dsl_dataset_phys_t));
 792         dsphys->ds_dir_obj = dd->dd_object;
 793         dsphys->ds_flags = flags;
 794         dsphys->ds_fsid_guid = unique_create();
 795         do {
 796                 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
 797                     sizeof (dsphys->ds_guid));
 798         } while (dsphys->ds_guid == 0);
 799         dsphys->ds_snapnames_zapobj =
 800             zap_create_norm(mos, U8_TEXTPREP_TOUPPER, DMU_OT_DSL_DS_SNAP_MAP,
 801             DMU_OT_NONE, 0, tx);
 802         dsphys->ds_creation_time = gethrestime_sec();
 803         dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
 804
 805         if (origin == NULL) {
 806                 dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
 807         } else {
 808                 dsl_dataset_t *ohds; /* head of the origin snapshot */
 809
 810                 dsphys->ds_prev_snap_obj = origin->ds_object;
 811                 dsphys->ds_prev_snap_txg =
 812                     dsl_dataset_phys(origin)->ds_creation_txg;
 813                 dsphys->ds_referenced_bytes =
 814                     dsl_dataset_phys(origin)->ds_referenced_bytes;
 815                 dsphys->ds_compressed_bytes =
 816                     dsl_dataset_phys(origin)->ds_compressed_bytes;
 817                 dsphys->ds_uncompressed_bytes =
 818                     dsl_dataset_phys(origin)->ds_uncompressed_bytes;
 819                 dsphys->ds_bp = dsl_dataset_phys(origin)->ds_bp;
 820
 821                 /*
 822                  * Inherit flags that describe the dataset's contents
 823                  * (INCONSISTENT) or properties (Case Insensitive).
 824                  */
 825                 dsphys->ds_flags |= dsl_dataset_phys(origin)->ds_flags &
 826                     (DS_FLAG_INCONSISTENT | DS_FLAG_CI_DATASET);
 827
 828                 for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 829                         if (origin->ds_feature_inuse[f])
 830                                 dsl_dataset_activate_feature(dsobj, f, tx);
 831                 }
 832
 833                 dmu_buf_will_dirty(origin->ds_dbuf, tx);
 834                 dsl_dataset_phys(origin)->ds_num_children++;
 835
 836                 VERIFY0(dsl_dataset_hold_obj(dp,
 837                     dsl_dir_phys(origin->ds_dir)->dd_head_dataset_obj,
 838                     FTAG, &ohds));
 839                 dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
 840                     dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
 841                 dsl_dataset_rele(ohds, FTAG);
 842
 843                 if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
 844                         if (dsl_dataset_phys(origin)->ds_next_clones_obj == 0) {
 845                                 dsl_dataset_phys(origin)->ds_next_clones_obj =
 846                                     zap_create(mos,
 847                                     DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
 848                         }
 849                         VERIFY0(zap_add_int(mos,
 850                             dsl_dataset_phys(origin)->ds_next_clones_obj,
 851                             dsobj, tx));
 852                 }
 853
 854                 dmu_buf_will_dirty(dd->dd_dbuf, tx);
 855                 dsl_dir_phys(dd)->dd_origin_obj = origin->ds_object;
 856                 if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
 857                         if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
 858                                 dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
 859                                 dsl_dir_phys(origin->ds_dir)->dd_clones =
 860                                     zap_create(mos,
 861                                     DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
 862                         }
 863                         VERIFY0(zap_add_int(mos,
 864                             dsl_dir_phys(origin->ds_dir)->dd_clones,
 865                             dsobj, tx));
 866                 }
 867         }
 868
 869         if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
 870                 dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
 871
 872         dmu_buf_rele(dbuf, FTAG);
 873
 874         dmu_buf_will_dirty(dd->dd_dbuf, tx);
 875         dsl_dir_phys(dd)->dd_head_dataset_obj = dsobj;
 876
 877         return (dsobj);
 878 }
 879
 880 static void
 881 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
 882 {
 883         objset_t *os;
 884
 885         VERIFY0(dmu_objset_from_ds(ds, &os));
 886         bzero(&os->os_zil_header, sizeof (os->os_zil_header));
 887         dsl_dataset_dirty(ds, tx);
 888 }
 889
 890 uint64_t
 891 dsl_dataset_create_sync(dsl_dir_t *pdd, const char *lastname,
 892     dsl_dataset_t *origin, uint64_t flags, cred_t *cr, dmu_tx_t *tx)
 893 {
 894         dsl_pool_t *dp = pdd->dd_pool;
 895         uint64_t dsobj, ddobj;
 896         dsl_dir_t *dd;
 897
 898         ASSERT(dmu_tx_is_syncing(tx));
 899         ASSERT(lastname[0] != '@');
 900
 901         ddobj = dsl_dir_create_sync(dp, pdd, lastname, tx);
 902         VERIFY0(dsl_dir_hold_obj(dp, ddobj, lastname, FTAG, &dd));
 903
 904         dsobj = dsl_dataset_create_sync_dd(dd, origin,
 905             flags & ~DS_CREATE_FLAG_NODIRTY, tx);
 906
 907         dsl_deleg_set_create_perms(dd, tx, cr);
 908
 909         /*
 910          * Since we're creating a new node we know it's a leaf, so we can
 911          * initialize the counts if the limit feature is active.
 912          */
 913         if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_FS_SS_LIMIT)) {
 914                 uint64_t cnt = 0;
 915                 objset_t *os = dd->dd_pool->dp_meta_objset;
 916
 917                 dsl_dir_zapify(dd, tx);
 918                 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_FILESYSTEM_COUNT,
 919                     sizeof (cnt), 1, &cnt, tx));
 920                 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_SNAPSHOT_COUNT,
 921                     sizeof (cnt), 1, &cnt, tx));
 922         }
 923
 924         dsl_dir_rele(dd, FTAG);
 925
 926         /*
 927          * If we are creating a clone, make sure we zero out any stale
 928          * data from the origin snapshots zil header.
 929          */
 930         if (origin != NULL && !(flags & DS_CREATE_FLAG_NODIRTY)) {
 931                 dsl_dataset_t *ds;
 932
 933                 VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 934                 dsl_dataset_zero_zil(ds, tx);
 935                 dsl_dataset_rele(ds, FTAG);
 936         }
 937
 938         return (dsobj);
 939 }
 940
 941 #ifdef __FreeBSD__
 942 /* FreeBSD ioctl compat begin */
 943 struct destroyarg {
 944         nvlist_t *nvl;
 945         const char *snapname;
 946 };
 947
 948 static int
 949 dsl_check_snap_cb(const char *name, void *arg)
 950 {
 951         struct destroyarg *da = arg;
 952         dsl_dataset_t *ds;
 953         char *dsname;
 954
 955         dsname = kmem_asprintf("%s@%s", name, da->snapname);
 956         fnvlist_add_boolean(da->nvl, dsname);
 957         kmem_free(dsname, strlen(dsname) + 1);
 958
 959         return (0);
 960 }
 961
 962 int
 963 dmu_get_recursive_snaps_nvl(char *fsname, const char *snapname,
 964     nvlist_t *snaps)
 965 {
 966         struct destroyarg *da;
 967         int err;
 968
 969         da = kmem_zalloc(sizeof (struct destroyarg), KM_SLEEP);
 970         da->nvl = snaps;
 971         da->snapname = snapname;
 972         err = dmu_objset_find(fsname, dsl_check_snap_cb, da,
 973             DS_FIND_CHILDREN);
 974         kmem_free(da, sizeof (struct destroyarg));
 975
 976         return (err);
 977 }
 978 /* FreeBSD ioctl compat end */
 979 #endif /* __FreeBSD__ */
 980
 981 /*
 982  * The unique space in the head dataset can be calculated by subtracting
 983  * the space used in the most recent snapshot, that is still being used
 984  * in this file system, from the space currently in use.  To figure out
 985  * the space in the most recent snapshot still in use, we need to take
 986  * the total space used in the snapshot and subtract out the space that
 987  * has been freed up since the snapshot was taken.
 988  */
 989 void
 990 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
 991 {
 992         uint64_t mrs_used;
 993         uint64_t dlused, dlcomp, dluncomp;
 994
 995         ASSERT(!ds->ds_is_snapshot);
 996
 997         if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
 998                 mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
 999         else
1000                 mrs_used = 0;
1001
1002         dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
1003
1004         ASSERT3U(dlused, <=, mrs_used);
1005         dsl_dataset_phys(ds)->ds_unique_bytes =
1006             dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
1007
1008         if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
1009             SPA_VERSION_UNIQUE_ACCURATE)
1010                 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1011 }
1012
1013 void
1014 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
1015     dmu_tx_t *tx)
1016 {
1017         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1018         uint64_t count;
1019         int err;
1020
1021         ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
1022         err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1023             obj, tx);
1024         /*
1025          * The err should not be ENOENT, but a bug in a previous version
1026          * of the code could cause upgrade_clones_cb() to not set
1027          * ds_next_snap_obj when it should, leading to a missing entry.
1028          * If we knew that the pool was created after
1029          * SPA_VERSION_NEXT_CLONES, we could assert that it isn't
1030          * ENOENT.  However, at least we can check that we don't have
1031          * too many entries in the next_clones_obj even after failing to
1032          * remove this one.
1033          */
1034         if (err != ENOENT)
1035                 VERIFY0(err);
1036         ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1037             &count));
1038         ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
1039 }
1040
1041
1042 blkptr_t *
1043 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1044 {
1045         return (&dsl_dataset_phys(ds)->ds_bp);
1046 }
1047
1048 void
1049 dsl_dataset_set_blkptr(dsl_dataset_t *ds, blkptr_t *bp, dmu_tx_t *tx)
1050 {
1051         ASSERT(dmu_tx_is_syncing(tx));
1052         /* If it's the meta-objset, set dp_meta_rootbp */
1053         if (ds == NULL) {
1054                 tx->tx_pool->dp_meta_rootbp = *bp;
1055         } else {
1056                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1057                 dsl_dataset_phys(ds)->ds_bp = *bp;
1058         }
1059 }
1060
1061 spa_t *
1062 dsl_dataset_get_spa(dsl_dataset_t *ds)
1063 {
1064         return (ds->ds_dir->dd_pool->dp_spa);
1065 }
1066
1067 void
1068 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1069 {
1070         dsl_pool_t *dp;
1071
1072         if (ds == NULL) /* this is the meta-objset */
1073                 return;
1074
1075         ASSERT(ds->ds_objset != NULL);
1076
1077         if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
1078                 panic("dirtying snapshot!");
1079
1080         dp = ds->ds_dir->dd_pool;
1081
1082         if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
1083                 /* up the hold count until we can be written out */
1084                 dmu_buf_add_ref(ds->ds_dbuf, ds);
1085         }
1086 }
1087
1088 boolean_t
1089 dsl_dataset_is_dirty(dsl_dataset_t *ds)
1090 {
1091         for (int t = 0; t < TXG_SIZE; t++) {
1092                 if (txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1093                     ds, t))
1094                         return (B_TRUE);
1095         }
1096         return (B_FALSE);
1097 }
1098
1099 static int
1100 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1101 {
1102         uint64_t asize;
1103
1104         if (!dmu_tx_is_syncing(tx))
1105                 return (0);
1106
1107         /*
1108          * If there's an fs-only reservation, any blocks that might become
1109          * owned by the snapshot dataset must be accommodated by space
1110          * outside of the reservation.
1111          */
1112         ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1113         asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
1114         if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1115                 return (SET_ERROR(ENOSPC));
1116
1117         /*
1118          * Propagate any reserved space for this snapshot to other
1119          * snapshot checks in this sync group.
1120          */
1121         if (asize > 0)
1122                 dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1123
1124         return (0);
1125 }
1126
1127 typedef struct dsl_dataset_snapshot_arg {
1128         nvlist_t *ddsa_snaps;
1129         nvlist_t *ddsa_props;
1130         nvlist_t *ddsa_errors;
1131         cred_t *ddsa_cr;
1132 } dsl_dataset_snapshot_arg_t;
1133
1134 int
1135 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
1136     dmu_tx_t *tx, boolean_t recv, uint64_t cnt, cred_t *cr)
1137 {
1138         int error;
1139         uint64_t value;
1140
1141         ds->ds_trysnap_txg = tx->tx_txg;
1142
1143         if (!dmu_tx_is_syncing(tx))
1144                 return (0);
1145
1146         /*
1147          * We don't allow multiple snapshots of the same txg.  If there
1148          * is already one, try again.
1149          */
1150         if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1151                 return (SET_ERROR(EAGAIN));
1152
1153         /*
1154          * Check for conflicting snapshot name.
1155          */
1156         error = dsl_dataset_snap_lookup(ds, snapname, &value);
1157         if (error == 0)
1158                 return (SET_ERROR(EEXIST));
1159         if (error != ENOENT)
1160                 return (error);
1161
1162         /*
1163          * We don't allow taking snapshots of inconsistent datasets, such as
1164          * those into which we are currently receiving.  However, if we are
1165          * creating this snapshot as part of a receive, this check will be
1166          * executed atomically with respect to the completion of the receive
1167          * itself but prior to the clearing of DS_FLAG_INCONSISTENT; in this
1168          * case we ignore this, knowing it will be fixed up for us shortly in
1169          * dmu_recv_end_sync().
1170          */
1171         if (!recv && DS_IS_INCONSISTENT(ds))
1172                 return (SET_ERROR(EBUSY));
1173
1174         /*
1175          * Skip the check for temporary snapshots or if we have already checked
1176          * the counts in dsl_dataset_snapshot_check. This means we really only
1177          * check the count here when we're receiving a stream.
1178          */
1179         if (cnt != 0 && cr != NULL) {
1180                 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1181                     ZFS_PROP_SNAPSHOT_LIMIT, NULL, cr);
1182                 if (error != 0)
1183                         return (error);
1184         }
1185
1186         error = dsl_dataset_snapshot_reserve_space(ds, tx);
1187         if (error != 0)
1188                 return (error);
1189
1190         return (0);
1191 }
1192
1193 static int
1194 dsl_dataset_snapshot_check(void *arg, dmu_tx_t *tx)
1195 {
1196         dsl_dataset_snapshot_arg_t *ddsa = arg;
1197         dsl_pool_t *dp = dmu_tx_pool(tx);
1198         nvpair_t *pair;
1199         int rv = 0;
1200
1201         /*
1202          * Pre-compute how many total new snapshots will be created for each
1203          * level in the tree and below. This is needed for validating the
1204          * snapshot limit when either taking a recursive snapshot or when
1205          * taking multiple snapshots.
1206          *
1207          * The problem is that the counts are not actually adjusted when
1208          * we are checking, only when we finally sync. For a single snapshot,
1209          * this is easy, the count will increase by 1 at each node up the tree,
1210          * but its more complicated for the recursive/multiple snapshot case.
1211          *
1212          * The dsl_fs_ss_limit_check function does recursively check the count
1213          * at each level up the tree but since it is validating each snapshot
1214          * independently we need to be sure that we are validating the complete
1215          * count for the entire set of snapshots. We do this by rolling up the
1216          * counts for each component of the name into an nvlist and then
1217          * checking each of those cases with the aggregated count.
1218          *
1219          * This approach properly handles not only the recursive snapshot
1220          * case (where we get all of those on the ddsa_snaps list) but also
1221          * the sibling case (e.g. snapshot a/b and a/c so that we will also
1222          * validate the limit on 'a' using a count of 2).
1223          *
1224          * We validate the snapshot names in the third loop and only report
1225          * name errors once.
1226          */
1227         if (dmu_tx_is_syncing(tx)) {
1228                 nvlist_t *cnt_track = NULL;
1229                 cnt_track = fnvlist_alloc();
1230
1231                 /* Rollup aggregated counts into the cnt_track list */
1232                 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1233                     pair != NULL;
1234                     pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1235                         char *pdelim;
1236                         uint64_t val;
1237                         char nm[MAXPATHLEN];
1238
1239                         (void) strlcpy(nm, nvpair_name(pair), sizeof (nm));
1240                         pdelim = strchr(nm, '@');
1241                         if (pdelim == NULL)
1242                                 continue;
1243                         *pdelim = '\0';
1244
1245                         do {
1246                                 if (nvlist_lookup_uint64(cnt_track, nm,
1247                                     &val) == 0) {
1248                                         /* update existing entry */
1249                                         fnvlist_add_uint64(cnt_track, nm,
1250                                             val + 1);
1251                                 } else {
1252                                         /* add to list */
1253                                         fnvlist_add_uint64(cnt_track, nm, 1);
1254                                 }
1255
1256                                 pdelim = strrchr(nm, '/');
1257                                 if (pdelim != NULL)
1258                                         *pdelim = '\0';
1259                         } while (pdelim != NULL);
1260                 }
1261
1262                 /* Check aggregated counts at each level */
1263                 for (pair = nvlist_next_nvpair(cnt_track, NULL);
1264                     pair != NULL; pair = nvlist_next_nvpair(cnt_track, pair)) {
1265                         int error = 0;
1266                         char *name;
1267                         uint64_t cnt = 0;
1268                         dsl_dataset_t *ds;
1269
1270                         name = nvpair_name(pair);
1271                         cnt = fnvpair_value_uint64(pair);
1272                         ASSERT(cnt > 0);
1273
1274                         error = dsl_dataset_hold(dp, name, FTAG, &ds);
1275                         if (error == 0) {
1276                                 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1277                                     ZFS_PROP_SNAPSHOT_LIMIT, NULL,
1278                                     ddsa->ddsa_cr);
1279                                 dsl_dataset_rele(ds, FTAG);
1280                         }
1281
1282                         if (error != 0) {
1283                                 if (ddsa->ddsa_errors != NULL)
1284                                         fnvlist_add_int32(ddsa->ddsa_errors,
1285                                             name, error);
1286                                 rv = error;
1287                                 /* only report one error for this check */
1288                                 break;
1289                         }
1290                 }
1291                 nvlist_free(cnt_track);
1292         }
1293
1294         for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1295             pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1296                 int error = 0;
1297                 dsl_dataset_t *ds;
1298                 char *name, *atp;
1299                 char dsname[MAXNAMELEN];
1300
1301                 name = nvpair_name(pair);
1302                 if (strlen(name) >= MAXNAMELEN)
1303                         error = SET_ERROR(ENAMETOOLONG);
1304                 if (error == 0) {
1305                         atp = strchr(name, '@');
1306                         if (atp == NULL)
1307                                 error = SET_ERROR(EINVAL);
1308                         if (error == 0)
1309                                 (void) strlcpy(dsname, name, atp - name + 1);
1310                 }
1311                 if (error == 0)
1312                         error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
1313                 if (error == 0) {
1314                         /* passing 0/NULL skips dsl_fs_ss_limit_check */
1315                         error = dsl_dataset_snapshot_check_impl(ds,
1316                             atp + 1, tx, B_FALSE, 0, NULL);
1317                         dsl_dataset_rele(ds, FTAG);
1318                 }
1319
1320                 if (error != 0) {
1321                         if (ddsa->ddsa_errors != NULL) {
1322                                 fnvlist_add_int32(ddsa->ddsa_errors,
1323                                     name, error);
1324                         }
1325                         rv = error;
1326                 }
1327         }
1328
1329         return (rv);
1330 }
1331
1332 void
1333 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
1334     dmu_tx_t *tx)
1335 {
1336         static zil_header_t zero_zil;
1337
1338         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1339         dmu_buf_t *dbuf;
1340         dsl_dataset_phys_t *dsphys;
1341         uint64_t dsobj, crtxg;
1342         objset_t *mos = dp->dp_meta_objset;
1343         objset_t *os;
1344
1345         ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
1346
1347         /*
1348          * If we are on an old pool, the zil must not be active, in which
1349          * case it will be zeroed.  Usually zil_suspend() accomplishes this.
1350          */
1351         ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP ||
1352             dmu_objset_from_ds(ds, &os) != 0 ||
1353             bcmp(&os->os_phys->os_zil_header, &zero_zil,
1354             sizeof (zero_zil)) == 0);
1355
1356         dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
1357
1358         /*
1359          * The origin's ds_creation_txg has to be < TXG_INITIAL
1360          */
1361         if (strcmp(snapname, ORIGIN_DIR_NAME) == 0)
1362                 crtxg = 1;
1363         else
1364                 crtxg = tx->tx_txg;
1365
1366         dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
1367             DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
1368         VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
1369         dmu_buf_will_dirty(dbuf, tx);
1370         dsphys = dbuf->db_data;
1371         bzero(dsphys, sizeof (dsl_dataset_phys_t));
1372         dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1373         dsphys->ds_fsid_guid = unique_create();
1374         do {
1375                 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
1376                     sizeof (dsphys->ds_guid));
1377         } while (dsphys->ds_guid == 0);
1378         dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1379         dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
1380         dsphys->ds_next_snap_obj = ds->ds_object;
1381         dsphys->ds_num_children = 1;
1382         dsphys->ds_creation_time = gethrestime_sec();
1383         dsphys->ds_creation_txg = crtxg;
1384         dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
1385         dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
1386         dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
1387         dsphys->ds_uncompressed_bytes =
1388             dsl_dataset_phys(ds)->ds_uncompressed_bytes;
1389         dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
1390         dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
1391         dmu_buf_rele(dbuf, FTAG);
1392
1393         for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1394                 if (ds->ds_feature_inuse[f])
1395                         dsl_dataset_activate_feature(dsobj, f, tx);
1396         }
1397
1398         ASSERT3U(ds->ds_prev != 0, ==,
1399             dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
1400         if (ds->ds_prev) {
1401                 uint64_t next_clones_obj =
1402                     dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
1403                 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1404                     ds->ds_object ||
1405                     dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
1406                 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1407                     ds->ds_object) {
1408                         dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1409                         ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
1410                             dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
1411                         dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
1412                 } else if (next_clones_obj != 0) {
1413                         dsl_dataset_remove_from_next_clones(ds->ds_prev,
1414                             dsphys->ds_next_snap_obj, tx);
1415                         VERIFY0(zap_add_int(mos,
1416                             next_clones_obj, dsobj, tx));
1417                 }
1418         }
1419
1420         /*
1421          * If we have a reference-reservation on this dataset, we will
1422          * need to increase the amount of refreservation being charged
1423          * since our unique space is going to zero.
1424          */
1425         if (ds->ds_reserved) {
1426                 int64_t delta;
1427                 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
1428                 delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
1429                     ds->ds_reserved);
1430                 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
1431                     delta, 0, 0, tx);
1432         }
1433
1434         dmu_buf_will_dirty(ds->ds_dbuf, tx);
1435         dsl_dataset_phys(ds)->ds_deadlist_obj =
1436             dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
1437             dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
1438         dsl_deadlist_close(&ds->ds_deadlist);
1439         dsl_deadlist_open(&ds->ds_deadlist, mos,
1440             dsl_dataset_phys(ds)->ds_deadlist_obj);
1441         dsl_deadlist_add_key(&ds->ds_deadlist,
1442             dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
1443
1444         ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
1445         dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
1446         dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
1447         dsl_dataset_phys(ds)->ds_unique_bytes = 0;
1448         if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
1449                 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1450
1451         VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
1452             snapname, 8, 1, &dsobj, tx));
1453
1454         if (ds->ds_prev)
1455                 dsl_dataset_rele(ds->ds_prev, ds);
1456         VERIFY0(dsl_dataset_hold_obj(dp,
1457             dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
1458
1459         dsl_scan_ds_snapshotted(ds, tx);
1460
1461         dsl_dir_snap_cmtime_update(ds->ds_dir);
1462
1463         spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, "");
1464 }
1465
1466 static void
1467 dsl_dataset_snapshot_sync(void *arg, dmu_tx_t *tx)
1468 {
1469         dsl_dataset_snapshot_arg_t *ddsa = arg;
1470         dsl_pool_t *dp = dmu_tx_pool(tx);
1471         nvpair_t *pair;
1472
1473         for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1474             pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1475                 dsl_dataset_t *ds;
1476                 char *name, *atp;
1477                 char dsname[MAXNAMELEN];
1478
1479                 name = nvpair_name(pair);
1480                 atp = strchr(name, '@');
1481                 (void) strlcpy(dsname, name, atp - name + 1);
1482                 VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
1483
1484                 dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
1485                 if (ddsa->ddsa_props != NULL) {
1486                         dsl_props_set_sync_impl(ds->ds_prev,
1487                             ZPROP_SRC_LOCAL, ddsa->ddsa_props, tx);
1488                 }
1489                 dsl_dataset_rele(ds, FTAG);
1490         }
1491 }
1492
1493 /*
1494  * The snapshots must all be in the same pool.
1495  * All-or-nothing: if there are any failures, nothing will be modified.
1496  */
1497 int
1498 dsl_dataset_snapshot(nvlist_t *snaps, nvlist_t *props, nvlist_t *errors)
1499 {
1500         dsl_dataset_snapshot_arg_t ddsa;
1501         nvpair_t *pair;
1502         boolean_t needsuspend;
1503         int error;
1504         spa_t *spa;
1505         char *firstname;
1506         nvlist_t *suspended = NULL;
1507
1508         pair = nvlist_next_nvpair(snaps, NULL);
1509         if (pair == NULL)
1510                 return (0);
1511         firstname = nvpair_name(pair);
1512
1513         error = spa_open(firstname, &spa, FTAG);
1514         if (error != 0)
1515                 return (error);
1516         needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1517         spa_close(spa, FTAG);
1518
1519         if (needsuspend) {
1520                 suspended = fnvlist_alloc();
1521                 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
1522                     pair = nvlist_next_nvpair(snaps, pair)) {
1523                         char fsname[MAXNAMELEN];
1524                         char *snapname = nvpair_name(pair);
1525                         char *atp;
1526                         void *cookie;
1527
1528                         atp = strchr(snapname, '@');
1529                         if (atp == NULL) {
1530                                 error = SET_ERROR(EINVAL);
1531                                 break;
1532                         }
1533                         (void) strlcpy(fsname, snapname, atp - snapname + 1);
1534
1535                         error = zil_suspend(fsname, &cookie);
1536                         if (error != 0)
1537                                 break;
1538                         fnvlist_add_uint64(suspended, fsname,
1539                             (uintptr_t)cookie);
1540                 }
1541         }
1542
1543         ddsa.ddsa_snaps = snaps;
1544         ddsa.ddsa_props = props;
1545         ddsa.ddsa_errors = errors;
1546         ddsa.ddsa_cr = CRED();
1547
1548         if (error == 0) {
1549                 error = dsl_sync_task(firstname, dsl_dataset_snapshot_check,
1550                     dsl_dataset_snapshot_sync, &ddsa,
1551                     fnvlist_num_pairs(snaps) * 3, ZFS_SPACE_CHECK_NORMAL);
1552         }
1553
1554         if (suspended != NULL) {
1555                 for (pair = nvlist_next_nvpair(suspended, NULL); pair != NULL;
1556                     pair = nvlist_next_nvpair(suspended, pair)) {
1557                         zil_resume((void *)(uintptr_t)
1558                             fnvpair_value_uint64(pair));
1559                 }
1560                 fnvlist_free(suspended);
1561         }
1562
1563 #ifdef __FreeBSD__
1564 #ifdef _KERNEL
1565         if (error == 0) {
1566                 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
1567                     pair = nvlist_next_nvpair(snaps, pair)) {
1568                         char *snapname = nvpair_name(pair);
1569                         zvol_create_minors(snapname);
1570                 }
1571         }
1572 #endif
1573 #endif
1574         return (error);
1575 }
1576
1577 typedef struct dsl_dataset_snapshot_tmp_arg {
1578         const char *ddsta_fsname;
1579         const char *ddsta_snapname;
1580         minor_t ddsta_cleanup_minor;
1581         const char *ddsta_htag;
1582 } dsl_dataset_snapshot_tmp_arg_t;
1583
1584 static int
1585 dsl_dataset_snapshot_tmp_check(void *arg, dmu_tx_t *tx)
1586 {
1587         dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1588         dsl_pool_t *dp = dmu_tx_pool(tx);
1589         dsl_dataset_t *ds;
1590         int error;
1591
1592         error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
1593         if (error != 0)
1594                 return (error);
1595
1596         /* NULL cred means no limit check for tmp snapshot */
1597         error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
1598             tx, B_FALSE, 0, NULL);
1599         if (error != 0) {
1600                 dsl_dataset_rele(ds, FTAG);
1601                 return (error);
1602         }
1603
1604         if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS) {
1605                 dsl_dataset_rele(ds, FTAG);
1606                 return (SET_ERROR(ENOTSUP));
1607         }
1608         error = dsl_dataset_user_hold_check_one(NULL, ddsta->ddsta_htag,
1609             B_TRUE, tx);
1610         if (error != 0) {
1611                 dsl_dataset_rele(ds, FTAG);
1612                 return (error);
1613         }
1614
1615         dsl_dataset_rele(ds, FTAG);
1616         return (0);
1617 }
1618
1619 static void
1620 dsl_dataset_snapshot_tmp_sync(void *arg, dmu_tx_t *tx)
1621 {
1622         dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1623         dsl_pool_t *dp = dmu_tx_pool(tx);
1624         dsl_dataset_t *ds;
1625
1626         VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
1627
1628         dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
1629         dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
1630             ddsta->ddsta_cleanup_minor, gethrestime_sec(), tx);
1631         dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
1632
1633         dsl_dataset_rele(ds, FTAG);
1634 }
1635
1636 int
1637 dsl_dataset_snapshot_tmp(const char *fsname, const char *snapname,
1638     minor_t cleanup_minor, const char *htag)
1639 {
1640         dsl_dataset_snapshot_tmp_arg_t ddsta;
1641         int error;
1642         spa_t *spa;
1643         boolean_t needsuspend;
1644         void *cookie;
1645
1646         ddsta.ddsta_fsname = fsname;
1647         ddsta.ddsta_snapname = snapname;
1648         ddsta.ddsta_cleanup_minor = cleanup_minor;
1649         ddsta.ddsta_htag = htag;
1650
1651         error = spa_open(fsname, &spa, FTAG);
1652         if (error != 0)
1653                 return (error);
1654         needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1655         spa_close(spa, FTAG);
1656
1657         if (needsuspend) {
1658                 error = zil_suspend(fsname, &cookie);
1659                 if (error != 0)
1660                         return (error);
1661         }
1662
1663         error = dsl_sync_task(fsname, dsl_dataset_snapshot_tmp_check,
1664             dsl_dataset_snapshot_tmp_sync, &ddsta, 3, ZFS_SPACE_CHECK_RESERVED);
1665
1666         if (needsuspend)
1667                 zil_resume(cookie);
1668         return (error);
1669 }
1670
1671
1672 void
1673 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx)
1674 {
1675         ASSERT(dmu_tx_is_syncing(tx));
1676         ASSERT(ds->ds_objset != NULL);
1677         ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
1678
1679         /*
1680          * in case we had to change ds_fsid_guid when we opened it,
1681          * sync it out now.
1682          */
1683         dmu_buf_will_dirty(ds->ds_dbuf, tx);
1684         dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
1685
1686         if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
1687                 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1688                     ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
1689                     &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
1690                 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1691                     ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
1692                     &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
1693                 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1694                     ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
1695                     &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
1696                 ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
1697                 ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
1698                 ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
1699         }
1700
1701         dmu_objset_sync(ds->ds_objset, zio, tx);
1702
1703         for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1704                 if (ds->ds_feature_activation_needed[f]) {
1705                         if (ds->ds_feature_inuse[f])
1706                                 continue;
1707                         dsl_dataset_activate_feature(ds->ds_object, f, tx);
1708                         ds->ds_feature_inuse[f] = B_TRUE;
1709                 }
1710         }
1711 }
1712
1713 static void
1714 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
1715 {
1716         uint64_t count = 0;
1717         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1718         zap_cursor_t zc;
1719         zap_attribute_t za;
1720         nvlist_t *propval = fnvlist_alloc();
1721         nvlist_t *val = fnvlist_alloc();
1722
1723         ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1724
1725         /*
1726          * There may be missing entries in ds_next_clones_obj
1727          * due to a bug in a previous version of the code.
1728          * Only trust it if it has the right number of entries.
1729          */
1730         if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
1731                 VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1732                     &count));
1733         }
1734         if (count != dsl_dataset_phys(ds)->ds_num_children - 1)
1735                 goto fail;
1736         for (zap_cursor_init(&zc, mos,
1737             dsl_dataset_phys(ds)->ds_next_clones_obj);
1738             zap_cursor_retrieve(&zc, &za) == 0;
1739             zap_cursor_advance(&zc)) {
1740                 dsl_dataset_t *clone;
1741                 char buf[ZFS_MAXNAMELEN];
1742                 VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
1743                     za.za_first_integer, FTAG, &clone));
1744                 dsl_dir_name(clone->ds_dir, buf);
1745                 fnvlist_add_boolean(val, buf);
1746                 dsl_dataset_rele(clone, FTAG);
1747         }
1748         zap_cursor_fini(&zc);
1749         fnvlist_add_nvlist(propval, ZPROP_VALUE, val);
1750         fnvlist_add_nvlist(nv, zfs_prop_to_name(ZFS_PROP_CLONES), propval);
1751 fail:
1752         nvlist_free(val);
1753         nvlist_free(propval);
1754 }
1755
1756 static void
1757 get_receive_resume_stats(dsl_dataset_t *ds, nvlist_t *nv)
1758 {
1759         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1760
1761         if (dsl_dataset_has_resume_receive_state(ds)) {
1762                 char *str;
1763                 void *packed;
1764                 uint8_t *compressed;
1765                 uint64_t val;
1766                 nvlist_t *token_nv = fnvlist_alloc();
1767                 size_t packed_size, compressed_size;
1768
1769                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1770                     DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val) == 0) {
1771                         fnvlist_add_uint64(token_nv, "fromguid", val);
1772                 }
1773                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1774                     DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val) == 0) {
1775                         fnvlist_add_uint64(token_nv, "object", val);
1776                 }
1777                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1778                     DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val) == 0) {
1779                         fnvlist_add_uint64(token_nv, "offset", val);
1780                 }
1781                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1782                     DS_FIELD_RESUME_BYTES, sizeof (val), 1, &val) == 0) {
1783                         fnvlist_add_uint64(token_nv, "bytes", val);
1784                 }
1785                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1786                     DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val) == 0) {
1787                         fnvlist_add_uint64(token_nv, "toguid", val);
1788                 }
1789                 char buf[256];
1790                 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1791                     DS_FIELD_RESUME_TONAME, 1, sizeof (buf), buf) == 0) {
1792                         fnvlist_add_string(token_nv, "toname", buf);
1793                 }
1794                 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1795                     DS_FIELD_RESUME_EMBEDOK) == 0) {
1796                         fnvlist_add_boolean(token_nv, "embedok");
1797                 }
1798                 packed = fnvlist_pack(token_nv, &packed_size);
1799                 fnvlist_free(token_nv);
1800                 compressed = kmem_alloc(packed_size, KM_SLEEP);
1801
1802                 compressed_size = gzip_compress(packed, compressed,
1803                     packed_size, packed_size, 6);
1804
1805                 zio_cksum_t cksum;
1806                 fletcher_4_native(compressed, compressed_size, NULL, &cksum);
1807
1808                 str = kmem_alloc(compressed_size * 2 + 1, KM_SLEEP);
1809                 for (int i = 0; i < compressed_size; i++) {
1810                         (void) sprintf(str + i * 2, "%02x", compressed[i]);
1811                 }
1812                 str[compressed_size * 2] = '\0';
1813                 char *propval = kmem_asprintf("%u-%llx-%llx-%s",
1814                     ZFS_SEND_RESUME_TOKEN_VERSION,
1815                     (longlong_t)cksum.zc_word[0],
1816                     (longlong_t)packed_size, str);
1817                 dsl_prop_nvlist_add_string(nv,
1818                     ZFS_PROP_RECEIVE_RESUME_TOKEN, propval);
1819                 kmem_free(packed, packed_size);
1820                 kmem_free(str, compressed_size * 2 + 1);
1821                 kmem_free(compressed, packed_size);
1822                 strfree(propval);
1823         }
1824 }
1825
1826 void
1827 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
1828 {
1829         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1830         uint64_t refd, avail, uobjs, aobjs, ratio;
1831
1832         ASSERT(dsl_pool_config_held(dp));
1833
1834         ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
1835             (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
1836             dsl_dataset_phys(ds)->ds_compressed_bytes);
1837
1838         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRATIO, ratio);
1839         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_LOGICALREFERENCED,
1840             dsl_dataset_phys(ds)->ds_uncompressed_bytes);
1841
1842         if (ds->ds_is_snapshot) {
1843                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO, ratio);
1844                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
1845                     dsl_dataset_phys(ds)->ds_unique_bytes);
1846                 get_clones_stat(ds, nv);
1847         } else {
1848                 if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
1849                         char buf[MAXNAMELEN];
1850                         dsl_dataset_name(ds->ds_prev, buf);
1851                         dsl_prop_nvlist_add_string(nv, ZFS_PROP_PREV_SNAP, buf);
1852                 }
1853
1854                 dsl_dir_stats(ds->ds_dir, nv);
1855         }
1856
1857         dsl_dataset_space(ds, &refd, &avail, &uobjs, &aobjs);
1858         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE, avail);
1859         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFERENCED, refd);
1860
1861         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATION,
1862             dsl_dataset_phys(ds)->ds_creation_time);
1863         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATETXG,
1864             dsl_dataset_phys(ds)->ds_creation_txg);
1865         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFQUOTA,
1866             ds->ds_quota);
1867         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRESERVATION,
1868             ds->ds_reserved);
1869         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_GUID,
1870             dsl_dataset_phys(ds)->ds_guid);
1871         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_UNIQUE,
1872             dsl_dataset_phys(ds)->ds_unique_bytes);
1873         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_OBJSETID,
1874             ds->ds_object);
1875         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USERREFS,
1876             ds->ds_userrefs);
1877         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_DEFER_DESTROY,
1878             DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
1879
1880         if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
1881                 uint64_t written, comp, uncomp;
1882                 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1883                 dsl_dataset_t *prev;
1884
1885                 int err = dsl_dataset_hold_obj(dp,
1886                     dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
1887                 if (err == 0) {
1888                         err = dsl_dataset_space_written(prev, ds, &written,
1889                             &comp, &uncomp);
1890                         dsl_dataset_rele(prev, FTAG);
1891                         if (err == 0) {
1892                                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_WRITTEN,
1893                                     written);
1894                         }
1895                 }
1896         }
1897
1898         if (!dsl_dataset_is_snapshot(ds)) {
1899                 /*
1900                  * A failed "newfs" (e.g. full) resumable receive leaves
1901                  * the stats set on this dataset.  Check here for the prop.
1902                  */
1903                 get_receive_resume_stats(ds, nv);
1904
1905                 /*
1906                  * A failed incremental resumable receive leaves the
1907                  * stats set on our child named "%recv".  Check the child
1908                  * for the prop.
1909                  */
1910                 char recvname[ZFS_MAXNAMELEN];
1911                 dsl_dataset_t *recv_ds;
1912                 dsl_dataset_name(ds, recvname);
1913                 (void) strcat(recvname, "/");
1914                 (void) strcat(recvname, recv_clone_name);
1915                 if (dsl_dataset_hold(dp, recvname, FTAG, &recv_ds) == 0) {
1916                         get_receive_resume_stats(recv_ds, nv);
1917                         dsl_dataset_rele(recv_ds, FTAG);
1918                 }
1919         }
1920 }
1921
1922 void
1923 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
1924 {
1925         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1926         ASSERT(dsl_pool_config_held(dp));
1927
1928         stat->dds_creation_txg = dsl_dataset_phys(ds)->ds_creation_txg;
1929         stat->dds_inconsistent =
1930             dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT;
1931         stat->dds_guid = dsl_dataset_phys(ds)->ds_guid;
1932         stat->dds_origin[0] = '\0';
1933         if (ds->ds_is_snapshot) {
1934                 stat->dds_is_snapshot = B_TRUE;
1935                 stat->dds_num_clones =
1936                     dsl_dataset_phys(ds)->ds_num_children - 1;
1937         } else {
1938                 stat->dds_is_snapshot = B_FALSE;
1939                 stat->dds_num_clones = 0;
1940
1941                 if (dsl_dir_is_clone(ds->ds_dir)) {
1942                         dsl_dataset_t *ods;
1943
1944                         VERIFY0(dsl_dataset_hold_obj(dp,
1945                             dsl_dir_phys(ds->ds_dir)->dd_origin_obj,
1946                             FTAG, &ods));
1947                         dsl_dataset_name(ods, stat->dds_origin);
1948                         dsl_dataset_rele(ods, FTAG);
1949                 }
1950         }
1951 }
1952
1953 uint64_t
1954 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
1955 {
1956         return (ds->ds_fsid_guid);
1957 }
1958
1959 void
1960 dsl_dataset_space(dsl_dataset_t *ds,
1961     uint64_t *refdbytesp, uint64_t *availbytesp,
1962     uint64_t *usedobjsp, uint64_t *availobjsp)
1963 {
1964         *refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
1965         *availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
1966         if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
1967                 *availbytesp +=
1968                     ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
1969         if (ds->ds_quota != 0) {
1970                 /*
1971                  * Adjust available bytes according to refquota
1972                  */
1973                 if (*refdbytesp < ds->ds_quota)
1974                         *availbytesp = MIN(*availbytesp,
1975                             ds->ds_quota - *refdbytesp);
1976                 else
1977                         *availbytesp = 0;
1978         }
1979         *usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
1980         *availobjsp = DN_MAX_OBJECT - *usedobjsp;
1981 }
1982
1983 boolean_t
1984 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
1985 {
1986         dsl_pool_t *dp = ds->ds_dir->dd_pool;
1987
1988         ASSERT(dsl_pool_config_held(dp));
1989         if (snap == NULL)
1990                 return (B_FALSE);
1991         if (dsl_dataset_phys(ds)->ds_bp.blk_birth >
1992             dsl_dataset_phys(snap)->ds_creation_txg) {
1993                 objset_t *os, *os_snap;
1994                 /*
1995                  * It may be that only the ZIL differs, because it was
1996                  * reset in the head.  Don't count that as being
1997                  * modified.
1998                  */
1999                 if (dmu_objset_from_ds(ds, &os) != 0)
2000                         return (B_TRUE);
2001                 if (dmu_objset_from_ds(snap, &os_snap) != 0)
2002                         return (B_TRUE);
2003                 return (bcmp(&os->os_phys->os_meta_dnode,
2004                     &os_snap->os_phys->os_meta_dnode,
2005                     sizeof (os->os_phys->os_meta_dnode)) != 0);
2006         }
2007         return (B_FALSE);
2008 }
2009
2010 typedef struct dsl_dataset_rename_snapshot_arg {
2011         const char *ddrsa_fsname;
2012         const char *ddrsa_oldsnapname;
2013         const char *ddrsa_newsnapname;
2014         boolean_t ddrsa_recursive;
2015         dmu_tx_t *ddrsa_tx;
2016 } dsl_dataset_rename_snapshot_arg_t;
2017
2018 /* ARGSUSED */
2019 static int
2020 dsl_dataset_rename_snapshot_check_impl(dsl_pool_t *dp,
2021     dsl_dataset_t *hds, void *arg)
2022 {
2023         dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2024         int error;
2025         uint64_t val;
2026
2027         error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2028         if (error != 0) {
2029                 /* ignore nonexistent snapshots */
2030                 return (error == ENOENT ? 0 : error);
2031         }
2032
2033         /* new name should not exist */
2034         error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_newsnapname, &val);
2035         if (error == 0)
2036                 error = SET_ERROR(EEXIST);
2037         else if (error == ENOENT)
2038                 error = 0;
2039
2040         /* dataset name + 1 for the "@" + the new snapshot name must fit */
2041         if (dsl_dir_namelen(hds->ds_dir) + 1 +
2042             strlen(ddrsa->ddrsa_newsnapname) >= MAXNAMELEN)
2043                 error = SET_ERROR(ENAMETOOLONG);
2044
2045         return (error);
2046 }
2047
2048 static int
2049 dsl_dataset_rename_snapshot_check(void *arg, dmu_tx_t *tx)
2050 {
2051         dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2052         dsl_pool_t *dp = dmu_tx_pool(tx);
2053         dsl_dataset_t *hds;
2054         int error;
2055
2056         error = dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds);
2057         if (error != 0)
2058                 return (error);
2059
2060         if (ddrsa->ddrsa_recursive) {
2061                 error = dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2062                     dsl_dataset_rename_snapshot_check_impl, ddrsa,
2063                     DS_FIND_CHILDREN);
2064         } else {
2065                 error = dsl_dataset_rename_snapshot_check_impl(dp, hds, ddrsa);
2066         }
2067         dsl_dataset_rele(hds, FTAG);
2068         return (error);
2069 }
2070
2071 static int
2072 dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
2073     dsl_dataset_t *hds, void *arg)
2074 {
2075 #ifdef __FreeBSD__
2076 #ifdef _KERNEL
2077         char *oldname, *newname;
2078 #endif
2079 #endif
2080         dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2081         dsl_dataset_t *ds;
2082         uint64_t val;
2083         dmu_tx_t *tx = ddrsa->ddrsa_tx;
2084         int error;
2085
2086         error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2087         ASSERT(error == 0 || error == ENOENT);
2088         if (error == ENOENT) {
2089                 /* ignore nonexistent snapshots */
2090                 return (0);
2091         }
2092
2093         VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
2094
2095         /* log before we change the name */
2096         spa_history_log_internal_ds(ds, "rename", tx,
2097             "-> @%s", ddrsa->ddrsa_newsnapname);
2098
2099         VERIFY0(dsl_dataset_snap_remove(hds, ddrsa->ddrsa_oldsnapname, tx,
2100             B_FALSE));
2101         mutex_enter(&ds->ds_lock);
2102         (void) strcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname);
2103         mutex_exit(&ds->ds_lock);
2104         VERIFY0(zap_add(dp->dp_meta_objset,
2105             dsl_dataset_phys(hds)->ds_snapnames_zapobj,
2106             ds->ds_snapname, 8, 1, &ds->ds_object, tx));
2107
2108 #ifdef __FreeBSD__
2109 #ifdef _KERNEL
2110         oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2111         newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2112         snprintf(oldname, MAXPATHLEN, "%s@%s", ddrsa->ddrsa_fsname,
2113             ddrsa->ddrsa_oldsnapname);
2114         snprintf(newname, MAXPATHLEN, "%s@%s", ddrsa->ddrsa_fsname,
2115             ddrsa->ddrsa_newsnapname);
2116         zfsvfs_update_fromname(oldname, newname);
2117         zvol_rename_minors(oldname, newname);
2118         kmem_free(newname, MAXPATHLEN);
2119         kmem_free(oldname, MAXPATHLEN);
2120 #endif
2121 #endif
2122         dsl_dataset_rele(ds, FTAG);
2123
2124         return (0);
2125 }
2126
2127 static void
2128 dsl_dataset_rename_snapshot_sync(void *arg, dmu_tx_t *tx)
2129 {
2130         dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2131         dsl_pool_t *dp = dmu_tx_pool(tx);
2132         dsl_dataset_t *hds;
2133
2134         VERIFY0(dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds));
2135         ddrsa->ddrsa_tx = tx;
2136         if (ddrsa->ddrsa_recursive) {
2137                 VERIFY0(dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2138                     dsl_dataset_rename_snapshot_sync_impl, ddrsa,
2139                     DS_FIND_CHILDREN));
2140         } else {
2141                 VERIFY0(dsl_dataset_rename_snapshot_sync_impl(dp, hds, ddrsa));
2142         }
2143         dsl_dataset_rele(hds, FTAG);
2144 }
2145
2146 int
2147 dsl_dataset_rename_snapshot(const char *fsname,
2148     const char *oldsnapname, const char *newsnapname, boolean_t recursive)
2149 {
2150         dsl_dataset_rename_snapshot_arg_t ddrsa;
2151
2152         ddrsa.ddrsa_fsname = fsname;
2153         ddrsa.ddrsa_oldsnapname = oldsnapname;
2154         ddrsa.ddrsa_newsnapname = newsnapname;
2155         ddrsa.ddrsa_recursive = recursive;
2156
2157         return (dsl_sync_task(fsname, dsl_dataset_rename_snapshot_check,
2158             dsl_dataset_rename_snapshot_sync, &ddrsa,
2159             1, ZFS_SPACE_CHECK_RESERVED));
2160 }
2161
2162 /*
2163  * If we're doing an ownership handoff, we need to make sure that there is
2164  * only one long hold on the dataset.  We're not allowed to change anything here
2165  * so we don't permanently release the long hold or regular hold here.  We want
2166  * to do this only when syncing to avoid the dataset unexpectedly going away
2167  * when we release the long hold.
2168  */
2169 static int
2170 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
2171 {
2172         boolean_t held;
2173
2174         if (!dmu_tx_is_syncing(tx))
2175                 return (0);
2176
2177         if (owner != NULL) {
2178                 VERIFY3P(ds->ds_owner, ==, owner);
2179                 dsl_dataset_long_rele(ds, owner);
2180         }
2181
2182         held = dsl_dataset_long_held(ds);
2183
2184         if (owner != NULL)
2185                 dsl_dataset_long_hold(ds, owner);
2186
2187         if (held)
2188                 return (SET_ERROR(EBUSY));
2189
2190         return (0);
2191 }
2192
2193 typedef struct dsl_dataset_rollback_arg {
2194         const char *ddra_fsname;
2195         void *ddra_owner;
2196         nvlist_t *ddra_result;
2197 } dsl_dataset_rollback_arg_t;
2198
2199 static int
2200 dsl_dataset_rollback_check(void *arg, dmu_tx_t *tx)
2201 {
2202         dsl_dataset_rollback_arg_t *ddra = arg;
2203         dsl_pool_t *dp = dmu_tx_pool(tx);
2204         dsl_dataset_t *ds;
2205         int64_t unused_refres_delta;
2206         int error;
2207
2208         error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
2209         if (error != 0)
2210                 return (error);
2211
2212         /* must not be a snapshot */
2213         if (ds->ds_is_snapshot) {
2214                 dsl_dataset_rele(ds, FTAG);
2215                 return (SET_ERROR(EINVAL));
2216         }
2217
2218         /* must have a most recent snapshot */
2219         if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
2220                 dsl_dataset_rele(ds, FTAG);
2221                 return (SET_ERROR(EINVAL));
2222         }
2223
2224         /* must not have any bookmarks after the most recent snapshot */
2225         nvlist_t *proprequest = fnvlist_alloc();
2226         fnvlist_add_boolean(proprequest, zfs_prop_to_name(ZFS_PROP_CREATETXG));
2227         nvlist_t *bookmarks = fnvlist_alloc();
2228         error = dsl_get_bookmarks_impl(ds, proprequest, bookmarks);
2229         fnvlist_free(proprequest);
2230         if (error != 0)
2231                 return (error);
2232         for (nvpair_t *pair = nvlist_next_nvpair(bookmarks, NULL);
2233             pair != NULL; pair = nvlist_next_nvpair(bookmarks, pair)) {
2234                 nvlist_t *valuenv =
2235                     fnvlist_lookup_nvlist(fnvpair_value_nvlist(pair),
2236                     zfs_prop_to_name(ZFS_PROP_CREATETXG));
2237                 uint64_t createtxg = fnvlist_lookup_uint64(valuenv, "value");
2238                 if (createtxg > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
2239                         fnvlist_free(bookmarks);
2240                         dsl_dataset_rele(ds, FTAG);
2241                         return (SET_ERROR(EEXIST));
2242                 }
2243         }
2244         fnvlist_free(bookmarks);
2245
2246         error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
2247         if (error != 0) {
2248                 dsl_dataset_rele(ds, FTAG);
2249                 return (error);
2250         }
2251
2252         /*
2253          * Check if the snap we are rolling back to uses more than
2254          * the refquota.
2255          */
2256         if (ds->ds_quota != 0 &&
2257             dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
2258                 dsl_dataset_rele(ds, FTAG);
2259                 return (SET_ERROR(EDQUOT));
2260         }
2261
2262         /*
2263          * When we do the clone swap, we will temporarily use more space
2264          * due to the refreservation (the head will no longer have any
2265          * unique space, so the entire amount of the refreservation will need
2266          * to be free).  We will immediately destroy the clone, freeing
2267          * this space, but the freeing happens over many txg's.
2268          */
2269         unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
2270             dsl_dataset_phys(ds)->ds_unique_bytes);
2271
2272         if (unused_refres_delta > 0 &&
2273             unused_refres_delta >
2274             dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
2275                 dsl_dataset_rele(ds, FTAG);
2276                 return (SET_ERROR(ENOSPC));
2277         }
2278
2279         dsl_dataset_rele(ds, FTAG);
2280         return (0);
2281 }
2282
2283 static void
2284 dsl_dataset_rollback_sync(void *arg, dmu_tx_t *tx)
2285 {
2286         dsl_dataset_rollback_arg_t *ddra = arg;
2287         dsl_pool_t *dp = dmu_tx_pool(tx);
2288         dsl_dataset_t *ds, *clone;
2289         uint64_t cloneobj;
2290         char namebuf[ZFS_MAXNAMELEN];
2291
2292         VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
2293
2294         dsl_dataset_name(ds->ds_prev, namebuf);
2295         fnvlist_add_string(ddra->ddra_result, "target", namebuf);
2296
2297         cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
2298             ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, tx);
2299
2300         VERIFY0(dsl_dataset_hold_obj(dp, cloneobj, FTAG, &clone));
2301
2302         dsl_dataset_clone_swap_sync_impl(clone, ds, tx);
2303         dsl_dataset_zero_zil(ds, tx);
2304
2305         dsl_destroy_head_sync_impl(clone, tx);
2306
2307         dsl_dataset_rele(clone, FTAG);
2308         dsl_dataset_rele(ds, FTAG);
2309 }
2310
2311 /*
2312  * Rolls back the given filesystem or volume to the most recent snapshot.
2313  * The name of the most recent snapshot will be returned under key "target"
2314  * in the result nvlist.
2315  *
2316  * If owner != NULL:
2317  * - The existing dataset MUST be owned by the specified owner at entry
2318  * - Upon return, dataset will still be held by the same owner, whether we
2319  *   succeed or not.
2320  *
2321  * This mode is required any time the existing filesystem is mounted.  See
2322  * notes above zfs_suspend_fs() for further details.
2323  */
2324 int
2325 dsl_dataset_rollback(const char *fsname, void *owner, nvlist_t *result)
2326 {
2327         dsl_dataset_rollback_arg_t ddra;
2328
2329         ddra.ddra_fsname = fsname;
2330         ddra.ddra_owner = owner;
2331         ddra.ddra_result = result;
2332
2333         return (dsl_sync_task(fsname, dsl_dataset_rollback_check,
2334             dsl_dataset_rollback_sync, &ddra,
2335             1, ZFS_SPACE_CHECK_RESERVED));
2336 }
2337
2338 struct promotenode {
2339         list_node_t link;
2340         dsl_dataset_t *ds;
2341 };
2342
2343 typedef struct dsl_dataset_promote_arg {
2344         const char *ddpa_clonename;
2345         dsl_dataset_t *ddpa_clone;
2346         list_t shared_snaps, origin_snaps, clone_snaps;
2347         dsl_dataset_t *origin_origin; /* origin of the origin */
2348         uint64_t used, comp, uncomp, unique, cloneusedsnap, originusedsnap;
2349         char *err_ds;
2350         cred_t *cr;
2351 } dsl_dataset_promote_arg_t;
2352
2353 static int snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep);
2354 static int promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp,
2355     void *tag);
2356 static void promote_rele(dsl_dataset_promote_arg_t *ddpa, void *tag);
2357
2358 static int
2359 dsl_dataset_promote_check(void *arg, dmu_tx_t *tx)
2360 {
2361         dsl_dataset_promote_arg_t *ddpa = arg;
2362         dsl_pool_t *dp = dmu_tx_pool(tx);
2363         dsl_dataset_t *hds;
2364         struct promotenode *snap;
2365         dsl_dataset_t *origin_ds;
2366         int err;
2367         uint64_t unused;
2368         uint64_t ss_mv_cnt;
2369         size_t max_snap_len;
2370
2371         err = promote_hold(ddpa, dp, FTAG);
2372         if (err != 0)
2373                 return (err);
2374
2375         hds = ddpa->ddpa_clone;
2376         max_snap_len = MAXNAMELEN - strlen(ddpa->ddpa_clonename) - 1;
2377
2378         if (dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE) {
2379                 promote_rele(ddpa, FTAG);
2380                 return (SET_ERROR(EXDEV));
2381         }
2382
2383         /*
2384          * Compute and check the amount of space to transfer.  Since this is
2385          * so expensive, don't do the preliminary check.
2386          */
2387         if (!dmu_tx_is_syncing(tx)) {
2388                 promote_rele(ddpa, FTAG);
2389                 return (0);
2390         }
2391
2392         snap = list_head(&ddpa->shared_snaps);
2393         origin_ds = snap->ds;
2394
2395         /* compute origin's new unique space */
2396         snap = list_tail(&ddpa->clone_snaps);
2397         ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
2398             origin_ds->ds_object);
2399         dsl_deadlist_space_range(&snap->ds->ds_deadlist,
2400             dsl_dataset_phys(origin_ds)->ds_prev_snap_txg, UINT64_MAX,
2401             &ddpa->unique, &unused, &unused);
2402
2403         /*
2404          * Walk the snapshots that we are moving
2405          *
2406          * Compute space to transfer.  Consider the incremental changes
2407          * to used by each snapshot:
2408          * (my used) = (prev's used) + (blocks born) - (blocks killed)
2409          * So each snapshot gave birth to:
2410          * (blocks born) = (my used) - (prev's used) + (blocks killed)
2411          * So a sequence would look like:
2412          * (uN - u(N-1) + kN) + ... + (u1 - u0 + k1) + (u0 - 0 + k0)
2413          * Which simplifies to:
2414          * uN + kN + kN-1 + ... + k1 + k0
2415          * Note however, if we stop before we reach the ORIGIN we get:
2416          * uN + kN + kN-1 + ... + kM - uM-1
2417          */
2418         ss_mv_cnt = 0;
2419         ddpa->used = dsl_dataset_phys(origin_ds)->ds_referenced_bytes;
2420         ddpa->comp = dsl_dataset_phys(origin_ds)->ds_compressed_bytes;
2421         ddpa->uncomp = dsl_dataset_phys(origin_ds)->ds_uncompressed_bytes;
2422         for (snap = list_head(&ddpa->shared_snaps); snap;
2423             snap = list_next(&ddpa->shared_snaps, snap)) {
2424                 uint64_t val, dlused, dlcomp, dluncomp;
2425                 dsl_dataset_t *ds = snap->ds;
2426
2427                 ss_mv_cnt++;
2428
2429                 /*
2430                  * If there are long holds, we won't be able to evict
2431                  * the objset.
2432                  */
2433                 if (dsl_dataset_long_held(ds)) {
2434                         err = SET_ERROR(EBUSY);
2435                         goto out;
2436                 }
2437
2438                 /* Check that the snapshot name does not conflict */
2439                 VERIFY0(dsl_dataset_get_snapname(ds));
2440                 if (strlen(ds->ds_snapname) >= max_snap_len) {
2441                         err = SET_ERROR(ENAMETOOLONG);
2442                         goto out;
2443                 }
2444                 err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
2445                 if (err == 0) {
2446                         (void) strcpy(ddpa->err_ds, snap->ds->ds_snapname);
2447                         err = SET_ERROR(EEXIST);
2448                         goto out;
2449                 }
2450                 if (err != ENOENT)
2451                         goto out;
2452
2453                 /* The very first snapshot does not have a deadlist */
2454                 if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
2455                         continue;
2456
2457                 dsl_deadlist_space(&ds->ds_deadlist,
2458                     &dlused, &dlcomp, &dluncomp);
2459                 ddpa->used += dlused;
2460                 ddpa->comp += dlcomp;
2461                 ddpa->uncomp += dluncomp;
2462         }
2463
2464         /*
2465          * If we are a clone of a clone then we never reached ORIGIN,
2466          * so we need to subtract out the clone origin's used space.
2467          */
2468         if (ddpa->origin_origin) {
2469                 ddpa->used -=
2470                     dsl_dataset_phys(ddpa->origin_origin)->ds_referenced_bytes;
2471                 ddpa->comp -=
2472                     dsl_dataset_phys(ddpa->origin_origin)->ds_compressed_bytes;
2473                 ddpa->uncomp -=
2474                     dsl_dataset_phys(ddpa->origin_origin)->
2475                     ds_uncompressed_bytes;
2476         }
2477
2478         /* Check that there is enough space and limit headroom here */
2479         err = dsl_dir_transfer_possible(origin_ds->ds_dir, hds->ds_dir,
2480             0, ss_mv_cnt, ddpa->used, ddpa->cr);
2481         if (err != 0)
2482                 goto out;
2483
2484         /*
2485          * Compute the amounts of space that will be used by snapshots
2486          * after the promotion (for both origin and clone).  For each,
2487          * it is the amount of space that will be on all of their
2488          * deadlists (that was not born before their new origin).
2489          */
2490         if (dsl_dir_phys(hds->ds_dir)->dd_flags & DD_FLAG_USED_BREAKDOWN) {
2491                 uint64_t space;
2492
2493                 /*
2494                  * Note, typically this will not be a clone of a clone,
2495                  * so dd_origin_txg will be < TXG_INITIAL, so
2496                  * these snaplist_space() -> dsl_deadlist_space_range()
2497                  * calls will be fast because they do not have to
2498                  * iterate over all bps.
2499                  */
2500                 snap = list_head(&ddpa->origin_snaps);
2501                 err = snaplist_space(&ddpa->shared_snaps,
2502                     snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
2503                 if (err != 0)
2504                         goto out;
2505
2506                 err = snaplist_space(&ddpa->clone_snaps,
2507                     snap->ds->ds_dir->dd_origin_txg, &space);
2508                 if (err != 0)
2509                         goto out;
2510                 ddpa->cloneusedsnap += space;
2511         }
2512         if (dsl_dir_phys(origin_ds->ds_dir)->dd_flags &
2513             DD_FLAG_USED_BREAKDOWN) {
2514                 err = snaplist_space(&ddpa->origin_snaps,
2515                     dsl_dataset_phys(origin_ds)->ds_creation_txg,
2516                     &ddpa->originusedsnap);
2517                 if (err != 0)
2518                         goto out;
2519         }
2520
2521 out:
2522         promote_rele(ddpa, FTAG);
2523         return (err);
2524 }
2525
2526 static void
2527 dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
2528 {
2529         dsl_dataset_promote_arg_t *ddpa = arg;
2530         dsl_pool_t *dp = dmu_tx_pool(tx);
2531         dsl_dataset_t *hds;
2532         struct promotenode *snap;
2533         dsl_dataset_t *origin_ds;
2534         dsl_dataset_t *origin_head;
2535         dsl_dir_t *dd;
2536         dsl_dir_t *odd = NULL;
2537         uint64_t oldnext_obj;
2538         int64_t delta;
2539 #if defined(__FreeBSD__) && defined(_KERNEL)
2540         char *oldname, *newname;
2541 #endif
2542
2543         VERIFY0(promote_hold(ddpa, dp, FTAG));
2544         hds = ddpa->ddpa_clone;
2545
2546         ASSERT0(dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE);
2547
2548         snap = list_head(&ddpa->shared_snaps);
2549         origin_ds = snap->ds;
2550         dd = hds->ds_dir;
2551
2552         snap = list_head(&ddpa->origin_snaps);
2553         origin_head = snap->ds;
2554
2555         /*
2556          * We need to explicitly open odd, since origin_ds's dd will be
2557          * changing.
2558          */
2559         VERIFY0(dsl_dir_hold_obj(dp, origin_ds->ds_dir->dd_object,
2560             NULL, FTAG, &odd));
2561
2562         /* change origin's next snap */
2563         dmu_buf_will_dirty(origin_ds->ds_dbuf, tx);
2564         oldnext_obj = dsl_dataset_phys(origin_ds)->ds_next_snap_obj;
2565         snap = list_tail(&ddpa->clone_snaps);
2566         ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
2567             origin_ds->ds_object);
2568         dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
2569
2570         /* change the origin's next clone */
2571         if (dsl_dataset_phys(origin_ds)->ds_next_clones_obj) {
2572                 dsl_dataset_remove_from_next_clones(origin_ds,
2573                     snap->ds->ds_object, tx);
2574                 VERIFY0(zap_add_int(dp->dp_meta_objset,
2575                     dsl_dataset_phys(origin_ds)->ds_next_clones_obj,
2576                     oldnext_obj, tx));
2577         }
2578
2579         /* change origin */
2580         dmu_buf_will_dirty(dd->dd_dbuf, tx);
2581         ASSERT3U(dsl_dir_phys(dd)->dd_origin_obj, ==, origin_ds->ds_object);
2582         dsl_dir_phys(dd)->dd_origin_obj = dsl_dir_phys(odd)->dd_origin_obj;
2583         dd->dd_origin_txg = origin_head->ds_dir->dd_origin_txg;
2584         dmu_buf_will_dirty(odd->dd_dbuf, tx);
2585         dsl_dir_phys(odd)->dd_origin_obj = origin_ds->ds_object;
2586         origin_head->ds_dir->dd_origin_txg =
2587             dsl_dataset_phys(origin_ds)->ds_creation_txg;
2588
2589         /* change dd_clone entries */
2590         if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2591                 VERIFY0(zap_remove_int(dp->dp_meta_objset,
2592                     dsl_dir_phys(odd)->dd_clones, hds->ds_object, tx));
2593                 VERIFY0(zap_add_int(dp->dp_meta_objset,
2594                     dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
2595                     hds->ds_object, tx));
2596
2597                 VERIFY0(zap_remove_int(dp->dp_meta_objset,
2598                     dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
2599                     origin_head->ds_object, tx));
2600                 if (dsl_dir_phys(dd)->dd_clones == 0) {
2601                         dsl_dir_phys(dd)->dd_clones =
2602                             zap_create(dp->dp_meta_objset, DMU_OT_DSL_CLONES,
2603                             DMU_OT_NONE, 0, tx);
2604                 }
2605                 VERIFY0(zap_add_int(dp->dp_meta_objset,
2606                     dsl_dir_phys(dd)->dd_clones, origin_head->ds_object, tx));
2607         }
2608
2609 #if defined(__FreeBSD__) && defined(_KERNEL)
2610         /* Take the spa_namespace_lock early so zvol renames don't deadlock. */
2611         mutex_enter(&spa_namespace_lock);
2612
2613         oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2614         newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2615 #endif
2616
2617         /* move snapshots to this dir */
2618         for (snap = list_head(&ddpa->shared_snaps); snap;
2619             snap = list_next(&ddpa->shared_snaps, snap)) {
2620                 dsl_dataset_t *ds = snap->ds;
2621
2622                 /*
2623                  * Property callbacks are registered to a particular
2624                  * dsl_dir.  Since ours is changing, evict the objset
2625                  * so that they will be unregistered from the old dsl_dir.
2626                  */
2627                 if (ds->ds_objset) {
2628                         dmu_objset_evict(ds->ds_objset);
2629                         ds->ds_objset = NULL;
2630                 }
2631
2632                 /* move snap name entry */
2633                 VERIFY0(dsl_dataset_get_snapname(ds));
2634                 VERIFY0(dsl_dataset_snap_remove(origin_head,
2635                     ds->ds_snapname, tx, B_TRUE));
2636                 VERIFY0(zap_add(dp->dp_meta_objset,
2637                     dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
2638                     8, 1, &ds->ds_object, tx));
2639                 dsl_fs_ss_count_adjust(hds->ds_dir, 1,
2640                     DD_FIELD_SNAPSHOT_COUNT, tx);
2641
2642                 /* change containing dsl_dir */
2643                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
2644                 ASSERT3U(dsl_dataset_phys(ds)->ds_dir_obj, ==, odd->dd_object);
2645                 dsl_dataset_phys(ds)->ds_dir_obj = dd->dd_object;
2646                 ASSERT3P(ds->ds_dir, ==, odd);
2647                 dsl_dir_rele(ds->ds_dir, ds);
2648                 VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
2649                     NULL, ds, &ds->ds_dir));
2650
2651 #if defined(__FreeBSD__) && defined(_KERNEL)
2652                 dsl_dataset_name(ds, newname);
2653                 zfsvfs_update_fromname(oldname, newname);
2654                 zvol_rename_minors(oldname, newname);
2655 #endif
2656
2657                 /* move any clone references */
2658                 if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
2659                     spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2660                         zap_cursor_t zc;
2661                         zap_attribute_t za;
2662
2663                         for (zap_cursor_init(&zc, dp->dp_meta_objset,
2664                             dsl_dataset_phys(ds)->ds_next_clones_obj);
2665                             zap_cursor_retrieve(&zc, &za) == 0;
2666                             zap_cursor_advance(&zc)) {
2667                                 dsl_dataset_t *cnds;
2668                                 uint64_t o;
2669
2670                                 if (za.za_first_integer == oldnext_obj) {
2671                                         /*
2672                                          * We've already moved the
2673                                          * origin's reference.
2674                                          */
2675                                         continue;
2676                                 }
2677
2678                                 VERIFY0(dsl_dataset_hold_obj(dp,
2679                                     za.za_first_integer, FTAG, &cnds));
2680                                 o = dsl_dir_phys(cnds->ds_dir)->
2681                                     dd_head_dataset_obj;
2682
2683                                 VERIFY0(zap_remove_int(dp->dp_meta_objset,
2684                                     dsl_dir_phys(odd)->dd_clones, o, tx));
2685                                 VERIFY0(zap_add_int(dp->dp_meta_objset,
2686                                     dsl_dir_phys(dd)->dd_clones, o, tx));
2687                                 dsl_dataset_rele(cnds, FTAG);
2688                         }
2689                         zap_cursor_fini(&zc);
2690                 }
2691
2692                 ASSERT(!dsl_prop_hascb(ds));
2693         }
2694
2695 #if defined(__FreeBSD__) && defined(_KERNEL)
2696         mutex_exit(&spa_namespace_lock);
2697
2698         kmem_free(newname, MAXPATHLEN);
2699         kmem_free(oldname, MAXPATHLEN);
2700 #endif
2701         /*
2702          * Change space accounting.
2703          * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either
2704          * both be valid, or both be 0 (resulting in delta == 0).  This
2705          * is true for each of {clone,origin} independently.
2706          */
2707
2708         delta = ddpa->cloneusedsnap -
2709             dsl_dir_phys(dd)->dd_used_breakdown[DD_USED_SNAP];
2710         ASSERT3S(delta, >=, 0);
2711         ASSERT3U(ddpa->used, >=, delta);
2712         dsl_dir_diduse_space(dd, DD_USED_SNAP, delta, 0, 0, tx);
2713         dsl_dir_diduse_space(dd, DD_USED_HEAD,
2714             ddpa->used - delta, ddpa->comp, ddpa->uncomp, tx);
2715
2716         delta = ddpa->originusedsnap -
2717             dsl_dir_phys(odd)->dd_used_breakdown[DD_USED_SNAP];
2718         ASSERT3S(delta, <=, 0);
2719         ASSERT3U(ddpa->used, >=, -delta);
2720         dsl_dir_diduse_space(odd, DD_USED_SNAP, delta, 0, 0, tx);
2721         dsl_dir_diduse_space(odd, DD_USED_HEAD,
2722             -ddpa->used - delta, -ddpa->comp, -ddpa->uncomp, tx);
2723
2724         dsl_dataset_phys(origin_ds)->ds_unique_bytes = ddpa->unique;
2725
2726         /* log history record */
2727         spa_history_log_internal_ds(hds, "promote", tx, "");
2728
2729         dsl_dir_rele(odd, FTAG);
2730         promote_rele(ddpa, FTAG);
2731 }
2732
2733 /*
2734  * Make a list of dsl_dataset_t's for the snapshots between first_obj
2735  * (exclusive) and last_obj (inclusive).  The list will be in reverse
2736  * order (last_obj will be the list_head()).  If first_obj == 0, do all
2737  * snapshots back to this dataset's origin.
2738  */
2739 static int
2740 snaplist_make(dsl_pool_t *dp,
2741     uint64_t first_obj, uint64_t last_obj, list_t *l, void *tag)
2742 {
2743         uint64_t obj = last_obj;
2744
2745         list_create(l, sizeof (struct promotenode),
2746             offsetof(struct promotenode, link));
2747
2748         while (obj != first_obj) {
2749                 dsl_dataset_t *ds;
2750                 struct promotenode *snap;
2751                 int err;
2752
2753                 err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
2754                 ASSERT(err != ENOENT);
2755                 if (err != 0)
2756                         return (err);
2757
2758                 if (first_obj == 0)
2759                         first_obj = dsl_dir_phys(ds->ds_dir)->dd_origin_obj;
2760
2761                 snap = kmem_alloc(sizeof (*snap), KM_SLEEP);
2762                 snap->ds = ds;
2763                 list_insert_tail(l, snap);
2764                 obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
2765         }
2766
2767         return (0);
2768 }
2769
2770 static int
2771 snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep)
2772 {
2773         struct promotenode *snap;
2774
2775         *spacep = 0;
2776         for (snap = list_head(l); snap; snap = list_next(l, snap)) {
2777                 uint64_t used, comp, uncomp;
2778                 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
2779                     mintxg, UINT64_MAX, &used, &comp, &uncomp);
2780                 *spacep += used;
2781         }
2782         return (0);
2783 }
2784
2785 static void
2786 snaplist_destroy(list_t *l, void *tag)
2787 {
2788         struct promotenode *snap;
2789
2790         if (l == NULL || !list_link_active(&l->list_head))
2791                 return;
2792
2793         while ((snap = list_tail(l)) != NULL) {
2794                 list_remove(l, snap);
2795                 dsl_dataset_rele(snap->ds, tag);
2796                 kmem_free(snap, sizeof (*snap));
2797         }
2798         list_destroy(l);
2799 }
2800
2801 static int
2802 promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp, void *tag)
2803 {
2804         int error;
2805         dsl_dir_t *dd;
2806         struct promotenode *snap;
2807
2808         error = dsl_dataset_hold(dp, ddpa->ddpa_clonename, tag,
2809             &ddpa->ddpa_clone);
2810         if (error != 0)
2811                 return (error);
2812         dd = ddpa->ddpa_clone->ds_dir;
2813
2814         if (ddpa->ddpa_clone->ds_is_snapshot ||
2815             !dsl_dir_is_clone(dd)) {
2816                 dsl_dataset_rele(ddpa->ddpa_clone, tag);
2817                 return (SET_ERROR(EINVAL));
2818         }
2819
2820         error = snaplist_make(dp, 0, dsl_dir_phys(dd)->dd_origin_obj,
2821             &ddpa->shared_snaps, tag);
2822         if (error != 0)
2823                 goto out;
2824
2825         error = snaplist_make(dp, 0, ddpa->ddpa_clone->ds_object,
2826             &ddpa->clone_snaps, tag);
2827         if (error != 0)
2828                 goto out;
2829
2830         snap = list_head(&ddpa->shared_snaps);
2831         ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
2832         error = snaplist_make(dp, dsl_dir_phys(dd)->dd_origin_obj,
2833             dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
2834             &ddpa->origin_snaps, tag);
2835         if (error != 0)
2836                 goto out;
2837
2838         if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
2839                 error = dsl_dataset_hold_obj(dp,
2840                     dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
2841                     tag, &ddpa->origin_origin);
2842                 if (error != 0)
2843                         goto out;
2844         }
2845 out:
2846         if (error != 0)
2847                 promote_rele(ddpa, tag);
2848         return (error);
2849 }
2850
2851 static void
2852 promote_rele(dsl_dataset_promote_arg_t *ddpa, void *tag)
2853 {
2854         snaplist_destroy(&ddpa->shared_snaps, tag);
2855         snaplist_destroy(&ddpa->clone_snaps, tag);
2856         snaplist_destroy(&ddpa->origin_snaps, tag);
2857         if (ddpa->origin_origin != NULL)
2858                 dsl_dataset_rele(ddpa->origin_origin, tag);
2859         dsl_dataset_rele(ddpa->ddpa_clone, tag);
2860 }
2861
2862 /*
2863  * Promote a clone.
2864  *
2865  * If it fails due to a conflicting snapshot name, "conflsnap" will be filled
2866  * in with the name.  (It must be at least MAXNAMELEN bytes long.)
2867  */
2868 int
2869 dsl_dataset_promote(const char *name, char *conflsnap)
2870 {
2871         dsl_dataset_promote_arg_t ddpa = { 0 };
2872         uint64_t numsnaps;
2873         int error;
2874         objset_t *os;
2875
2876         /*
2877          * We will modify space proportional to the number of
2878          * snapshots.  Compute numsnaps.
2879          */
2880         error = dmu_objset_hold(name, FTAG, &os);
2881         if (error != 0)
2882                 return (error);
2883         error = zap_count(dmu_objset_pool(os)->dp_meta_objset,
2884             dsl_dataset_phys(dmu_objset_ds(os))->ds_snapnames_zapobj,
2885             &numsnaps);
2886         dmu_objset_rele(os, FTAG);
2887         if (error != 0)
2888                 return (error);
2889
2890         ddpa.ddpa_clonename = name;
2891         ddpa.err_ds = conflsnap;
2892         ddpa.cr = CRED();
2893
2894         return (dsl_sync_task(name, dsl_dataset_promote_check,
2895             dsl_dataset_promote_sync, &ddpa,
2896             2 + numsnaps, ZFS_SPACE_CHECK_RESERVED));
2897 }
2898
2899 int
2900 dsl_dataset_clone_swap_check_impl(dsl_dataset_t *clone,
2901     dsl_dataset_t *origin_head, boolean_t force, void *owner, dmu_tx_t *tx)
2902 {
2903         /*
2904          * "slack" factor for received datasets with refquota set on them.
2905          * See the bottom of this function for details on its use.
2906          */
2907         uint64_t refquota_slack = DMU_MAX_ACCESS * spa_asize_inflation;
2908         int64_t unused_refres_delta;
2909
2910         /* they should both be heads */
2911         if (clone->ds_is_snapshot ||
2912             origin_head->ds_is_snapshot)
2913                 return (SET_ERROR(EINVAL));
2914
2915         /* if we are not forcing, the branch point should be just before them */
2916         if (!force && clone->ds_prev != origin_head->ds_prev)
2917                 return (SET_ERROR(EINVAL));
2918
2919         /* clone should be the clone (unless they are unrelated) */
2920         if (clone->ds_prev != NULL &&
2921             clone->ds_prev != clone->ds_dir->dd_pool->dp_origin_snap &&
2922             origin_head->ds_dir != clone->ds_prev->ds_dir)
2923                 return (SET_ERROR(EINVAL));
2924
2925         /* the clone should be a child of the origin */
2926         if (clone->ds_dir->dd_parent != origin_head->ds_dir)
2927                 return (SET_ERROR(EINVAL));
2928
2929         /* origin_head shouldn't be modified unless 'force' */
2930         if (!force &&
2931             dsl_dataset_modified_since_snap(origin_head, origin_head->ds_prev))
2932                 return (SET_ERROR(ETXTBSY));
2933
2934         /* origin_head should have no long holds (e.g. is not mounted) */
2935         if (dsl_dataset_handoff_check(origin_head, owner, tx))
2936                 return (SET_ERROR(EBUSY));
2937
2938         /* check amount of any unconsumed refreservation */
2939         unused_refres_delta =
2940             (int64_t)MIN(origin_head->ds_reserved,
2941             dsl_dataset_phys(origin_head)->ds_unique_bytes) -
2942             (int64_t)MIN(origin_head->ds_reserved,
2943             dsl_dataset_phys(clone)->ds_unique_bytes);
2944
2945         if (unused_refres_delta > 0 &&
2946             unused_refres_delta >
2947             dsl_dir_space_available(origin_head->ds_dir, NULL, 0, TRUE))
2948                 return (SET_ERROR(ENOSPC));
2949
2950         /*
2951          * The clone can't be too much over the head's refquota.
2952          *
2953          * To ensure that the entire refquota can be used, we allow one
2954          * transaction to exceed the the refquota.  Therefore, this check
2955          * needs to also allow for the space referenced to be more than the
2956          * refquota.  The maximum amount of space that one transaction can use
2957          * on disk is DMU_MAX_ACCESS * spa_asize_inflation.  Allowing this
2958          * overage ensures that we are able to receive a filesystem that
2959          * exceeds the refquota on the source system.
2960          *
2961          * So that overage is the refquota_slack we use below.
2962          */
2963         if (origin_head->ds_quota != 0 &&
2964             dsl_dataset_phys(clone)->ds_referenced_bytes >
2965             origin_head->ds_quota + refquota_slack)
2966                 return (SET_ERROR(EDQUOT));
2967
2968         return (0);
2969 }
2970
2971 void
2972 dsl_dataset_clone_swap_sync_impl(dsl_dataset_t *clone,
2973     dsl_dataset_t *origin_head, dmu_tx_t *tx)
2974 {
2975         dsl_pool_t *dp = dmu_tx_pool(tx);
2976         int64_t unused_refres_delta;
2977
2978         ASSERT(clone->ds_reserved == 0);
2979         /*
2980          * NOTE: On DEBUG kernels there could be a race between this and
2981          * the check function if spa_asize_inflation is adjusted...
2982          */
2983         ASSERT(origin_head->ds_quota == 0 ||
2984             dsl_dataset_phys(clone)->ds_unique_bytes <= origin_head->ds_quota +
2985             DMU_MAX_ACCESS * spa_asize_inflation);
2986         ASSERT3P(clone->ds_prev, ==, origin_head->ds_prev);
2987
2988         /*
2989          * Swap per-dataset feature flags.
2990          */
2991         for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
2992                 if (!(spa_feature_table[f].fi_flags &
2993                     ZFEATURE_FLAG_PER_DATASET)) {
2994                         ASSERT(!clone->ds_feature_inuse[f]);
2995                         ASSERT(!origin_head->ds_feature_inuse[f]);
2996                         continue;
2997                 }
2998
2999                 boolean_t clone_inuse = clone->ds_feature_inuse[f];
3000                 boolean_t origin_head_inuse = origin_head->ds_feature_inuse[f];
3001
3002                 if (clone_inuse) {
3003                         dsl_dataset_deactivate_feature(clone->ds_object, f, tx);
3004                         clone->ds_feature_inuse[f] = B_FALSE;
3005                 }
3006                 if (origin_head_inuse) {
3007                         dsl_dataset_deactivate_feature(origin_head->ds_object,
3008                             f, tx);
3009                         origin_head->ds_feature_inuse[f] = B_FALSE;
3010                 }
3011                 if (clone_inuse) {
3012                         dsl_dataset_activate_feature(origin_head->ds_object,
3013                             f, tx);
3014                         origin_head->ds_feature_inuse[f] = B_TRUE;
3015                 }
3016                 if (origin_head_inuse) {
3017                         dsl_dataset_activate_feature(clone->ds_object, f, tx);
3018                         clone->ds_feature_inuse[f] = B_TRUE;
3019                 }
3020         }
3021
3022         dmu_buf_will_dirty(clone->ds_dbuf, tx);
3023         dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
3024
3025         if (clone->ds_objset != NULL) {
3026                 dmu_objset_evict(clone->ds_objset);
3027                 clone->ds_objset = NULL;
3028         }
3029
3030         if (origin_head->ds_objset != NULL) {
3031                 dmu_objset_evict(origin_head->ds_objset);
3032                 origin_head->ds_objset = NULL;
3033         }
3034
3035         unused_refres_delta =
3036             (int64_t)MIN(origin_head->ds_reserved,
3037             dsl_dataset_phys(origin_head)->ds_unique_bytes) -
3038             (int64_t)MIN(origin_head->ds_reserved,
3039             dsl_dataset_phys(clone)->ds_unique_bytes);
3040
3041         /*
3042          * Reset origin's unique bytes, if it exists.
3043          */
3044         if (clone->ds_prev) {
3045                 dsl_dataset_t *origin = clone->ds_prev;
3046                 uint64_t comp, uncomp;
3047
3048                 dmu_buf_will_dirty(origin->ds_dbuf, tx);
3049                 dsl_deadlist_space_range(&clone->ds_deadlist,
3050                     dsl_dataset_phys(origin)->ds_prev_snap_txg, UINT64_MAX,
3051                     &dsl_dataset_phys(origin)->ds_unique_bytes, &comp, &uncomp);
3052         }
3053
3054         /* swap blkptrs */
3055         {
3056                 blkptr_t tmp;
3057                 tmp = dsl_dataset_phys(origin_head)->ds_bp;
3058                 dsl_dataset_phys(origin_head)->ds_bp =
3059                     dsl_dataset_phys(clone)->ds_bp;
3060                 dsl_dataset_phys(clone)->ds_bp = tmp;
3061         }
3062
3063         /* set dd_*_bytes */
3064         {
3065                 int64_t dused, dcomp, duncomp;
3066                 uint64_t cdl_used, cdl_comp, cdl_uncomp;
3067                 uint64_t odl_used, odl_comp, odl_uncomp;
3068
3069                 ASSERT3U(dsl_dir_phys(clone->ds_dir)->
3070                     dd_used_breakdown[DD_USED_SNAP], ==, 0);
3071
3072                 dsl_deadlist_space(&clone->ds_deadlist,
3073                     &cdl_used, &cdl_comp, &cdl_uncomp);
3074                 dsl_deadlist_space(&origin_head->ds_deadlist,
3075                     &odl_used, &odl_comp, &odl_uncomp);
3076
3077                 dused = dsl_dataset_phys(clone)->ds_referenced_bytes +
3078                     cdl_used -
3079                     (dsl_dataset_phys(origin_head)->ds_referenced_bytes +
3080                     odl_used);
3081                 dcomp = dsl_dataset_phys(clone)->ds_compressed_bytes +
3082                     cdl_comp -
3083                     (dsl_dataset_phys(origin_head)->ds_compressed_bytes +
3084                     odl_comp);
3085                 duncomp = dsl_dataset_phys(clone)->ds_uncompressed_bytes +
3086                     cdl_uncomp -
3087                     (dsl_dataset_phys(origin_head)->ds_uncompressed_bytes +
3088                     odl_uncomp);
3089
3090                 dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_HEAD,
3091                     dused, dcomp, duncomp, tx);
3092                 dsl_dir_diduse_space(clone->ds_dir, DD_USED_HEAD,
3093                     -dused, -dcomp, -duncomp, tx);
3094
3095                 /*
3096                  * The difference in the space used by snapshots is the
3097                  * difference in snapshot space due to the head's
3098                  * deadlist (since that's the only thing that's
3099                  * changing that affects the snapused).
3100                  */
3101                 dsl_deadlist_space_range(&clone->ds_deadlist,
3102                     origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
3103                     &cdl_used, &cdl_comp, &cdl_uncomp);
3104                 dsl_deadlist_space_range(&origin_head->ds_deadlist,
3105                     origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
3106                     &odl_used, &odl_comp, &odl_uncomp);
3107                 dsl_dir_transfer_space(origin_head->ds_dir, cdl_used - odl_used,
3108                     DD_USED_HEAD, DD_USED_SNAP, NULL);
3109         }
3110
3111         /* swap ds_*_bytes */
3112         SWITCH64(dsl_dataset_phys(origin_head)->ds_referenced_bytes,
3113             dsl_dataset_phys(clone)->ds_referenced_bytes);
3114         SWITCH64(dsl_dataset_phys(origin_head)->ds_compressed_bytes,
3115             dsl_dataset_phys(clone)->ds_compressed_bytes);
3116         SWITCH64(dsl_dataset_phys(origin_head)->ds_uncompressed_bytes,
3117             dsl_dataset_phys(clone)->ds_uncompressed_bytes);
3118         SWITCH64(dsl_dataset_phys(origin_head)->ds_unique_bytes,
3119             dsl_dataset_phys(clone)->ds_unique_bytes);
3120
3121         /* apply any parent delta for change in unconsumed refreservation */
3122         dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_REFRSRV,
3123             unused_refres_delta, 0, 0, tx);
3124
3125         /*
3126          * Swap deadlists.
3127          */
3128         dsl_deadlist_close(&clone->ds_deadlist);
3129         dsl_deadlist_close(&origin_head->ds_deadlist);
3130         SWITCH64(dsl_dataset_phys(origin_head)->ds_deadlist_obj,
3131             dsl_dataset_phys(clone)->ds_deadlist_obj);
3132         dsl_deadlist_open(&clone->ds_deadlist, dp->dp_meta_objset,
3133             dsl_dataset_phys(clone)->ds_deadlist_obj);
3134         dsl_deadlist_open(&origin_head->ds_deadlist, dp->dp_meta_objset,
3135             dsl_dataset_phys(origin_head)->ds_deadlist_obj);
3136
3137         dsl_scan_ds_clone_swapped(origin_head, clone, tx);
3138
3139         spa_history_log_internal_ds(clone, "clone swap", tx,
3140             "parent=%s", origin_head->ds_dir->dd_myname);
3141 }
3142
3143 /*
3144  * Given a pool name and a dataset object number in that pool,
3145  * return the name of that dataset.
3146  */
3147 int
3148 dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf)
3149 {
3150         dsl_pool_t *dp;
3151         dsl_dataset_t *ds;
3152         int error;
3153
3154         error = dsl_pool_hold(pname, FTAG, &dp);
3155         if (error != 0)
3156                 return (error);
3157
3158         error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
3159         if (error == 0) {
3160                 dsl_dataset_name(ds, buf);
3161                 dsl_dataset_rele(ds, FTAG);
3162         }
3163         dsl_pool_rele(dp, FTAG);
3164
3165         return (error);
3166 }
3167
3168 int
3169 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
3170     uint64_t asize, uint64_t inflight, uint64_t *used, uint64_t *ref_rsrv)
3171 {
3172         int error = 0;
3173
3174         ASSERT3S(asize, >, 0);
3175
3176         /*
3177          * *ref_rsrv is the portion of asize that will come from any
3178          * unconsumed refreservation space.
3179          */
3180         *ref_rsrv = 0;
3181
3182         mutex_enter(&ds->ds_lock);
3183         /*
3184          * Make a space adjustment for reserved bytes.
3185          */
3186         if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
3187                 ASSERT3U(*used, >=,
3188                     ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
3189                 *used -=
3190                     (ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
3191                 *ref_rsrv =
3192                     asize - MIN(asize, parent_delta(ds, asize + inflight));
3193         }
3194
3195         if (!check_quota || ds->ds_quota == 0) {
3196                 mutex_exit(&ds->ds_lock);
3197                 return (0);
3198         }
3199         /*
3200          * If they are requesting more space, and our current estimate
3201          * is over quota, they get to try again unless the actual
3202          * on-disk is over quota and there are no pending changes (which
3203          * may free up space for us).
3204          */
3205         if (dsl_dataset_phys(ds)->ds_referenced_bytes + inflight >=
3206             ds->ds_quota) {
3207                 if (inflight > 0 ||
3208                     dsl_dataset_phys(ds)->ds_referenced_bytes < ds->ds_quota)
3209                         error = SET_ERROR(ERESTART);
3210                 else
3211                         error = SET_ERROR(EDQUOT);
3212         }
3213         mutex_exit(&ds->ds_lock);
3214
3215         return (error);
3216 }
3217
3218 typedef struct dsl_dataset_set_qr_arg {
3219         const char *ddsqra_name;
3220         zprop_source_t ddsqra_source;
3221         uint64_t ddsqra_value;
3222 } dsl_dataset_set_qr_arg_t;
3223
3224
3225 /* ARGSUSED */
3226 static int
3227 dsl_dataset_set_refquota_check(void *arg, dmu_tx_t *tx)
3228 {
3229         dsl_dataset_set_qr_arg_t *ddsqra = arg;
3230         dsl_pool_t *dp = dmu_tx_pool(tx);
3231         dsl_dataset_t *ds;
3232         int error;
3233         uint64_t newval;
3234
3235         if (spa_version(dp->dp_spa) < SPA_VERSION_REFQUOTA)
3236                 return (SET_ERROR(ENOTSUP));
3237
3238         error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
3239         if (error != 0)
3240                 return (error);
3241
3242         if (ds->ds_is_snapshot) {
3243                 dsl_dataset_rele(ds, FTAG);
3244                 return (SET_ERROR(EINVAL));
3245         }
3246
3247         error = dsl_prop_predict(ds->ds_dir,
3248             zfs_prop_to_name(ZFS_PROP_REFQUOTA),
3249             ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
3250         if (error != 0) {
3251                 dsl_dataset_rele(ds, FTAG);
3252                 return (error);
3253         }
3254
3255         if (newval == 0) {
3256                 dsl_dataset_rele(ds, FTAG);
3257                 return (0);
3258         }
3259
3260         if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
3261             newval < ds->ds_reserved) {
3262                 dsl_dataset_rele(ds, FTAG);
3263                 return (SET_ERROR(ENOSPC));
3264         }
3265
3266         dsl_dataset_rele(ds, FTAG);
3267         return (0);
3268 }
3269
3270 static void
3271 dsl_dataset_set_refquota_sync(void *arg, dmu_tx_t *tx)
3272 {
3273         dsl_dataset_set_qr_arg_t *ddsqra = arg;
3274         dsl_pool_t *dp = dmu_tx_pool(tx);
3275         dsl_dataset_t *ds;
3276         uint64_t newval;
3277
3278         VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
3279
3280         dsl_prop_set_sync_impl(ds,
3281             zfs_prop_to_name(ZFS_PROP_REFQUOTA),
3282             ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1,
3283             &ddsqra->ddsqra_value, tx);
3284
3285         VERIFY0(dsl_prop_get_int_ds(ds,
3286             zfs_prop_to_name(ZFS_PROP_REFQUOTA), &newval));
3287
3288         if (ds->ds_quota != newval) {
3289                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
3290                 ds->ds_quota = newval;
3291         }
3292         dsl_dataset_rele(ds, FTAG);
3293 }
3294
3295 int
3296 dsl_dataset_set_refquota(const char *dsname, zprop_source_t source,
3297     uint64_t refquota)
3298 {
3299         dsl_dataset_set_qr_arg_t ddsqra;
3300
3301         ddsqra.ddsqra_name = dsname;
3302         ddsqra.ddsqra_source = source;
3303         ddsqra.ddsqra_value = refquota;
3304
3305         return (dsl_sync_task(dsname, dsl_dataset_set_refquota_check,
3306             dsl_dataset_set_refquota_sync, &ddsqra, 0, ZFS_SPACE_CHECK_NONE));
3307 }
3308
3309 static int
3310 dsl_dataset_set_refreservation_check(void *arg, dmu_tx_t *tx)
3311 {
3312         dsl_dataset_set_qr_arg_t *ddsqra = arg;
3313         dsl_pool_t *dp = dmu_tx_pool(tx);
3314         dsl_dataset_t *ds;
3315         int error;
3316         uint64_t newval, unique;
3317
3318         if (spa_version(dp->dp_spa) < SPA_VERSION_REFRESERVATION)
3319                 return (SET_ERROR(ENOTSUP));
3320
3321         error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
3322         if (error != 0)
3323                 return (error);
3324
3325         if (ds->ds_is_snapshot) {
3326                 dsl_dataset_rele(ds, FTAG);
3327                 return (SET_ERROR(EINVAL));
3328         }
3329
3330         error = dsl_prop_predict(ds->ds_dir,
3331             zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
3332             ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
3333         if (error != 0) {
3334                 dsl_dataset_rele(ds, FTAG);
3335                 return (error);
3336         }
3337
3338         /*
3339          * If we are doing the preliminary check in open context, the
3340          * space estimates may be inaccurate.
3341          */
3342         if (!dmu_tx_is_syncing(tx)) {
3343                 dsl_dataset_rele(ds, FTAG);
3344                 return (0);
3345         }
3346
3347         mutex_enter(&ds->ds_lock);
3348         if (!DS_UNIQUE_IS_ACCURATE(ds))
3349                 dsl_dataset_recalc_head_uniq(ds);
3350         unique = dsl_dataset_phys(ds)->ds_unique_bytes;
3351         mutex_exit(&ds->ds_lock);
3352
3353         if (MAX(unique, newval) > MAX(unique, ds->ds_reserved)) {
3354                 uint64_t delta = MAX(unique, newval) -
3355                     MAX(unique, ds->ds_reserved);
3356
3357                 if (delta >
3358                     dsl_dir_space_available(ds->ds_dir, NULL, 0, B_TRUE) ||
3359                     (ds->ds_quota > 0 && newval > ds->ds_quota)) {
3360                         dsl_dataset_rele(ds, FTAG);
3361                         return (SET_ERROR(ENOSPC));
3362                 }
3363         }
3364
3365         dsl_dataset_rele(ds, FTAG);
3366         return (0);
3367 }
3368
3369 void
3370 dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
3371     zprop_source_t source, uint64_t value, dmu_tx_t *tx)
3372 {
3373         uint64_t newval;
3374         uint64_t unique;
3375         int64_t delta;
3376
3377         dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
3378             source, sizeof (value), 1, &value, tx);
3379
3380         VERIFY0(dsl_prop_get_int_ds(ds,
3381             zfs_prop_to_name(ZFS_PROP_REFRESERVATION), &newval));
3382
3383         dmu_buf_will_dirty(ds->ds_dbuf, tx);
3384         mutex_enter(&ds->ds_dir->dd_lock);
3385         mutex_enter(&ds->ds_lock);
3386         ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
3387         unique = dsl_dataset_phys(ds)->ds_unique_bytes;
3388         delta = MAX(0, (int64_t)(newval - unique)) -
3389             MAX(0, (int64_t)(ds->ds_reserved - unique));
3390         ds->ds_reserved = newval;
3391         mutex_exit(&ds->ds_lock);
3392
3393         dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
3394         mutex_exit(&ds->ds_dir->dd_lock);
3395 }
3396
3397 static void
3398 dsl_dataset_set_refreservation_sync(void *arg, dmu_tx_t *tx)
3399 {
3400         dsl_dataset_set_qr_arg_t *ddsqra = arg;
3401         dsl_pool_t *dp = dmu_tx_pool(tx);
3402         dsl_dataset_t *ds;
3403
3404         VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
3405         dsl_dataset_set_refreservation_sync_impl(ds,
3406             ddsqra->ddsqra_source, ddsqra->ddsqra_value, tx);
3407         dsl_dataset_rele(ds, FTAG);
3408 }
3409
3410 int
3411 dsl_dataset_set_refreservation(const char *dsname, zprop_source_t source,
3412     uint64_t refreservation)
3413 {
3414         dsl_dataset_set_qr_arg_t ddsqra;
3415
3416         ddsqra.ddsqra_name = dsname;
3417         ddsqra.ddsqra_source = source;
3418         ddsqra.ddsqra_value = refreservation;
3419
3420         return (dsl_sync_task(dsname, dsl_dataset_set_refreservation_check,
3421             dsl_dataset_set_refreservation_sync, &ddsqra,
3422             0, ZFS_SPACE_CHECK_NONE));
3423 }
3424
3425 /*
3426  * Return (in *usedp) the amount of space written in new that is not
3427  * present in oldsnap.  New may be a snapshot or the head.  Old must be
3428  * a snapshot before new, in new's filesystem (or its origin).  If not then
3429  * fail and return EINVAL.
3430  *
3431  * The written space is calculated by considering two components:  First, we
3432  * ignore any freed space, and calculate the written as new's used space
3433  * minus old's used space.  Next, we add in the amount of space that was freed
3434  * between the two snapshots, thus reducing new's used space relative to old's.
3435  * Specifically, this is the space that was born before old->ds_creation_txg,
3436  * and freed before new (ie. on new's deadlist or a previous deadlist).
3437  *
3438  * space freed                         [---------------------]
3439  * snapshots                       ---O-------O--------O-------O------
3440  *                                         oldsnap            new
3441  */
3442 int
3443 dsl_dataset_space_written(dsl_dataset_t *oldsnap, dsl_dataset_t *new,
3444     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
3445 {
3446         int err = 0;
3447         uint64_t snapobj;
3448         dsl_pool_t *dp = new->ds_dir->dd_pool;
3449
3450         ASSERT(dsl_pool_config_held(dp));
3451
3452         *usedp = 0;
3453         *usedp += dsl_dataset_phys(new)->ds_referenced_bytes;
3454         *usedp -= dsl_dataset_phys(oldsnap)->ds_referenced_bytes;
3455
3456         *compp = 0;
3457         *compp += dsl_dataset_phys(new)->ds_compressed_bytes;
3458         *compp -= dsl_dataset_phys(oldsnap)->ds_compressed_bytes;
3459
3460         *uncompp = 0;
3461         *uncompp += dsl_dataset_phys(new)->ds_uncompressed_bytes;
3462         *uncompp -= dsl_dataset_phys(oldsnap)->ds_uncompressed_bytes;
3463
3464         snapobj = new->ds_object;
3465         while (snapobj != oldsnap->ds_object) {
3466                 dsl_dataset_t *snap;
3467                 uint64_t used, comp, uncomp;
3468
3469                 if (snapobj == new->ds_object) {
3470                         snap = new;
3471                 } else {
3472                         err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &snap);
3473                         if (err != 0)
3474                                 break;
3475                 }
3476
3477                 if (dsl_dataset_phys(snap)->ds_prev_snap_txg ==
3478                     dsl_dataset_phys(oldsnap)->ds_creation_txg) {
3479                         /*
3480                          * The blocks in the deadlist can not be born after
3481                          * ds_prev_snap_txg, so get the whole deadlist space,
3482                          * which is more efficient (especially for old-format
3483                          * deadlists).  Unfortunately the deadlist code
3484                          * doesn't have enough information to make this
3485                          * optimization itself.
3486                          */
3487                         dsl_deadlist_space(&snap->ds_deadlist,
3488                             &used, &comp, &uncomp);
3489                 } else {
3490                         dsl_deadlist_space_range(&snap->ds_deadlist,
3491                             0, dsl_dataset_phys(oldsnap)->ds_creation_txg,
3492                             &used, &comp, &uncomp);
3493                 }
3494                 *usedp += used;
3495                 *compp += comp;
3496                 *uncompp += uncomp;
3497
3498                 /*
3499                  * If we get to the beginning of the chain of snapshots
3500                  * (ds_prev_snap_obj == 0) before oldsnap, then oldsnap
3501                  * was not a snapshot of/before new.
3502                  */
3503                 snapobj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
3504                 if (snap != new)
3505                         dsl_dataset_rele(snap, FTAG);
3506                 if (snapobj == 0) {
3507                         err = SET_ERROR(EINVAL);
3508                         break;
3509                 }
3510
3511         }
3512         return (err);
3513 }
3514
3515 /*
3516  * Return (in *usedp) the amount of space that will be reclaimed if firstsnap,
3517  * lastsnap, and all snapshots in between are deleted.
3518  *
3519  * blocks that would be freed            [---------------------------]
3520  * snapshots                       ---O-------O--------O-------O--------O
3521  *                                        firstsnap        lastsnap
3522  *
3523  * This is the set of blocks that were born after the snap before firstsnap,
3524  * (birth > firstsnap->prev_snap_txg) and died before the snap after the
3525  * last snap (ie, is on lastsnap->ds_next->ds_deadlist or an earlier deadlist).
3526  * We calculate this by iterating over the relevant deadlists (from the snap
3527  * after lastsnap, backward to the snap after firstsnap), summing up the
3528  * space on the deadlist that was born after the snap before firstsnap.
3529  */
3530 int
3531 dsl_dataset_space_wouldfree(dsl_dataset_t *firstsnap,
3532     dsl_dataset_t *lastsnap,
3533     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
3534 {
3535         int err = 0;
3536         uint64_t snapobj;
3537         dsl_pool_t *dp = firstsnap->ds_dir->dd_pool;
3538
3539         ASSERT(firstsnap->ds_is_snapshot);
3540         ASSERT(lastsnap->ds_is_snapshot);
3541
3542         /*
3543          * Check that the snapshots are in the same dsl_dir, and firstsnap
3544          * is before lastsnap.
3545          */
3546         if (firstsnap->ds_dir != lastsnap->ds_dir ||
3547             dsl_dataset_phys(firstsnap)->ds_creation_txg >
3548             dsl_dataset_phys(lastsnap)->ds_creation_txg)
3549                 return (SET_ERROR(EINVAL));
3550
3551         *usedp = *compp = *uncompp = 0;
3552
3553         snapobj = dsl_dataset_phys(lastsnap)->ds_next_snap_obj;
3554         while (snapobj != firstsnap->ds_object) {
3555                 dsl_dataset_t *ds;
3556                 uint64_t used, comp, uncomp;
3557
3558                 err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &ds);
3559                 if (err != 0)
3560                         break;
3561
3562                 dsl_deadlist_space_range(&ds->ds_deadlist,
3563                     dsl_dataset_phys(firstsnap)->ds_prev_snap_txg, UINT64_MAX,
3564                     &used, &comp, &uncomp);
3565                 *usedp += used;
3566                 *compp += comp;
3567                 *uncompp += uncomp;
3568
3569                 snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
3570                 ASSERT3U(snapobj, !=, 0);
3571                 dsl_dataset_rele(ds, FTAG);
3572         }
3573         return (err);
3574 }
3575
3576 /*
3577  * Return TRUE if 'earlier' is an earlier snapshot in 'later's timeline.
3578  * For example, they could both be snapshots of the same filesystem, and
3579  * 'earlier' is before 'later'.  Or 'earlier' could be the origin of
3580  * 'later's filesystem.  Or 'earlier' could be an older snapshot in the origin's
3581  * filesystem.  Or 'earlier' could be the origin's origin.
3582  *
3583  * If non-zero, earlier_txg is used instead of earlier's ds_creation_txg.
3584  */
3585 boolean_t
3586 dsl_dataset_is_before(dsl_dataset_t *later, dsl_dataset_t *earlier,
3587     uint64_t earlier_txg)
3588 {
3589         dsl_pool_t *dp = later->ds_dir->dd_pool;
3590         int error;
3591         boolean_t ret;
3592
3593         ASSERT(dsl_pool_config_held(dp));
3594         ASSERT(earlier->ds_is_snapshot || earlier_txg != 0);
3595
3596         if (earlier_txg == 0)
3597                 earlier_txg = dsl_dataset_phys(earlier)->ds_creation_txg;
3598
3599         if (later->ds_is_snapshot &&
3600             earlier_txg >= dsl_dataset_phys(later)->ds_creation_txg)
3601                 return (B_FALSE);
3602
3603         if (later->ds_dir == earlier->ds_dir)
3604                 return (B_TRUE);
3605         if (!dsl_dir_is_clone(later->ds_dir))
3606                 return (B_FALSE);
3607
3608         if (dsl_dir_phys(later->ds_dir)->dd_origin_obj == earlier->ds_object)
3609                 return (B_TRUE);
3610         dsl_dataset_t *origin;
3611         error = dsl_dataset_hold_obj(dp,
3612             dsl_dir_phys(later->ds_dir)->dd_origin_obj, FTAG, &origin);
3613         if (error != 0)
3614                 return (B_FALSE);
3615         ret = dsl_dataset_is_before(origin, earlier, earlier_txg);
3616         dsl_dataset_rele(origin, FTAG);
3617         return (ret);
3618 }
3619
3620 void
3621 dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx)
3622 {
3623         objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
3624         dmu_object_zapify(mos, ds->ds_object, DMU_OT_DSL_DATASET, tx);
3625 }
3626
3627 boolean_t
3628 dsl_dataset_is_zapified(dsl_dataset_t *ds)
3629 {
3630         dmu_object_info_t doi;
3631
3632         dmu_object_info_from_db(ds->ds_dbuf, &doi);
3633         return (doi.doi_type == DMU_OTN_ZAP_METADATA);
3634 }
3635
3636 boolean_t
3637 dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds)
3638 {
3639         return (dsl_dataset_is_zapified(ds) &&
3640             zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
3641             ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
3642 }