module/zfs/dsl_dataset.c

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