usr/src/uts/common/fs/zfs/dsl_synctask.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, 2017 by Delphix. All rights reserved.
  24  */
  25
  26 #include <sys/dmu.h>
  27 #include <sys/dmu_tx.h>
  28 #include <sys/dsl_pool.h>
  29 #include <sys/dsl_dir.h>
  30 #include <sys/dsl_synctask.h>
  31 #include <sys/metaslab.h>
  32
  33 #define DST_AVG_BLKSHIFT 14
  34
  35 /* ARGSUSED */
  36 static int
  37 dsl_null_checkfunc(void *arg, dmu_tx_t *tx)
  38 {
  39         return (0);
  40 }
  41
  42 static int
  43 dsl_sync_task_common(const char *pool, dsl_checkfunc_t *checkfunc,
  44     dsl_syncfunc_t *syncfunc, void *arg,
  45     int blocks_modified, zfs_space_check_t space_check, boolean_t early)
  46 {
  47         spa_t *spa;
  48         dmu_tx_t *tx;
  49         int err;
  50         dsl_sync_task_t dst = { 0 };
  51         dsl_pool_t *dp;
  52
  53         err = spa_open(pool, &spa, FTAG);
  54         if (err != 0)
  55                 return (err);
  56         dp = spa_get_dsl(spa);
  57
  58 top:
  59         tx = dmu_tx_create_dd(dp->dp_mos_dir);
  60         VERIFY0(dmu_tx_assign(tx, TXG_WAIT));
  61
  62         dst.dst_pool = dp;
  63         dst.dst_txg = dmu_tx_get_txg(tx);
  64         dst.dst_space = blocks_modified << DST_AVG_BLKSHIFT;
  65         dst.dst_space_check = space_check;
  66         dst.dst_checkfunc = checkfunc != NULL ? checkfunc : dsl_null_checkfunc;
  67         dst.dst_syncfunc = syncfunc;
  68         dst.dst_arg = arg;
  69         dst.dst_error = 0;
  70         dst.dst_nowaiter = B_FALSE;
  71
  72         dsl_pool_config_enter(dp, FTAG);
  73         err = dst.dst_checkfunc(arg, tx);
  74         dsl_pool_config_exit(dp, FTAG);
  75
  76         if (err != 0) {
  77                 dmu_tx_commit(tx);
  78                 spa_close(spa, FTAG);
  79                 return (err);
  80         }
  81
  82         txg_list_t *task_list = (early) ?
  83             &dp->dp_early_sync_tasks : &dp->dp_sync_tasks;
  84         VERIFY(txg_list_add_tail(task_list, &dst, dst.dst_txg));
  85
  86         dmu_tx_commit(tx);
  87
  88         txg_wait_synced(dp, dst.dst_txg);
  89
  90         if (dst.dst_error == EAGAIN) {
  91                 txg_wait_synced(dp, dst.dst_txg + TXG_DEFER_SIZE);
  92                 goto top;
  93         }
  94
  95         spa_close(spa, FTAG);
  96         return (dst.dst_error);
  97 }
  98
  99 /*
 100  * Called from open context to perform a callback in syncing context.  Waits
 101  * for the operation to complete.
 102  *
 103  * The checkfunc will be called from open context as a preliminary check
 104  * which can quickly fail.  If it succeeds, it will be called again from
 105  * syncing context.  The checkfunc should generally be designed to work
 106  * properly in either context, but if necessary it can check
 107  * dmu_tx_is_syncing(tx).
 108  *
 109  * The synctask infrastructure enforces proper locking strategy with respect
 110  * to the dp_config_rwlock -- the lock will always be held when the callbacks
 111  * are called.  It will be held for read during the open-context (preliminary)
 112  * call to the checkfunc, and then held for write from syncing context during
 113  * the calls to the check and sync funcs.
 114  *
 115  * A dataset or pool name can be passed as the first argument.  Typically,
 116  * the check func will hold, check the return value of the hold, and then
 117  * release the dataset.  The sync func will VERIFYO(hold()) the dataset.
 118  * This is safe because no changes can be made between the check and sync funcs,
 119  * and the sync func will only be called if the check func successfully opened
 120  * the dataset.
 121  */
 122 int
 123 dsl_sync_task(const char *pool, dsl_checkfunc_t *checkfunc,
 124     dsl_syncfunc_t *syncfunc, void *arg,
 125     int blocks_modified, zfs_space_check_t space_check)
 126 {
 127         return (dsl_sync_task_common(pool, checkfunc, syncfunc, arg,
 128             blocks_modified, space_check, B_FALSE));
 129 }
 130
 131 /*
 132  * An early synctask works exactly as a standard synctask with one important
 133  * difference on the way it is handled during syncing context. Standard
 134  * synctasks run after we've written out all the dirty blocks of dirty
 135  * datasets. Early synctasks are executed before writing out any dirty data,
 136  * and thus before standard synctasks.
 137  *
 138  * For that reason, early synctasks can affect the process of writing dirty
 139  * changes to disk for the txg that they run and should be used with caution.
 140  * In addition, early synctasks should not dirty any metaslabs as this would
 141  * invalidate the precodition/invariant for subsequent early synctasks.
 142  * [see dsl_pool_sync() and dsl_early_sync_task_verify()]
 143  */
 144 int
 145 dsl_early_sync_task(const char *pool, dsl_checkfunc_t *checkfunc,
 146     dsl_syncfunc_t *syncfunc, void *arg,
 147     int blocks_modified, zfs_space_check_t space_check)
 148 {
 149         return (dsl_sync_task_common(pool, checkfunc, syncfunc, arg,
 150             blocks_modified, space_check, B_TRUE));
 151 }
 152
 153 static void
 154 dsl_sync_task_nowait_common(dsl_pool_t *dp, dsl_syncfunc_t *syncfunc, void *arg,
 155     int blocks_modified, zfs_space_check_t space_check, dmu_tx_t *tx,
 156     boolean_t early)
 157 {
 158         dsl_sync_task_t *dst = kmem_zalloc(sizeof (*dst), KM_SLEEP);
 159
 160         dst->dst_pool = dp;
 161         dst->dst_txg = dmu_tx_get_txg(tx);
 162         dst->dst_space = blocks_modified << DST_AVG_BLKSHIFT;
 163         dst->dst_space_check = space_check;
 164         dst->dst_checkfunc = dsl_null_checkfunc;
 165         dst->dst_syncfunc = syncfunc;
 166         dst->dst_arg = arg;
 167         dst->dst_error = 0;
 168         dst->dst_nowaiter = B_TRUE;
 169
 170         txg_list_t *task_list = (early) ?
 171             &dp->dp_early_sync_tasks : &dp->dp_sync_tasks;
 172         VERIFY(txg_list_add_tail(task_list, dst, dst->dst_txg));
 173 }
 174
 175 void
 176 dsl_sync_task_nowait(dsl_pool_t *dp, dsl_syncfunc_t *syncfunc, void *arg,
 177     int blocks_modified, zfs_space_check_t space_check, dmu_tx_t *tx)
 178 {
 179         dsl_sync_task_nowait_common(dp, syncfunc, arg,
 180             blocks_modified, space_check, tx, B_FALSE);
 181 }
 182
 183 void
 184 dsl_early_sync_task_nowait(dsl_pool_t *dp, dsl_syncfunc_t *syncfunc, void *arg,
 185     int blocks_modified, zfs_space_check_t space_check, dmu_tx_t *tx)
 186 {
 187         dsl_sync_task_nowait_common(dp, syncfunc, arg,
 188             blocks_modified, space_check, tx, B_TRUE);
 189 }
 190
 191 /*
 192  * Called in syncing context to execute the synctask.
 193  */
 194 void
 195 dsl_sync_task_sync(dsl_sync_task_t *dst, dmu_tx_t *tx)
 196 {
 197         dsl_pool_t *dp = dst->dst_pool;
 198
 199         ASSERT0(dst->dst_error);
 200
 201         /*
 202          * Check for sufficient space.
 203          *
 204          * When the sync task was created, the caller specified the
 205          * type of space checking required.  See the comment in
 206          * zfs_space_check_t for details on the semantics of each
 207          * type of space checking.
 208          *
 209          * We just check against what's on-disk; we don't want any
 210          * in-flight accounting to get in our way, because open context
 211          * may have already used up various in-core limits
 212          * (arc_tempreserve, dsl_pool_tempreserve).
 213          */
 214         if (dst->dst_space_check != ZFS_SPACE_CHECK_NONE) {
 215                 uint64_t quota = dsl_pool_unreserved_space(dp,
 216                     dst->dst_space_check);
 217                 uint64_t used = dsl_dir_phys(dp->dp_root_dir)->dd_used_bytes;
 218
 219                 /* MOS space is triple-dittoed, so we multiply by 3. */
 220                 if (used + dst->dst_space * 3 > quota) {
 221                         dst->dst_error = SET_ERROR(ENOSPC);
 222                         if (dst->dst_nowaiter)
 223                                 kmem_free(dst, sizeof (*dst));
 224                         return;
 225                 }
 226         }
 227
 228         /*
 229          * Check for errors by calling checkfunc.
 230          */
 231         rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
 232         dst->dst_error = dst->dst_checkfunc(dst->dst_arg, tx);
 233         if (dst->dst_error == 0)
 234                 dst->dst_syncfunc(dst->dst_arg, tx);
 235         rrw_exit(&dp->dp_config_rwlock, FTAG);
 236         if (dst->dst_nowaiter)
 237                 kmem_free(dst, sizeof (*dst));
 238 }