sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_pool.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) 2013 by Delphix. All rights reserved.
  24  */
  25
  26 #include <sys/dsl_pool.h>
  27 #include <sys/dsl_dataset.h>
  28 #include <sys/dsl_prop.h>
  29 #include <sys/dsl_dir.h>
  30 #include <sys/dsl_synctask.h>
  31 #include <sys/dsl_scan.h>
  32 #include <sys/dnode.h>
  33 #include <sys/dmu_tx.h>
  34 #include <sys/dmu_objset.h>
  35 #include <sys/arc.h>
  36 #include <sys/zap.h>
  37 #include <sys/zio.h>
  38 #include <sys/zfs_context.h>
  39 #include <sys/fs/zfs.h>
  40 #include <sys/zfs_znode.h>
  41 #include <sys/spa_impl.h>
  42 #include <sys/dsl_deadlist.h>
  43 #include <sys/bptree.h>
  44 #include <sys/zfeature.h>
  45 #include <sys/zil_impl.h>
  46 #include <sys/dsl_userhold.h>
  47
  48 int zfs_no_write_throttle = 0;
  49 int zfs_write_limit_shift = 3;                  /* 1/8th of physical memory */
  50 int zfs_txg_synctime_ms = 1000;         /* target millisecs to sync a txg */
  51
  52 uint64_t zfs_write_limit_min = 32 << 20;        /* min write limit is 32MB */
  53 uint64_t zfs_write_limit_max = 0;               /* max data payload per txg */
  54 uint64_t zfs_write_limit_inflated = 0;
  55 uint64_t zfs_write_limit_override = 0;
  56
  57 kmutex_t zfs_write_limit_lock;
  58
  59 static pgcnt_t old_physmem = 0;
  60
  61 SYSCTL_DECL(_vfs_zfs);
  62 TUNABLE_INT("vfs.zfs.no_write_throttle", &zfs_no_write_throttle);
  63 SYSCTL_INT(_vfs_zfs, OID_AUTO, no_write_throttle, CTLFLAG_RDTUN,
  64     &zfs_no_write_throttle, 0, "");
  65 TUNABLE_INT("vfs.zfs.write_limit_shift", &zfs_write_limit_shift);
  66 SYSCTL_INT(_vfs_zfs, OID_AUTO, write_limit_shift, CTLFLAG_RDTUN,
  67     &zfs_write_limit_shift, 0, "2^N of physical memory");
  68 SYSCTL_DECL(_vfs_zfs_txg);
  69 TUNABLE_INT("vfs.zfs.txg.synctime_ms", &zfs_txg_synctime_ms);
  70 SYSCTL_INT(_vfs_zfs_txg, OID_AUTO, synctime_ms, CTLFLAG_RDTUN,
  71     &zfs_txg_synctime_ms, 0, "Target milliseconds to sync a txg");
  72
  73 TUNABLE_QUAD("vfs.zfs.write_limit_min", &zfs_write_limit_min);
  74 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_min, CTLFLAG_RDTUN,
  75     &zfs_write_limit_min, 0, "Minimum write limit");
  76 TUNABLE_QUAD("vfs.zfs.write_limit_max", &zfs_write_limit_max);
  77 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_max, CTLFLAG_RDTUN,
  78     &zfs_write_limit_max, 0, "Maximum data payload per txg");
  79 TUNABLE_QUAD("vfs.zfs.write_limit_inflated", &zfs_write_limit_inflated);
  80 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_inflated, CTLFLAG_RDTUN,
  81     &zfs_write_limit_inflated, 0, "Maximum size of the dynamic write limit");
  82 TUNABLE_QUAD("vfs.zfs.write_limit_override", &zfs_write_limit_override);
  83 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_override, CTLFLAG_RDTUN,
  84     &zfs_write_limit_override, 0,
  85     "Force a txg if dirty buffers exceed this value (bytes)");
  86
  87 int
  88 dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp)
  89 {
  90         uint64_t obj;
  91         int err;
  92
  93         err = zap_lookup(dp->dp_meta_objset,
  94             dp->dp_root_dir->dd_phys->dd_child_dir_zapobj,
  95             name, sizeof (obj), 1, &obj);
  96         if (err)
  97                 return (err);
  98
  99         return (dsl_dir_hold_obj(dp, obj, name, dp, ddp));
 100 }
 101
 102 static dsl_pool_t *
 103 dsl_pool_open_impl(spa_t *spa, uint64_t txg)
 104 {
 105         dsl_pool_t *dp;
 106         blkptr_t *bp = spa_get_rootblkptr(spa);
 107
 108         dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP);
 109         dp->dp_spa = spa;
 110         dp->dp_meta_rootbp = *bp;
 111         rrw_init(&dp->dp_config_rwlock, B_TRUE);
 112         dp->dp_write_limit = zfs_write_limit_min;
 113         txg_init(dp, txg);
 114
 115         txg_list_create(&dp->dp_dirty_datasets,
 116             offsetof(dsl_dataset_t, ds_dirty_link));
 117         txg_list_create(&dp->dp_dirty_zilogs,
 118             offsetof(zilog_t, zl_dirty_link));
 119         txg_list_create(&dp->dp_dirty_dirs,
 120             offsetof(dsl_dir_t, dd_dirty_link));
 121         txg_list_create(&dp->dp_sync_tasks,
 122             offsetof(dsl_sync_task_t, dst_node));
 123
 124         mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL);
 125
 126         dp->dp_vnrele_taskq = taskq_create("zfs_vn_rele_taskq", 1, minclsyspri,
 127             1, 4, 0);
 128
 129         return (dp);
 130 }
 131
 132 int
 133 dsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp)
 134 {
 135         int err;
 136         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
 137
 138         err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp,
 139             &dp->dp_meta_objset);
 140         if (err != 0)
 141                 dsl_pool_close(dp);
 142         else
 143                 *dpp = dp;
 144
 145         return (err);
 146 }
 147
 148 int
 149 dsl_pool_open(dsl_pool_t *dp)
 150 {
 151         int err;
 152         dsl_dir_t *dd;
 153         dsl_dataset_t *ds;
 154         uint64_t obj;
 155
 156         rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
 157         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 158             DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1,
 159             &dp->dp_root_dir_obj);
 160         if (err)
 161                 goto out;
 162
 163         err = dsl_dir_hold_obj(dp, dp->dp_root_dir_obj,
 164             NULL, dp, &dp->dp_root_dir);
 165         if (err)
 166                 goto out;
 167
 168         err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir);
 169         if (err)
 170                 goto out;
 171
 172         if (spa_version(dp->dp_spa) >= SPA_VERSION_ORIGIN) {
 173                 err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd);
 174                 if (err)
 175                         goto out;
 176                 err = dsl_dataset_hold_obj(dp, dd->dd_phys->dd_head_dataset_obj,
 177                     FTAG, &ds);
 178                 if (err == 0) {
 179                         err = dsl_dataset_hold_obj(dp,
 180                             ds->ds_phys->ds_prev_snap_obj, dp,
 181                             &dp->dp_origin_snap);
 182                         dsl_dataset_rele(ds, FTAG);
 183                 }
 184                 dsl_dir_rele(dd, dp);
 185                 if (err)
 186                         goto out;
 187         }
 188
 189         if (spa_version(dp->dp_spa) >= SPA_VERSION_DEADLISTS) {
 190                 err = dsl_pool_open_special_dir(dp, FREE_DIR_NAME,
 191                     &dp->dp_free_dir);
 192                 if (err)
 193                         goto out;
 194
 195                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 196                     DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj);
 197                 if (err)
 198                         goto out;
 199                 VERIFY0(bpobj_open(&dp->dp_free_bpobj,
 200                     dp->dp_meta_objset, obj));
 201         }
 202
 203         if (spa_feature_is_active(dp->dp_spa,
 204             &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])) {
 205                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 206                     DMU_POOL_BPTREE_OBJ, sizeof (uint64_t), 1,
 207                     &dp->dp_bptree_obj);
 208                 if (err != 0)
 209                         goto out;
 210         }
 211
 212         if (spa_feature_is_active(dp->dp_spa,
 213             &spa_feature_table[SPA_FEATURE_EMPTY_BPOBJ])) {
 214                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 215                     DMU_POOL_EMPTY_BPOBJ, sizeof (uint64_t), 1,
 216                     &dp->dp_empty_bpobj);
 217                 if (err != 0)
 218                         goto out;
 219         }
 220
 221         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 222             DMU_POOL_TMP_USERREFS, sizeof (uint64_t), 1,
 223             &dp->dp_tmp_userrefs_obj);
 224         if (err == ENOENT)
 225                 err = 0;
 226         if (err)
 227                 goto out;
 228
 229         err = dsl_scan_init(dp, dp->dp_tx.tx_open_txg);
 230
 231 out:
 232         rrw_exit(&dp->dp_config_rwlock, FTAG);
 233         return (err);
 234 }
 235
 236 void
 237 dsl_pool_close(dsl_pool_t *dp)
 238 {
 239         /* drop our references from dsl_pool_open() */
 240
 241         /*
 242          * Since we held the origin_snap from "syncing" context (which
 243          * includes pool-opening context), it actually only got a "ref"
 244          * and not a hold, so just drop that here.
 245          */
 246         if (dp->dp_origin_snap)
 247                 dsl_dataset_rele(dp->dp_origin_snap, dp);
 248         if (dp->dp_mos_dir)
 249                 dsl_dir_rele(dp->dp_mos_dir, dp);
 250         if (dp->dp_free_dir)
 251                 dsl_dir_rele(dp->dp_free_dir, dp);
 252         if (dp->dp_root_dir)
 253                 dsl_dir_rele(dp->dp_root_dir, dp);
 254
 255         bpobj_close(&dp->dp_free_bpobj);
 256
 257         /* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */
 258         if (dp->dp_meta_objset)
 259                 dmu_objset_evict(dp->dp_meta_objset);
 260
 261         txg_list_destroy(&dp->dp_dirty_datasets);
 262         txg_list_destroy(&dp->dp_dirty_zilogs);
 263         txg_list_destroy(&dp->dp_sync_tasks);
 264         txg_list_destroy(&dp->dp_dirty_dirs);
 265
 266         arc_flush(dp->dp_spa);
 267         txg_fini(dp);
 268         dsl_scan_fini(dp);
 269         rrw_destroy(&dp->dp_config_rwlock);
 270         mutex_destroy(&dp->dp_lock);
 271         taskq_destroy(dp->dp_vnrele_taskq);
 272         if (dp->dp_blkstats)
 273                 kmem_free(dp->dp_blkstats, sizeof (zfs_all_blkstats_t));
 274         kmem_free(dp, sizeof (dsl_pool_t));
 275 }
 276
 277 dsl_pool_t *
 278 dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg)
 279 {
 280         int err;
 281         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
 282         dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);
 283         objset_t *os;
 284         dsl_dataset_t *ds;
 285         uint64_t obj;
 286
 287         rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
 288
 289         /* create and open the MOS (meta-objset) */
 290         dp->dp_meta_objset = dmu_objset_create_impl(spa,
 291             NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx);
 292
 293         /* create the pool directory */
 294         err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 295             DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
 296         ASSERT0(err);
 297
 298         /* Initialize scan structures */
 299         VERIFY0(dsl_scan_init(dp, txg));
 300
 301         /* create and open the root dir */
 302         dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx);
 303         VERIFY0(dsl_dir_hold_obj(dp, dp->dp_root_dir_obj,
 304             NULL, dp, &dp->dp_root_dir));
 305
 306         /* create and open the meta-objset dir */
 307         (void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx);
 308         VERIFY0(dsl_pool_open_special_dir(dp,
 309             MOS_DIR_NAME, &dp->dp_mos_dir));
 310
 311         if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
 312                 /* create and open the free dir */
 313                 (void) dsl_dir_create_sync(dp, dp->dp_root_dir,
 314                     FREE_DIR_NAME, tx);
 315                 VERIFY0(dsl_pool_open_special_dir(dp,
 316                     FREE_DIR_NAME, &dp->dp_free_dir));
 317
 318                 /* create and open the free_bplist */
 319                 obj = bpobj_alloc(dp->dp_meta_objset, SPA_MAXBLOCKSIZE, tx);
 320                 VERIFY(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 321                     DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx) == 0);
 322                 VERIFY0(bpobj_open(&dp->dp_free_bpobj,
 323                     dp->dp_meta_objset, obj));
 324         }
 325
 326         if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB)
 327                 dsl_pool_create_origin(dp, tx);
 328
 329         /* create the root dataset */
 330         obj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx);
 331
 332         /* create the root objset */
 333         VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG, &ds));
 334         os = dmu_objset_create_impl(dp->dp_spa, ds,
 335             dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx);
 336 #ifdef _KERNEL
 337         zfs_create_fs(os, kcred, zplprops, tx);
 338 #endif
 339         dsl_dataset_rele(ds, FTAG);
 340
 341         dmu_tx_commit(tx);
 342
 343         rrw_exit(&dp->dp_config_rwlock, FTAG);
 344
 345         return (dp);
 346 }
 347
 348 /*
 349  * Account for the meta-objset space in its placeholder dsl_dir.
 350  */
 351 void
 352 dsl_pool_mos_diduse_space(dsl_pool_t *dp,
 353     int64_t used, int64_t comp, int64_t uncomp)
 354 {
 355         ASSERT3U(comp, ==, uncomp); /* it's all metadata */
 356         mutex_enter(&dp->dp_lock);
 357         dp->dp_mos_used_delta += used;
 358         dp->dp_mos_compressed_delta += comp;
 359         dp->dp_mos_uncompressed_delta += uncomp;
 360         mutex_exit(&dp->dp_lock);
 361 }
 362
 363 static int
 364 deadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
 365 {
 366         dsl_deadlist_t *dl = arg;
 367         dsl_deadlist_insert(dl, bp, tx);
 368         return (0);
 369 }
 370
 371 void
 372 dsl_pool_sync(dsl_pool_t *dp, uint64_t txg)
 373 {
 374         zio_t *zio;
 375         dmu_tx_t *tx;
 376         dsl_dir_t *dd;
 377         dsl_dataset_t *ds;
 378         objset_t *mos = dp->dp_meta_objset;
 379         hrtime_t start, write_time;
 380         uint64_t data_written;
 381         int err;
 382         list_t synced_datasets;
 383
 384         list_create(&synced_datasets, sizeof (dsl_dataset_t),
 385             offsetof(dsl_dataset_t, ds_synced_link));
 386
 387         /*
 388          * We need to copy dp_space_towrite() before doing
 389          * dsl_sync_task_sync(), because
 390          * dsl_dataset_snapshot_reserve_space() will increase
 391          * dp_space_towrite but not actually write anything.
 392          */
 393         data_written = dp->dp_space_towrite[txg & TXG_MASK];
 394
 395         tx = dmu_tx_create_assigned(dp, txg);
 396
 397         dp->dp_read_overhead = 0;
 398         start = gethrtime();
 399
 400         zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 401         while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) {
 402                 /*
 403                  * We must not sync any non-MOS datasets twice, because
 404                  * we may have taken a snapshot of them.  However, we
 405                  * may sync newly-created datasets on pass 2.
 406                  */
 407                 ASSERT(!list_link_active(&ds->ds_synced_link));
 408                 list_insert_tail(&synced_datasets, ds);
 409                 dsl_dataset_sync(ds, zio, tx);
 410         }
 411         DTRACE_PROBE(pool_sync__1setup);
 412         err = zio_wait(zio);
 413
 414         write_time = gethrtime() - start;
 415         ASSERT(err == 0);
 416         DTRACE_PROBE(pool_sync__2rootzio);
 417
 418         /*
 419          * After the data blocks have been written (ensured by the zio_wait()
 420          * above), update the user/group space accounting.
 421          */
 422         for (ds = list_head(&synced_datasets); ds;
 423             ds = list_next(&synced_datasets, ds))
 424                 dmu_objset_do_userquota_updates(ds->ds_objset, tx);
 425
 426         /*
 427          * Sync the datasets again to push out the changes due to
 428          * userspace updates.  This must be done before we process the
 429          * sync tasks, so that any snapshots will have the correct
 430          * user accounting information (and we won't get confused
 431          * about which blocks are part of the snapshot).
 432          */
 433         zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 434         while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) {
 435                 ASSERT(list_link_active(&ds->ds_synced_link));
 436                 dmu_buf_rele(ds->ds_dbuf, ds);
 437                 dsl_dataset_sync(ds, zio, tx);
 438         }
 439         err = zio_wait(zio);
 440
 441         /*
 442          * Now that the datasets have been completely synced, we can
 443          * clean up our in-memory structures accumulated while syncing:
 444          *
 445          *  - move dead blocks from the pending deadlist to the on-disk deadlist
 446          *  - release hold from dsl_dataset_dirty()
 447          */
 448         while (ds = list_remove_head(&synced_datasets)) {
 449                 objset_t *os = ds->ds_objset;
 450                 bplist_iterate(&ds->ds_pending_deadlist,
 451                     deadlist_enqueue_cb, &ds->ds_deadlist, tx);
 452                 ASSERT(!dmu_objset_is_dirty(os, txg));
 453                 dmu_buf_rele(ds->ds_dbuf, ds);
 454         }
 455
 456         start = gethrtime();
 457         while (dd = txg_list_remove(&dp->dp_dirty_dirs, txg))
 458                 dsl_dir_sync(dd, tx);
 459         write_time += gethrtime() - start;
 460
 461         /*
 462          * The MOS's space is accounted for in the pool/$MOS
 463          * (dp_mos_dir).  We can't modify the mos while we're syncing
 464          * it, so we remember the deltas and apply them here.
 465          */
 466         if (dp->dp_mos_used_delta != 0 || dp->dp_mos_compressed_delta != 0 ||
 467             dp->dp_mos_uncompressed_delta != 0) {
 468                 dsl_dir_diduse_space(dp->dp_mos_dir, DD_USED_HEAD,
 469                     dp->dp_mos_used_delta,
 470                     dp->dp_mos_compressed_delta,
 471                     dp->dp_mos_uncompressed_delta, tx);
 472                 dp->dp_mos_used_delta = 0;
 473                 dp->dp_mos_compressed_delta = 0;
 474                 dp->dp_mos_uncompressed_delta = 0;
 475         }
 476
 477         start = gethrtime();
 478         if (list_head(&mos->os_dirty_dnodes[txg & TXG_MASK]) != NULL ||
 479             list_head(&mos->os_free_dnodes[txg & TXG_MASK]) != NULL) {
 480                 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 481                 dmu_objset_sync(mos, zio, tx);
 482                 err = zio_wait(zio);
 483                 ASSERT(err == 0);
 484                 dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", "");
 485                 spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp);
 486         }
 487         write_time += gethrtime() - start;
 488         DTRACE_PROBE2(pool_sync__4io, hrtime_t, write_time,
 489             hrtime_t, dp->dp_read_overhead);
 490         write_time -= dp->dp_read_overhead;
 491
 492         /*
 493          * If we modify a dataset in the same txg that we want to destroy it,
 494          * its dsl_dir's dd_dbuf will be dirty, and thus have a hold on it.
 495          * dsl_dir_destroy_check() will fail if there are unexpected holds.
 496          * Therefore, we want to sync the MOS (thus syncing the dd_dbuf
 497          * and clearing the hold on it) before we process the sync_tasks.
 498          * The MOS data dirtied by the sync_tasks will be synced on the next
 499          * pass.
 500          */
 501         DTRACE_PROBE(pool_sync__3task);
 502         if (!txg_list_empty(&dp->dp_sync_tasks, txg)) {
 503                 dsl_sync_task_t *dst;
 504                 /*
 505                  * No more sync tasks should have been added while we
 506                  * were syncing.
 507                  */
 508                 ASSERT(spa_sync_pass(dp->dp_spa) == 1);
 509                 while (dst = txg_list_remove(&dp->dp_sync_tasks, txg))
 510                         dsl_sync_task_sync(dst, tx);
 511         }
 512
 513         dmu_tx_commit(tx);
 514
 515         dp->dp_space_towrite[txg & TXG_MASK] = 0;
 516         ASSERT(dp->dp_tempreserved[txg & TXG_MASK] == 0);
 517
 518         /*
 519          * If the write limit max has not been explicitly set, set it
 520          * to a fraction of available physical memory (default 1/8th).
 521          * Note that we must inflate the limit because the spa
 522          * inflates write sizes to account for data replication.
 523          * Check this each sync phase to catch changing memory size.
 524          */
 525         if (physmem != old_physmem && zfs_write_limit_shift) {
 526                 mutex_enter(&zfs_write_limit_lock);
 527                 old_physmem = physmem;
 528                 zfs_write_limit_max = ptob(physmem) >> zfs_write_limit_shift;
 529                 zfs_write_limit_inflated = MAX(zfs_write_limit_min,
 530                     spa_get_asize(dp->dp_spa, zfs_write_limit_max));
 531                 mutex_exit(&zfs_write_limit_lock);
 532         }
 533
 534         /*
 535          * Attempt to keep the sync time consistent by adjusting the
 536          * amount of write traffic allowed into each transaction group.
 537          * Weight the throughput calculation towards the current value:
 538          *      thru = 3/4 old_thru + 1/4 new_thru
 539          *
 540          * Note: write_time is in nanosecs, so write_time/MICROSEC
 541          * yields millisecs
 542          */
 543         ASSERT(zfs_write_limit_min > 0);
 544         if (data_written > zfs_write_limit_min / 8 && write_time > MICROSEC) {
 545                 uint64_t throughput = data_written / (write_time / MICROSEC);
 546
 547                 if (dp->dp_throughput)
 548                         dp->dp_throughput = throughput / 4 +
 549                             3 * dp->dp_throughput / 4;
 550                 else
 551                         dp->dp_throughput = throughput;
 552                 dp->dp_write_limit = MIN(zfs_write_limit_inflated,
 553                     MAX(zfs_write_limit_min,
 554                     dp->dp_throughput * zfs_txg_synctime_ms));
 555         }
 556 }
 557
 558 void
 559 dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg)
 560 {
 561         zilog_t *zilog;
 562         dsl_dataset_t *ds;
 563
 564         while (zilog = txg_list_remove(&dp->dp_dirty_zilogs, txg)) {
 565                 ds = dmu_objset_ds(zilog->zl_os);
 566                 zil_clean(zilog, txg);
 567                 ASSERT(!dmu_objset_is_dirty(zilog->zl_os, txg));
 568                 dmu_buf_rele(ds->ds_dbuf, zilog);
 569         }
 570         ASSERT(!dmu_objset_is_dirty(dp->dp_meta_objset, txg));
 571 }
 572
 573 /*
 574  * TRUE if the current thread is the tx_sync_thread or if we
 575  * are being called from SPA context during pool initialization.
 576  */
 577 int
 578 dsl_pool_sync_context(dsl_pool_t *dp)
 579 {
 580         return (curthread == dp->dp_tx.tx_sync_thread ||
 581             spa_is_initializing(dp->dp_spa));
 582 }
 583
 584 uint64_t
 585 dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree)
 586 {
 587         uint64_t space, resv;
 588
 589         /*
 590          * Reserve about 1.6% (1/64), or at least 32MB, for allocation
 591          * efficiency.
 592          * XXX The intent log is not accounted for, so it must fit
 593          * within this slop.
 594          *
 595          * If we're trying to assess whether it's OK to do a free,
 596          * cut the reservation in half to allow forward progress
 597          * (e.g. make it possible to rm(1) files from a full pool).
 598          */
 599         space = spa_get_dspace(dp->dp_spa);
 600         resv = MAX(space >> 6, SPA_MINDEVSIZE >> 1);
 601         if (netfree)
 602                 resv >>= 1;
 603
 604         return (space - resv);
 605 }
 606
 607 int
 608 dsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx)
 609 {
 610         uint64_t reserved = 0;
 611         uint64_t write_limit = (zfs_write_limit_override ?
 612             zfs_write_limit_override : dp->dp_write_limit);
 613
 614         if (zfs_no_write_throttle) {
 615                 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK],
 616                     space);
 617                 return (0);
 618         }
 619
 620         /*
 621          * Check to see if we have exceeded the maximum allowed IO for
 622          * this transaction group.  We can do this without locks since
 623          * a little slop here is ok.  Note that we do the reserved check
 624          * with only half the requested reserve: this is because the
 625          * reserve requests are worst-case, and we really don't want to
 626          * throttle based off of worst-case estimates.
 627          */
 628         if (write_limit > 0) {
 629                 reserved = dp->dp_space_towrite[tx->tx_txg & TXG_MASK]
 630                     + dp->dp_tempreserved[tx->tx_txg & TXG_MASK] / 2;
 631
 632                 if (reserved && reserved > write_limit)
 633                         return (SET_ERROR(ERESTART));
 634         }
 635
 636         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], space);
 637
 638         /*
 639          * If this transaction group is over 7/8ths capacity, delay
 640          * the caller 1 clock tick.  This will slow down the "fill"
 641          * rate until the sync process can catch up with us.
 642          */
 643         if (reserved && reserved > (write_limit - (write_limit >> 3)))
 644                 txg_delay(dp, tx->tx_txg, 1);
 645
 646         return (0);
 647 }
 648
 649 void
 650 dsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
 651 {
 652         ASSERT(dp->dp_tempreserved[tx->tx_txg & TXG_MASK] >= space);
 653         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], -space);
 654 }
 655
 656 void
 657 dsl_pool_memory_pressure(dsl_pool_t *dp)
 658 {
 659         uint64_t space_inuse = 0;
 660         int i;
 661
 662         if (dp->dp_write_limit == zfs_write_limit_min)
 663                 return;
 664
 665         for (i = 0; i < TXG_SIZE; i++) {
 666                 space_inuse += dp->dp_space_towrite[i];
 667                 space_inuse += dp->dp_tempreserved[i];
 668         }
 669         dp->dp_write_limit = MAX(zfs_write_limit_min,
 670             MIN(dp->dp_write_limit, space_inuse / 4));
 671 }
 672
 673 void
 674 dsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
 675 {
 676         if (space > 0) {
 677                 mutex_enter(&dp->dp_lock);
 678                 dp->dp_space_towrite[tx->tx_txg & TXG_MASK] += space;
 679                 mutex_exit(&dp->dp_lock);
 680         }
 681 }
 682
 683 /* ARGSUSED */
 684 static int
 685 upgrade_clones_cb(dsl_pool_t *dp, dsl_dataset_t *hds, void *arg)
 686 {
 687         dmu_tx_t *tx = arg;
 688         dsl_dataset_t *ds, *prev = NULL;
 689         int err;
 690
 691         err = dsl_dataset_hold_obj(dp, hds->ds_object, FTAG, &ds);
 692         if (err)
 693                 return (err);
 694
 695         while (ds->ds_phys->ds_prev_snap_obj != 0) {
 696                 err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
 697                     FTAG, &prev);
 698                 if (err) {
 699                         dsl_dataset_rele(ds, FTAG);
 700                         return (err);
 701                 }
 702
 703                 if (prev->ds_phys->ds_next_snap_obj != ds->ds_object)
 704                         break;
 705                 dsl_dataset_rele(ds, FTAG);
 706                 ds = prev;
 707                 prev = NULL;
 708         }
 709
 710         if (prev == NULL) {
 711                 prev = dp->dp_origin_snap;
 712
 713                 /*
 714                  * The $ORIGIN can't have any data, or the accounting
 715                  * will be wrong.
 716                  */
 717                 ASSERT0(prev->ds_phys->ds_bp.blk_birth);
 718
 719                 /* The origin doesn't get attached to itself */
 720                 if (ds->ds_object == prev->ds_object) {
 721                         dsl_dataset_rele(ds, FTAG);
 722                         return (0);
 723                 }
 724
 725                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
 726                 ds->ds_phys->ds_prev_snap_obj = prev->ds_object;
 727                 ds->ds_phys->ds_prev_snap_txg = prev->ds_phys->ds_creation_txg;
 728
 729                 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx);
 730                 ds->ds_dir->dd_phys->dd_origin_obj = prev->ds_object;
 731
 732                 dmu_buf_will_dirty(prev->ds_dbuf, tx);
 733                 prev->ds_phys->ds_num_children++;
 734
 735                 if (ds->ds_phys->ds_next_snap_obj == 0) {
 736                         ASSERT(ds->ds_prev == NULL);
 737                         VERIFY0(dsl_dataset_hold_obj(dp,
 738                             ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev));
 739                 }
 740         }
 741
 742         ASSERT3U(ds->ds_dir->dd_phys->dd_origin_obj, ==, prev->ds_object);
 743         ASSERT3U(ds->ds_phys->ds_prev_snap_obj, ==, prev->ds_object);
 744
 745         if (prev->ds_phys->ds_next_clones_obj == 0) {
 746                 dmu_buf_will_dirty(prev->ds_dbuf, tx);
 747                 prev->ds_phys->ds_next_clones_obj =
 748                     zap_create(dp->dp_meta_objset,
 749                     DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
 750         }
 751         VERIFY0(zap_add_int(dp->dp_meta_objset,
 752             prev->ds_phys->ds_next_clones_obj, ds->ds_object, tx));
 753
 754         dsl_dataset_rele(ds, FTAG);
 755         if (prev != dp->dp_origin_snap)
 756                 dsl_dataset_rele(prev, FTAG);
 757         return (0);
 758 }
 759
 760 void
 761 dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx)
 762 {
 763         ASSERT(dmu_tx_is_syncing(tx));
 764         ASSERT(dp->dp_origin_snap != NULL);
 765
 766         VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj, upgrade_clones_cb,
 767             tx, DS_FIND_CHILDREN));
 768 }
 769
 770 /* ARGSUSED */
 771 static int
 772 upgrade_dir_clones_cb(dsl_pool_t *dp, dsl_dataset_t *ds, void *arg)
 773 {
 774         dmu_tx_t *tx = arg;
 775         objset_t *mos = dp->dp_meta_objset;
 776
 777         if (ds->ds_dir->dd_phys->dd_origin_obj != 0) {
 778                 dsl_dataset_t *origin;
 779
 780                 VERIFY0(dsl_dataset_hold_obj(dp,
 781                     ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &origin));
 782
 783                 if (origin->ds_dir->dd_phys->dd_clones == 0) {
 784                         dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
 785                         origin->ds_dir->dd_phys->dd_clones = zap_create(mos,
 786                             DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
 787                 }
 788
 789                 VERIFY0(zap_add_int(dp->dp_meta_objset,
 790                     origin->ds_dir->dd_phys->dd_clones, ds->ds_object, tx));
 791
 792                 dsl_dataset_rele(origin, FTAG);
 793         }
 794         return (0);
 795 }
 796
 797 void
 798 dsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx)
 799 {
 800         ASSERT(dmu_tx_is_syncing(tx));
 801         uint64_t obj;
 802
 803         (void) dsl_dir_create_sync(dp, dp->dp_root_dir, FREE_DIR_NAME, tx);
 804         VERIFY0(dsl_pool_open_special_dir(dp,
 805             FREE_DIR_NAME, &dp->dp_free_dir));
 806
 807         /*
 808          * We can't use bpobj_alloc(), because spa_version() still
 809          * returns the old version, and we need a new-version bpobj with
 810          * subobj support.  So call dmu_object_alloc() directly.
 811          */
 812         obj = dmu_object_alloc(dp->dp_meta_objset, DMU_OT_BPOBJ,
 813             SPA_MAXBLOCKSIZE, DMU_OT_BPOBJ_HDR, sizeof (bpobj_phys_t), tx);
 814         VERIFY0(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 815             DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx));
 816         VERIFY0(bpobj_open(&dp->dp_free_bpobj, dp->dp_meta_objset, obj));
 817
 818         VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
 819             upgrade_dir_clones_cb, tx, DS_FIND_CHILDREN));
 820 }
 821
 822 void
 823 dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx)
 824 {
 825         uint64_t dsobj;
 826         dsl_dataset_t *ds;
 827
 828         ASSERT(dmu_tx_is_syncing(tx));
 829         ASSERT(dp->dp_origin_snap == NULL);
 830         ASSERT(rrw_held(&dp->dp_config_rwlock, RW_WRITER));
 831
 832         /* create the origin dir, ds, & snap-ds */
 833         dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME,
 834             NULL, 0, kcred, tx);
 835         VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 836         dsl_dataset_snapshot_sync_impl(ds, ORIGIN_DIR_NAME, tx);
 837         VERIFY0(dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
 838             dp, &dp->dp_origin_snap));
 839         dsl_dataset_rele(ds, FTAG);
 840 }
 841
 842 taskq_t *
 843 dsl_pool_vnrele_taskq(dsl_pool_t *dp)
 844 {
 845         return (dp->dp_vnrele_taskq);
 846 }
 847
 848 /*
 849  * Walk through the pool-wide zap object of temporary snapshot user holds
 850  * and release them.
 851  */
 852 void
 853 dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
 854 {
 855         zap_attribute_t za;
 856         zap_cursor_t zc;
 857         objset_t *mos = dp->dp_meta_objset;
 858         uint64_t zapobj = dp->dp_tmp_userrefs_obj;
 859
 860         if (zapobj == 0)
 861                 return;
 862         ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
 863
 864         for (zap_cursor_init(&zc, mos, zapobj);
 865             zap_cursor_retrieve(&zc, &za) == 0;
 866             zap_cursor_advance(&zc)) {
 867                 char *htag;
 868                 uint64_t dsobj;
 869
 870                 htag = strchr(za.za_name, '-');
 871                 *htag = '\0';
 872                 ++htag;
 873                 dsobj = strtonum(za.za_name, NULL);
 874                 dsl_dataset_user_release_tmp(dp, dsobj, htag);
 875         }
 876         zap_cursor_fini(&zc);
 877 }
 878
 879 /*
 880  * Create the pool-wide zap object for storing temporary snapshot holds.
 881  */
 882 void
 883 dsl_pool_user_hold_create_obj(dsl_pool_t *dp, dmu_tx_t *tx)
 884 {
 885         objset_t *mos = dp->dp_meta_objset;
 886
 887         ASSERT(dp->dp_tmp_userrefs_obj == 0);
 888         ASSERT(dmu_tx_is_syncing(tx));
 889
 890         dp->dp_tmp_userrefs_obj = zap_create_link(mos, DMU_OT_USERREFS,
 891             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_TMP_USERREFS, tx);
 892 }
 893
 894 static int
 895 dsl_pool_user_hold_rele_impl(dsl_pool_t *dp, uint64_t dsobj,
 896     const char *tag, uint64_t now, dmu_tx_t *tx, boolean_t holding)
 897 {
 898         objset_t *mos = dp->dp_meta_objset;
 899         uint64_t zapobj = dp->dp_tmp_userrefs_obj;
 900         char *name;
 901         int error;
 902
 903         ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
 904         ASSERT(dmu_tx_is_syncing(tx));
 905
 906         /*
 907          * If the pool was created prior to SPA_VERSION_USERREFS, the
 908          * zap object for temporary holds might not exist yet.
 909          */
 910         if (zapobj == 0) {
 911                 if (holding) {
 912                         dsl_pool_user_hold_create_obj(dp, tx);
 913                         zapobj = dp->dp_tmp_userrefs_obj;
 914                 } else {
 915                         return (SET_ERROR(ENOENT));
 916                 }
 917         }
 918
 919         name = kmem_asprintf("%llx-%s", (u_longlong_t)dsobj, tag);
 920         if (holding)
 921                 error = zap_add(mos, zapobj, name, 8, 1, &now, tx);
 922         else
 923                 error = zap_remove(mos, zapobj, name, tx);
 924         strfree(name);
 925
 926         return (error);
 927 }
 928
 929 /*
 930  * Add a temporary hold for the given dataset object and tag.
 931  */
 932 int
 933 dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
 934     uint64_t now, dmu_tx_t *tx)
 935 {
 936         return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, now, tx, B_TRUE));
 937 }
 938
 939 /*
 940  * Release a temporary hold for the given dataset object and tag.
 941  */
 942 int
 943 dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
 944     dmu_tx_t *tx)
 945 {
 946         return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, 0,
 947             tx, B_FALSE));
 948 }
 949
 950 /*
 951  * DSL Pool Configuration Lock
 952  *
 953  * The dp_config_rwlock protects against changes to DSL state (e.g. dataset
 954  * creation / destruction / rename / property setting).  It must be held for
 955  * read to hold a dataset or dsl_dir.  I.e. you must call
 956  * dsl_pool_config_enter() or dsl_pool_hold() before calling
 957  * dsl_{dataset,dir}_hold{_obj}.  In most circumstances, the dp_config_rwlock
 958  * must be held continuously until all datasets and dsl_dirs are released.
 959  *
 960  * The only exception to this rule is that if a "long hold" is placed on
 961  * a dataset, then the dp_config_rwlock may be dropped while the dataset
 962  * is still held.  The long hold will prevent the dataset from being
 963  * destroyed -- the destroy will fail with EBUSY.  A long hold can be
 964  * obtained by calling dsl_dataset_long_hold(), or by "owning" a dataset
 965  * (by calling dsl_{dataset,objset}_{try}own{_obj}).
 966  *
 967  * Legitimate long-holders (including owners) should be long-running, cancelable
 968  * tasks that should cause "zfs destroy" to fail.  This includes DMU
 969  * consumers (i.e. a ZPL filesystem being mounted or ZVOL being open),
 970  * "zfs send", and "zfs diff".  There are several other long-holders whose
 971  * uses are suboptimal (e.g. "zfs promote", and zil_suspend()).
 972  *
 973  * The usual formula for long-holding would be:
 974  * dsl_pool_hold()
 975  * dsl_dataset_hold()
 976  * ... perform checks ...
 977  * dsl_dataset_long_hold()
 978  * dsl_pool_rele()
 979  * ... perform long-running task ...
 980  * dsl_dataset_long_rele()
 981  * dsl_dataset_rele()
 982  *
 983  * Note that when the long hold is released, the dataset is still held but
 984  * the pool is not held.  The dataset may change arbitrarily during this time
 985  * (e.g. it could be destroyed).  Therefore you shouldn't do anything to the
 986  * dataset except release it.
 987  *
 988  * User-initiated operations (e.g. ioctls, zfs_ioc_*()) are either read-only
 989  * or modifying operations.
 990  *
 991  * Modifying operations should generally use dsl_sync_task().  The synctask
 992  * infrastructure enforces proper locking strategy with respect to the
 993  * dp_config_rwlock.  See the comment above dsl_sync_task() for details.
 994  *
 995  * Read-only operations will manually hold the pool, then the dataset, obtain
 996  * information from the dataset, then release the pool and dataset.
 997  * dmu_objset_{hold,rele}() are convenience routines that also do the pool
 998  * hold/rele.
 999  */
