module/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) 2012 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
  46 int zfs_no_write_throttle = 0;
  47 int zfs_write_limit_shift = 3;                  /* 1/8th of physical memory */
  48 int zfs_txg_synctime_ms = 1000;         /* target millisecs to sync a txg */
  49 int zfs_txg_history = 60;               /* statistics for the last N txgs */
  50
  51 unsigned long zfs_write_limit_min = 32 << 20;   /* min write limit is 32MB */
  52 unsigned long zfs_write_limit_max = 0;          /* max data payload per txg */
  53 unsigned long zfs_write_limit_inflated = 0;
  54 unsigned long zfs_write_limit_override = 0;
  55
  56 kmutex_t zfs_write_limit_lock;
  57
  58 static pgcnt_t old_physmem = 0;
  59
  60 static int
  61 dsl_pool_txg_history_update(kstat_t *ksp, int rw)
  62 {
  63         dsl_pool_t *dp = ksp->ks_private;
  64         txg_history_t *th;
  65         int i = 0;
  66
  67         if (rw == KSTAT_WRITE)
  68                 return (EACCES);
  69
  70         if (ksp->ks_data)
  71                 kmem_free(ksp->ks_data, ksp->ks_data_size);
  72
  73         mutex_enter(&dp->dp_lock);
  74
  75         ksp->ks_ndata = dp->dp_txg_history_size;
  76         ksp->ks_data_size = dp->dp_txg_history_size * sizeof(kstat_txg_t);
  77         if (ksp->ks_data_size > 0)
  78                 ksp->ks_data = kmem_alloc(ksp->ks_data_size, KM_PUSHPAGE);
  79
  80         /* Traversed oldest to youngest for the most readable kstat output */
  81         for (th = list_tail(&dp->dp_txg_history); th != NULL;
  82              th = list_prev(&dp->dp_txg_history, th)) {
  83                 mutex_enter(&th->th_lock);
  84                 ASSERT3S(i + sizeof(kstat_txg_t), <=, ksp->ks_data_size);
  85                 memcpy(ksp->ks_data + i, &th->th_kstat, sizeof(kstat_txg_t));
  86                 i += sizeof(kstat_txg_t);
  87                 mutex_exit(&th->th_lock);
  88         }
  89
  90         mutex_exit(&dp->dp_lock);
  91
  92         return (0);
  93 }
  94
  95 static void
  96 dsl_pool_txg_history_init(dsl_pool_t *dp, uint64_t txg)
  97 {
  98         char name[KSTAT_STRLEN];
  99
 100         list_create(&dp->dp_txg_history, sizeof (txg_history_t),
 101             offsetof(txg_history_t, th_link));
 102         dsl_pool_txg_history_add(dp, txg);
 103
 104         (void) snprintf(name, KSTAT_STRLEN, "txgs-%s", spa_name(dp->dp_spa));
 105         dp->dp_txg_kstat = kstat_create("zfs", 0, name, "misc",
 106             KSTAT_TYPE_TXG, 0, KSTAT_FLAG_VIRTUAL);
 107         if (dp->dp_txg_kstat) {
 108                 dp->dp_txg_kstat->ks_data = NULL;
 109                 dp->dp_txg_kstat->ks_private = dp;
 110                 dp->dp_txg_kstat->ks_update = dsl_pool_txg_history_update;
 111                 kstat_install(dp->dp_txg_kstat);
 112         }
 113 }
 114
 115 static void
 116 dsl_pool_txg_history_destroy(dsl_pool_t *dp)
 117 {
 118         txg_history_t *th;
 119
 120         if (dp->dp_txg_kstat) {
 121                 if (dp->dp_txg_kstat->ks_data)
 122                         kmem_free(dp->dp_txg_kstat->ks_data,
 123                             dp->dp_txg_kstat->ks_data_size);
 124
 125                 kstat_delete(dp->dp_txg_kstat);
 126         }
 127
 128         mutex_enter(&dp->dp_lock);
 129         while ((th = list_remove_head(&dp->dp_txg_history))) {
 130                 dp->dp_txg_history_size--;
 131                 mutex_destroy(&th->th_lock);
 132                 kmem_free(th, sizeof(txg_history_t));
 133         }
 134
 135         ASSERT3U(dp->dp_txg_history_size, ==, 0);
 136         list_destroy(&dp->dp_txg_history);
 137         mutex_exit(&dp->dp_lock);
 138 }
 139
 140 txg_history_t *
 141 dsl_pool_txg_history_add(dsl_pool_t *dp, uint64_t txg)
 142 {
 143         txg_history_t *th, *rm;
 144
 145         th = kmem_zalloc(sizeof(txg_history_t), KM_SLEEP);
 146         mutex_init(&th->th_lock, NULL, MUTEX_DEFAULT, NULL);
 147         th->th_kstat.txg = txg;
 148         th->th_kstat.state = TXG_STATE_OPEN;
 149         th->th_kstat.birth = gethrtime();
 150
 151         mutex_enter(&dp->dp_lock);
 152
 153         list_insert_head(&dp->dp_txg_history, th);
 154         dp->dp_txg_history_size++;
 155
 156         while (dp->dp_txg_history_size > zfs_txg_history) {
 157                 dp->dp_txg_history_size--;
 158                 rm = list_remove_tail(&dp->dp_txg_history);
 159                 mutex_destroy(&rm->th_lock);
 160                 kmem_free(rm, sizeof(txg_history_t));
 161         }
 162
 163         mutex_exit(&dp->dp_lock);
 164
 165         return (th);
 166 }
 167
 168 /*
 169  * Traversed youngest to oldest because lookups are only done for open
 170  * or syncing txgs which are guaranteed to be at the head of the list.
 171  * The txg_history_t structure will be returned locked.
 172  */
 173 txg_history_t *
 174 dsl_pool_txg_history_get(dsl_pool_t *dp, uint64_t txg)
 175 {
 176         txg_history_t *th;
 177
 178         mutex_enter(&dp->dp_lock);
 179         for (th = list_head(&dp->dp_txg_history); th != NULL;
 180              th = list_next(&dp->dp_txg_history, th)) {
 181                 if (th->th_kstat.txg == txg) {
 182                         mutex_enter(&th->th_lock);
 183                         break;
 184                 }
 185         }
 186         mutex_exit(&dp->dp_lock);
 187
 188         return (th);
 189 }
 190
 191 void
 192 dsl_pool_txg_history_put(txg_history_t *th)
 193 {
 194         mutex_exit(&th->th_lock);
 195 }
 196
 197 int
 198 dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp)
 199 {
 200         uint64_t obj;
 201         int err;
 202
 203         err = zap_lookup(dp->dp_meta_objset,
 204             dp->dp_root_dir->dd_phys->dd_child_dir_zapobj,
 205             name, sizeof (obj), 1, &obj);
 206         if (err)
 207                 return (err);
 208
 209         return (dsl_dir_open_obj(dp, obj, name, dp, ddp));
 210 }
 211
 212 static dsl_pool_t *
 213 dsl_pool_open_impl(spa_t *spa, uint64_t txg)
 214 {
 215         dsl_pool_t *dp;
 216         blkptr_t *bp = spa_get_rootblkptr(spa);
 217
 218         dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP);
 219         dp->dp_spa = spa;
 220         dp->dp_meta_rootbp = *bp;
 221         rw_init(&dp->dp_config_rwlock, NULL, RW_DEFAULT, NULL);
 222         dp->dp_write_limit = zfs_write_limit_min;
 223         txg_init(dp, txg);
 224
 225         txg_list_create(&dp->dp_dirty_datasets,
 226             offsetof(dsl_dataset_t, ds_dirty_link));
 227         txg_list_create(&dp->dp_dirty_dirs,
 228             offsetof(dsl_dir_t, dd_dirty_link));
 229         txg_list_create(&dp->dp_sync_tasks,
 230             offsetof(dsl_sync_task_group_t, dstg_node));
 231         list_create(&dp->dp_synced_datasets, sizeof (dsl_dataset_t),
 232             offsetof(dsl_dataset_t, ds_synced_link));
 233
 234         mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL);
 235
 236         dp->dp_iput_taskq = taskq_create("zfs_iput_taskq", 1, minclsyspri,
 237             1, 4, 0);
 238
 239         dsl_pool_txg_history_init(dp, txg);
 240
 241         return (dp);
 242 }
 243
 244 int
 245 dsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp)
 246 {
 247         int err;
 248         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
 249
 250         err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp,
 251             &dp->dp_meta_objset);
 252         if (err != 0)
 253                 dsl_pool_close(dp);
 254         else
 255                 *dpp = dp;
 256
 257         return (err);
 258 }
 259
 260 int
 261 dsl_pool_open(dsl_pool_t *dp)
 262 {
 263         int err;
 264         dsl_dir_t *dd;
 265         dsl_dataset_t *ds;
 266         uint64_t obj;
 267
 268         rw_enter(&dp->dp_config_rwlock, RW_WRITER);
 269         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 270             DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1,
 271             &dp->dp_root_dir_obj);
 272         if (err)
 273                 goto out;
 274
 275         err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj,
 276             NULL, dp, &dp->dp_root_dir);
 277         if (err)
 278                 goto out;
 279
 280         err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir);
 281         if (err)
 282                 goto out;
 283
 284         if (spa_version(dp->dp_spa) >= SPA_VERSION_ORIGIN) {
 285                 err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd);
 286                 if (err)
 287                         goto out;
 288                 err = dsl_dataset_hold_obj(dp, dd->dd_phys->dd_head_dataset_obj,
 289                     FTAG, &ds);
 290                 if (err == 0) {
 291                         err = dsl_dataset_hold_obj(dp,
 292                             ds->ds_phys->ds_prev_snap_obj, dp,
 293                             &dp->dp_origin_snap);
 294                         dsl_dataset_rele(ds, FTAG);
 295                 }
 296                 dsl_dir_close(dd, dp);
 297                 if (err)
 298                         goto out;
 299         }
 300
 301         if (spa_version(dp->dp_spa) >= SPA_VERSION_DEADLISTS) {
 302                 err = dsl_pool_open_special_dir(dp, FREE_DIR_NAME,
 303                     &dp->dp_free_dir);
 304                 if (err)
 305                         goto out;
 306
 307                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 308                     DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj);
 309                 if (err)
 310                         goto out;
 311                 VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj,
 312                     dp->dp_meta_objset, obj));
 313         }
 314
 315         if (spa_feature_is_active(dp->dp_spa,
 316             &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])) {
 317                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 318                     DMU_POOL_BPTREE_OBJ, sizeof (uint64_t), 1,
 319                     &dp->dp_bptree_obj);
 320                 if (err != 0)
 321                         goto out;
 322         }
 323
 324         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 325             DMU_POOL_TMP_USERREFS, sizeof (uint64_t), 1,
 326             &dp->dp_tmp_userrefs_obj);
 327         if (err == ENOENT)
 328                 err = 0;
 329         if (err)
 330                 goto out;
 331
 332         err = dsl_scan_init(dp, dp->dp_tx.tx_open_txg);
 333
 334 out:
 335         rw_exit(&dp->dp_config_rwlock);
 336         return (err);
 337 }
 338
 339 void
 340 dsl_pool_close(dsl_pool_t *dp)
 341 {
 342         /* drop our references from dsl_pool_open() */
 343
 344         /*
 345          * Since we held the origin_snap from "syncing" context (which
 346          * includes pool-opening context), it actually only got a "ref"
 347          * and not a hold, so just drop that here.
 348          */
 349         if (dp->dp_origin_snap)
 350                 dsl_dataset_drop_ref(dp->dp_origin_snap, dp);
 351         if (dp->dp_mos_dir)
 352                 dsl_dir_close(dp->dp_mos_dir, dp);
 353         if (dp->dp_free_dir)
 354                 dsl_dir_close(dp->dp_free_dir, dp);
 355         if (dp->dp_root_dir)
 356                 dsl_dir_close(dp->dp_root_dir, dp);
 357
 358         bpobj_close(&dp->dp_free_bpobj);
 359
 360         /* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */
 361         if (dp->dp_meta_objset)
 362                 dmu_objset_evict(dp->dp_meta_objset);
 363
 364         txg_list_destroy(&dp->dp_dirty_datasets);
 365         txg_list_destroy(&dp->dp_sync_tasks);
 366         txg_list_destroy(&dp->dp_dirty_dirs);
 367         list_destroy(&dp->dp_synced_datasets);
 368
 369         arc_flush(dp->dp_spa);
 370         txg_fini(dp);
 371         dsl_scan_fini(dp);
 372         dsl_pool_txg_history_destroy(dp);
 373         rw_destroy(&dp->dp_config_rwlock);
 374         mutex_destroy(&dp->dp_lock);
 375         taskq_destroy(dp->dp_iput_taskq);
 376         if (dp->dp_blkstats)
 377                 kmem_free(dp->dp_blkstats, sizeof (zfs_all_blkstats_t));
 378         kmem_free(dp, sizeof (dsl_pool_t));
 379 }
 380
 381 dsl_pool_t *
 382 dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg)
 383 {
 384         int err;
 385         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
 386         dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);
 387         objset_t *os;
 388         dsl_dataset_t *ds;
 389         uint64_t obj;
 390
 391         /* create and open the MOS (meta-objset) */
 392         dp->dp_meta_objset = dmu_objset_create_impl(spa,
 393             NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx);
 394
 395         /* create the pool directory */
 396         err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 397             DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
 398         ASSERT3U(err, ==, 0);
 399
 400         /* Initialize scan structures */
 401         VERIFY3U(0, ==, dsl_scan_init(dp, txg));
 402
 403         /* create and open the root dir */
 404         dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx);
 405         VERIFY(0 == dsl_dir_open_obj(dp, dp->dp_root_dir_obj,
 406             NULL, dp, &dp->dp_root_dir));
 407
 408         /* create and open the meta-objset dir */
 409         (void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx);
 410         VERIFY(0 == dsl_pool_open_special_dir(dp,
 411             MOS_DIR_NAME, &dp->dp_mos_dir));
 412
 413         if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
 414                 /* create and open the free dir */
 415                 (void) dsl_dir_create_sync(dp, dp->dp_root_dir,
 416                     FREE_DIR_NAME, tx);
 417                 VERIFY(0 == dsl_pool_open_special_dir(dp,
 418                     FREE_DIR_NAME, &dp->dp_free_dir));
 419
 420                 /* create and open the free_bplist */
 421                 obj = bpobj_alloc(dp->dp_meta_objset, SPA_MAXBLOCKSIZE, tx);
 422                 VERIFY(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 423                     DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx) == 0);
 424                 VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj,
 425                     dp->dp_meta_objset, obj));
 426         }
 427
 428         if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB)
 429                 dsl_pool_create_origin(dp, tx);
 430
 431         /* create the root dataset */
 432         obj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx);
 433
 434         /* create the root objset */
 435         VERIFY(0 == dsl_dataset_hold_obj(dp, obj, FTAG, &ds));
 436         VERIFY(NULL != (os = dmu_objset_create_impl(dp->dp_spa, ds,
 437             dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx)));
 438 #ifdef _KERNEL
 439         zfs_create_fs(os, kcred, zplprops, tx);
 440 #endif
 441         dsl_dataset_rele(ds, FTAG);
 442
 443         dmu_tx_commit(tx);
 444
 445         return (dp);
 446 }
 447
 448 static int
 449 deadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
 450 {
 451         dsl_deadlist_t *dl = arg;
 452         dsl_pool_t *dp = dmu_objset_pool(dl->dl_os);
 453         rw_enter(&dp->dp_config_rwlock, RW_READER);
 454         dsl_deadlist_insert(dl, bp, tx);
 455         rw_exit(&dp->dp_config_rwlock);
 456         return (0);
 457 }
 458
 459 void
 460 dsl_pool_sync(dsl_pool_t *dp, uint64_t txg)
 461 {
 462         zio_t *zio;
 463         dmu_tx_t *tx;
 464         dsl_dir_t *dd;
 465         dsl_dataset_t *ds;
 466         dsl_sync_task_group_t *dstg;
 467         objset_t *mos = dp->dp_meta_objset;
 468         hrtime_t start, write_time;
 469         uint64_t data_written;
 470         int err;
 471
 472         /*
 473          * We need to copy dp_space_towrite() before doing
 474          * dsl_sync_task_group_sync(), because
 475          * dsl_dataset_snapshot_reserve_space() will increase
 476          * dp_space_towrite but not actually write anything.
 477          */
 478         data_written = dp->dp_space_towrite[txg & TXG_MASK];
 479
 480         tx = dmu_tx_create_assigned(dp, txg);
 481
 482         dp->dp_read_overhead = 0;
 483         start = gethrtime();
 484
 485         zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 486         while ((ds = txg_list_remove(&dp->dp_dirty_datasets, txg))) {
 487                 /*
 488                  * We must not sync any non-MOS datasets twice, because
 489                  * we may have taken a snapshot of them.  However, we
 490                  * may sync newly-created datasets on pass 2.
 491                  */
 492                 ASSERT(!list_link_active(&ds->ds_synced_link));
 493                 list_insert_tail(&dp->dp_synced_datasets, ds);
 494                 dsl_dataset_sync(ds, zio, tx);
 495         }
 496         DTRACE_PROBE(pool_sync__1setup);
 497         err = zio_wait(zio);
 498
 499         write_time = gethrtime() - start;
 500         ASSERT(err == 0);
 501         DTRACE_PROBE(pool_sync__2rootzio);
 502
 503         for (ds = list_head(&dp->dp_synced_datasets); ds;
 504             ds = list_next(&dp->dp_synced_datasets, ds))
 505                 dmu_objset_do_userquota_updates(ds->ds_objset, tx);
 506
 507         /*
 508          * Sync the datasets again to push out the changes due to
 509          * userspace updates.  This must be done before we process the
 510          * sync tasks, because that could cause a snapshot of a dataset
 511          * whose ds_bp will be rewritten when we do this 2nd sync.
 512          */
 513         zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 514         while ((ds = txg_list_remove(&dp->dp_dirty_datasets, txg))) {
 515                 ASSERT(list_link_active(&ds->ds_synced_link));
 516                 dmu_buf_rele(ds->ds_dbuf, ds);
 517                 dsl_dataset_sync(ds, zio, tx);
 518         }
 519         err = zio_wait(zio);
 520
 521         /*
 522          * Move dead blocks from the pending deadlist to the on-disk
 523          * deadlist.
 524          */
 525         for (ds = list_head(&dp->dp_synced_datasets); ds;
 526             ds = list_next(&dp->dp_synced_datasets, ds)) {
 527                 bplist_iterate(&ds->ds_pending_deadlist,
 528                     deadlist_enqueue_cb, &ds->ds_deadlist, tx);
 529         }
 530
 531         while ((dstg = txg_list_remove(&dp->dp_sync_tasks, txg))) {
 532                 /*
 533                  * No more sync tasks should have been added while we
 534                  * were syncing.
 535                  */
 536                 ASSERT(spa_sync_pass(dp->dp_spa) == 1);
 537                 dsl_sync_task_group_sync(dstg, tx);
 538         }
 539         DTRACE_PROBE(pool_sync__3task);
 540
 541         start = gethrtime();
 542         while ((dd = txg_list_remove(&dp->dp_dirty_dirs, txg)))
 543                 dsl_dir_sync(dd, tx);
 544         write_time += gethrtime() - start;
 545
 546         start = gethrtime();
 547         if (list_head(&mos->os_dirty_dnodes[txg & TXG_MASK]) != NULL ||
 548             list_head(&mos->os_free_dnodes[txg & TXG_MASK]) != NULL) {
 549                 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 550                 dmu_objset_sync(mos, zio, tx);
 551                 err = zio_wait(zio);
 552                 ASSERT(err == 0);
 553                 dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", "");
 554                 spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp);
 555         }
 556         write_time += gethrtime() - start;
 557         DTRACE_PROBE2(pool_sync__4io, hrtime_t, write_time,
 558             hrtime_t, dp->dp_read_overhead);
 559         write_time -= dp->dp_read_overhead;
 560
 561         dmu_tx_commit(tx);
 562
 563         dp->dp_space_towrite[txg & TXG_MASK] = 0;
 564         ASSERT(dp->dp_tempreserved[txg & TXG_MASK] == 0);
 565
 566         /*
 567          * If the write limit max has not been explicitly set, set it
 568          * to a fraction of available physical memory (default 1/8th).
 569          * Note that we must inflate the limit because the spa
 570          * inflates write sizes to account for data replication.
 571          * Check this each sync phase to catch changing memory size.
 572          */
 573         if (physmem != old_physmem && zfs_write_limit_shift) {
 574                 mutex_enter(&zfs_write_limit_lock);
 575                 old_physmem = physmem;
 576                 zfs_write_limit_max = ptob(physmem) >> zfs_write_limit_shift;
 577                 zfs_write_limit_inflated = MAX(zfs_write_limit_min,
 578                     spa_get_asize(dp->dp_spa, zfs_write_limit_max));
 579                 mutex_exit(&zfs_write_limit_lock);
 580         }
 581
 582         /*
 583          * Attempt to keep the sync time consistent by adjusting the
 584          * amount of write traffic allowed into each transaction group.
 585          * Weight the throughput calculation towards the current value:
 586          *      thru = 3/4 old_thru + 1/4 new_thru
 587          *
 588          * Note: write_time is in nanosecs, so write_time/MICROSEC
 589          * yields millisecs
 590          */
 591         ASSERT(zfs_write_limit_min > 0);
 592         if (data_written > zfs_write_limit_min / 8 && write_time > MICROSEC) {
 593                 uint64_t throughput = data_written / (write_time / MICROSEC);
 594
 595                 if (dp->dp_throughput)
 596                         dp->dp_throughput = throughput / 4 +
 597                             3 * dp->dp_throughput / 4;
 598                 else
 599                         dp->dp_throughput = throughput;
 600                 dp->dp_write_limit = MIN(zfs_write_limit_inflated,
 601                     MAX(zfs_write_limit_min,
 602                     dp->dp_throughput * zfs_txg_synctime_ms));
 603         }
 604 }
 605
 606 void
 607 dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg)
 608 {
 609         dsl_dataset_t *ds;
 610         objset_t *os;
 611
 612         while ((ds = list_head(&dp->dp_synced_datasets))) {
 613                 list_remove(&dp->dp_synced_datasets, ds);
 614                 os = ds->ds_objset;
 615                 zil_clean(os->os_zil, txg);
 616                 ASSERT(!dmu_objset_is_dirty(os, txg));
 617                 dmu_buf_rele(ds->ds_dbuf, ds);
 618         }
 619         ASSERT(!dmu_objset_is_dirty(dp->dp_meta_objset, txg));
 620 }
 621
 622 /*
 623  * TRUE if the current thread is the tx_sync_thread or if we
 624  * are being called from SPA context during pool initialization.
 625  */
 626 int
 627 dsl_pool_sync_context(dsl_pool_t *dp)
 628 {
 629         return (curthread == dp->dp_tx.tx_sync_thread ||
 630             spa_is_initializing(dp->dp_spa));
 631 }
 632
 633 uint64_t
 634 dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree)
 635 {
 636         uint64_t space, resv;
 637
 638         /*
 639          * Reserve about 1.6% (1/64), or at least 32MB, for allocation
 640          * efficiency.
 641          * XXX The intent log is not accounted for, so it must fit
 642          * within this slop.
 643          *
 644          * If we're trying to assess whether it's OK to do a free,
 645          * cut the reservation in half to allow forward progress
 646          * (e.g. make it possible to rm(1) files from a full pool).
 647          */
 648         space = spa_get_dspace(dp->dp_spa);
 649         resv = MAX(space >> 6, SPA_MINDEVSIZE >> 1);
 650         if (netfree)
 651                 resv >>= 1;
 652
 653         return (space - resv);
 654 }
 655
 656 int
 657 dsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx)
 658 {
 659         uint64_t reserved = 0;
 660         uint64_t write_limit = (zfs_write_limit_override ?
 661             zfs_write_limit_override : dp->dp_write_limit);
 662
 663         if (zfs_no_write_throttle) {
 664                 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK],
 665                     space);
 666                 return (0);
 667         }
 668
 669         /*
 670          * Check to see if we have exceeded the maximum allowed IO for
 671          * this transaction group.  We can do this without locks since
 672          * a little slop here is ok.  Note that we do the reserved check
 673          * with only half the requested reserve: this is because the
 674          * reserve requests are worst-case, and we really don't want to
 675          * throttle based off of worst-case estimates.
 676          */
 677         if (write_limit > 0) {
 678                 reserved = dp->dp_space_towrite[tx->tx_txg & TXG_MASK]
 679                     + dp->dp_tempreserved[tx->tx_txg & TXG_MASK] / 2;
 680
 681                 if (reserved && reserved > write_limit) {
 682                         DMU_TX_STAT_BUMP(dmu_tx_write_limit);
 683                         return (ERESTART);
 684                 }
 685         }
 686
 687         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], space);
 688
 689         /*
 690          * If this transaction group is over 7/8ths capacity, delay
 691          * the caller 1 clock tick.  This will slow down the "fill"
 692          * rate until the sync process can catch up with us.
 693          */
 694         if (reserved && reserved > (write_limit - (write_limit >> 3)))
 695                 txg_delay(dp, tx->tx_txg, 1);
 696
 697         return (0);
 698 }
 699
 700 void
 701 dsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
 702 {
 703         ASSERT(dp->dp_tempreserved[tx->tx_txg & TXG_MASK] >= space);
 704         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], -space);
 705 }
 706
 707 void
 708 dsl_pool_memory_pressure(dsl_pool_t *dp)
 709 {
 710         uint64_t space_inuse = 0;
 711         int i;
 712
 713         if (dp->dp_write_limit == zfs_write_limit_min)
 714                 return;
 715
 716         for (i = 0; i < TXG_SIZE; i++) {
 717                 space_inuse += dp->dp_space_towrite[i];
 718                 space_inuse += dp->dp_tempreserved[i];
 719         }
 720         dp->dp_write_limit = MAX(zfs_write_limit_min,
 721             MIN(dp->dp_write_limit, space_inuse / 4));
 722 }
 723
 724 void
 725 dsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
 726 {
 727         if (space > 0) {
 728                 mutex_enter(&dp->dp_lock);
 729                 dp->dp_space_towrite[tx->tx_txg & TXG_MASK] += space;
 730                 mutex_exit(&dp->dp_lock);
 731         }
 732 }
 733
 734 /* ARGSUSED */
 735 static int
 736 upgrade_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg)
 737 {
 738         dmu_tx_t *tx = arg;
 739         dsl_dataset_t *ds, *prev = NULL;
 740         int err;
 741         dsl_pool_t *dp = spa_get_dsl(spa);
 742
 743         err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
 744         if (err)
 745                 return (err);
 746
 747         while (ds->ds_phys->ds_prev_snap_obj != 0) {
 748                 err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
 749                     FTAG, &prev);
 750                 if (err) {
 751                         dsl_dataset_rele(ds, FTAG);
 752                         return (err);
 753                 }
 754
 755                 if (prev->ds_phys->ds_next_snap_obj != ds->ds_object)
 756                         break;
 757                 dsl_dataset_rele(ds, FTAG);
 758                 ds = prev;
 759                 prev = NULL;
 760         }
 761
 762         if (prev == NULL) {
 763                 prev = dp->dp_origin_snap;
 764
 765                 /*
 766                  * The $ORIGIN can't have any data, or the accounting
 767                  * will be wrong.
 768                  */
 769                 ASSERT(prev->ds_phys->ds_bp.blk_birth == 0);
 770
 771                 /* The origin doesn't get attached to itself */
 772                 if (ds->ds_object == prev->ds_object) {
 773                         dsl_dataset_rele(ds, FTAG);
 774                         return (0);
 775                 }
 776
 777                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
 778                 ds->ds_phys->ds_prev_snap_obj = prev->ds_object;
 779                 ds->ds_phys->ds_prev_snap_txg = prev->ds_phys->ds_creation_txg;
 780
 781                 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx);
 782                 ds->ds_dir->dd_phys->dd_origin_obj = prev->ds_object;
 783
 784                 dmu_buf_will_dirty(prev->ds_dbuf, tx);
 785                 prev->ds_phys->ds_num_children++;
 786
 787                 if (ds->ds_phys->ds_next_snap_obj == 0) {
 788                         ASSERT(ds->ds_prev == NULL);
 789                         VERIFY(0 == dsl_dataset_hold_obj(dp,
 790                             ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev));
 791                 }
 792         }
 793
 794         ASSERT(ds->ds_dir->dd_phys->dd_origin_obj == prev->ds_object);
 795         ASSERT(ds->ds_phys->ds_prev_snap_obj == prev->ds_object);
 796
 797         if (prev->ds_phys->ds_next_clones_obj == 0) {
 798                 dmu_buf_will_dirty(prev->ds_dbuf, tx);
 799                 prev->ds_phys->ds_next_clones_obj =
 800                     zap_create(dp->dp_meta_objset,
 801                     DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
 802         }
 803         VERIFY(0 == zap_add_int(dp->dp_meta_objset,
 804             prev->ds_phys->ds_next_clones_obj, ds->ds_object, tx));
 805
 806         dsl_dataset_rele(ds, FTAG);
 807         if (prev != dp->dp_origin_snap)
 808                 dsl_dataset_rele(prev, FTAG);
 809         return (0);
 810 }
 811
 812 void
 813 dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx)
 814 {
 815         ASSERT(dmu_tx_is_syncing(tx));
 816         ASSERT(dp->dp_origin_snap != NULL);
 817
 818         VERIFY3U(0, ==, dmu_objset_find_spa(dp->dp_spa, NULL, upgrade_clones_cb,
 819             tx, DS_FIND_CHILDREN));
 820 }
 821
 822 /* ARGSUSED */
 823 static int
 824 upgrade_dir_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg)
 825 {
 826         dmu_tx_t *tx = arg;
 827         dsl_dataset_t *ds;
 828         dsl_pool_t *dp = spa_get_dsl(spa);
 829         objset_t *mos = dp->dp_meta_objset;
 830
 831         VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 832
 833         if (ds->ds_dir->dd_phys->dd_origin_obj) {
 834                 dsl_dataset_t *origin;
 835
 836                 VERIFY3U(0, ==, dsl_dataset_hold_obj(dp,
 837                     ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &origin));
 838
 839                 if (origin->ds_dir->dd_phys->dd_clones == 0) {
 840                         dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
 841                         origin->ds_dir->dd_phys->dd_clones = zap_create(mos,
 842                             DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
 843                 }
 844
 845                 VERIFY3U(0, ==, zap_add_int(dp->dp_meta_objset,
 846                     origin->ds_dir->dd_phys->dd_clones, dsobj, tx));
 847
 848                 dsl_dataset_rele(origin, FTAG);
 849         }
 850
 851         dsl_dataset_rele(ds, FTAG);
 852         return (0);
 853 }
 854
 855 void
 856 dsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx)
 857 {
 858         uint64_t obj;
 859
 860         ASSERT(dmu_tx_is_syncing(tx));
 861
 862         (void) dsl_dir_create_sync(dp, dp->dp_root_dir, FREE_DIR_NAME, tx);
 863         VERIFY(0 == dsl_pool_open_special_dir(dp,
 864             FREE_DIR_NAME, &dp->dp_free_dir));
 865
 866         /*
 867          * We can't use bpobj_alloc(), because spa_version() still
 868          * returns the old version, and we need a new-version bpobj with
 869          * subobj support.  So call dmu_object_alloc() directly.
 870          */
 871         obj = dmu_object_alloc(dp->dp_meta_objset, DMU_OT_BPOBJ,
 872             SPA_MAXBLOCKSIZE, DMU_OT_BPOBJ_HDR, sizeof (bpobj_phys_t), tx);
 873         VERIFY3U(0, ==, zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 874             DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx));
 875         VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj,
 876             dp->dp_meta_objset, obj));
 877
 878         VERIFY3U(0, ==, dmu_objset_find_spa(dp->dp_spa, NULL,
 879             upgrade_dir_clones_cb, tx, DS_FIND_CHILDREN));
 880 }
 881
 882 void
 883 dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx)
 884 {
 885         uint64_t dsobj;
 886         dsl_dataset_t *ds;
 887
 888         ASSERT(dmu_tx_is_syncing(tx));
 889         ASSERT(dp->dp_origin_snap == NULL);
 890
 891         /* create the origin dir, ds, & snap-ds */
 892         rw_enter(&dp->dp_config_rwlock, RW_WRITER);
 893         dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME,
 894             NULL, 0, kcred, tx);
 895         VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 896         dsl_dataset_snapshot_sync(ds, ORIGIN_DIR_NAME, tx);
 897         VERIFY(0 == dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
 898             dp, &dp->dp_origin_snap));
 899         dsl_dataset_rele(ds, FTAG);
 900         rw_exit(&dp->dp_config_rwlock);
 901 }
 902
 903 taskq_t *
 904 dsl_pool_iput_taskq(dsl_pool_t *dp)
 905 {
 906         return (dp->dp_iput_taskq);
 907 }
 908
 909 /*
 910  * Walk through the pool-wide zap object of temporary snapshot user holds
 911  * and release them.
 912  */
 913 void
 914 dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
 915 {
 916         zap_attribute_t za;
 917         zap_cursor_t zc;
 918         objset_t *mos = dp->dp_meta_objset;
 919         uint64_t zapobj = dp->dp_tmp_userrefs_obj;
 920
 921         if (zapobj == 0)
 922                 return;
 923         ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
 924
 925         for (zap_cursor_init(&zc, mos, zapobj);
 926             zap_cursor_retrieve(&zc, &za) == 0;
 927             zap_cursor_advance(&zc)) {
 928                 char *htag;
 929                 uint64_t dsobj;
 930
 931                 htag = strchr(za.za_name, '-');
 932                 *htag = '\0';
 933                 ++htag;
 934                 dsobj = strtonum(za.za_name, NULL);
 935                 (void) dsl_dataset_user_release_tmp(dp, dsobj, htag, B_FALSE);
 936         }
 937         zap_cursor_fini(&zc);
 938 }
 939
 940 /*
 941  * Create the pool-wide zap object for storing temporary snapshot holds.
 942  */
 943 void
 944 dsl_pool_user_hold_create_obj(dsl_pool_t *dp, dmu_tx_t *tx)
 945 {
 946         objset_t *mos = dp->dp_meta_objset;
 947
 948         ASSERT(dp->dp_tmp_userrefs_obj == 0);
 949         ASSERT(dmu_tx_is_syncing(tx));
 950
 951         dp->dp_tmp_userrefs_obj = zap_create_link(mos, DMU_OT_USERREFS,
 952             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_TMP_USERREFS, tx);
 953 }
 954
 955 static int
 956 dsl_pool_user_hold_rele_impl(dsl_pool_t *dp, uint64_t dsobj,
 957     const char *tag, uint64_t *now, dmu_tx_t *tx, boolean_t holding)
 958 {
 959         objset_t *mos = dp->dp_meta_objset;
 960         uint64_t zapobj = dp->dp_tmp_userrefs_obj;
 961         char *name;
 962         int error;
 963
 964         ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
 965         ASSERT(dmu_tx_is_syncing(tx));
 966
 967         /*
 968          * If the pool was created prior to SPA_VERSION_USERREFS, the
 969          * zap object for temporary holds might not exist yet.
 970          */
 971         if (zapobj == 0) {
 972                 if (holding) {
 973                         dsl_pool_user_hold_create_obj(dp, tx);
 974                         zapobj = dp->dp_tmp_userrefs_obj;
 975                 } else {
 976                         return (ENOENT);
 977                 }
 978         }
 979
 980         name = kmem_asprintf("%llx-%s", (u_longlong_t)dsobj, tag);
 981         if (holding)
 982                 error = zap_add(mos, zapobj, name, 8, 1, now, tx);
 983         else
 984                 error = zap_remove(mos, zapobj, name, tx);
 985         strfree(name);
 986
 987         return (error);
 988 }
 989
 990 /*
 991  * Add a temporary hold for the given dataset object and tag.
 992  */
 993 int
 994 dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
 995     uint64_t *now, dmu_tx_t *tx)
 996 {
 997         return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, now, tx, B_TRUE));
 998 }
 999