1000
1001 int
1002 dsl_pool_hold(const char *name, void *tag, dsl_pool_t **dp)
1003 {
1004         spa_t *spa;
1005         int error;
1006
1007         error = spa_open(name, &spa, tag);
1008         if (error == 0) {
1009                 *dp = spa_get_dsl(spa);
1010                 dsl_pool_config_enter(*dp, tag);
1011         }
1012         return (error);
1013 }
1014
1015 void
1016 dsl_pool_rele(dsl_pool_t *dp, void *tag)
1017 {
1018         dsl_pool_config_exit(dp, tag);
1019         spa_close(dp->dp_spa, tag);
1020 }
1021
1022 void
1023 dsl_pool_config_enter(dsl_pool_t *dp, void *tag)
1024 {
1025         /*
1026          * We use a "reentrant" reader-writer lock, but not reentrantly.
1027          *
1028          * The rrwlock can (with the track_all flag) track all reading threads,
1029          * which is very useful for debugging which code path failed to release
1030          * the lock, and for verifying that the *current* thread does hold
1031          * the lock.
1032          *
1033          * (Unlike a rwlock, which knows that N threads hold it for
1034          * read, but not *which* threads, so rw_held(RW_READER) returns TRUE
1035          * if any thread holds it for read, even if this thread doesn't).
1036          */
1037         ASSERT(!rrw_held(&dp->dp_config_rwlock, RW_READER));
1038         rrw_enter(&dp->dp_config_rwlock, RW_READER, tag);
1039 }
1040
1041 void
1042 dsl_pool_config_exit(dsl_pool_t *dp, void *tag)
1043 {
1044         rrw_exit(&dp->dp_config_rwlock, tag);
1045 }
1046
1047 boolean_t
1048 dsl_pool_config_held(dsl_pool_t *dp)
1049 {
1050         return (RRW_LOCK_HELD(&dp->dp_config_rwlock));
1051 }