1000 /*
1001  * Release a temporary hold for the given dataset object and tag.
1002  */
1003 int
1004 dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
1005     dmu_tx_t *tx)
1006 {
1007         return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, NULL,
1008             tx, B_FALSE));
1009 }
1010
1011 #if defined(_KERNEL) && defined(HAVE_SPL)
1012 module_param(zfs_no_write_throttle, int, 0644);
1013 MODULE_PARM_DESC(zfs_no_write_throttle, "Disable write throttling");
1014
1015 module_param(zfs_write_limit_shift, int, 0444);
1016 MODULE_PARM_DESC(zfs_write_limit_shift, "log2(fraction of memory) per txg");
1017
1018 module_param(zfs_txg_synctime_ms, int, 0644);
1019 MODULE_PARM_DESC(zfs_txg_synctime_ms, "Target milliseconds between txg sync");
1020
1021 module_param(zfs_txg_history, int, 0644);
1022 MODULE_PARM_DESC(zfs_txg_history, "Historic statistics for the last N txgs");
1023
1024 module_param(zfs_write_limit_min, ulong, 0444);
1025 MODULE_PARM_DESC(zfs_write_limit_min, "Min txg write limit");
1026
1027 module_param(zfs_write_limit_max, ulong, 0444);
1028 MODULE_PARM_DESC(zfs_write_limit_max, "Max txg write limit");
1029
1030 module_param(zfs_write_limit_inflated, ulong, 0444);
1031 MODULE_PARM_DESC(zfs_write_limit_inflated, "Inflated txg write limit");
1032
1033 module_param(zfs_write_limit_override, ulong, 0444);
1034 MODULE_PARM_DESC(zfs_write_limit_override, "Override txg write limit");
1035 #endif