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.
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.
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]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
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>
33 #define DST_AVG_BLKSHIFT 14
37 dsl_null_checkfunc(void *arg
, dmu_tx_t
*tx
)
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
)
50 dsl_sync_task_t dst
= { 0 };
53 err
= spa_open(pool
, &spa
, FTAG
);
56 dp
= spa_get_dsl(spa
);
59 tx
= dmu_tx_create_dd(dp
->dp_mos_dir
);
60 VERIFY0(dmu_tx_assign(tx
, TXG_WAIT
));
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
;
70 dst
.dst_nowaiter
= B_FALSE
;
72 dsl_pool_config_enter(dp
, FTAG
);
73 err
= dst
.dst_checkfunc(arg
, tx
);
74 dsl_pool_config_exit(dp
, FTAG
);
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
));
88 txg_wait_synced(dp
, dst
.dst_txg
);
90 if (dst
.dst_error
== EAGAIN
) {
91 txg_wait_synced(dp
, dst
.dst_txg
+ TXG_DEFER_SIZE
);
96 return (dst
.dst_error
);
100 * Called from open context to perform a callback in syncing context. Waits
101 * for the operation to complete.
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).
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.
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
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
)
127 return (dsl_sync_task_common(pool
, checkfunc
, syncfunc
, arg
,
128 blocks_modified
, space_check
, B_FALSE
));
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.
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()]
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
)
149 return (dsl_sync_task_common(pool
, checkfunc
, syncfunc
, arg
,
150 blocks_modified
, space_check
, B_TRUE
));
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
,
158 dsl_sync_task_t
*dst
= kmem_zalloc(sizeof (*dst
), KM_SLEEP
);
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
;
168 dst
->dst_nowaiter
= B_TRUE
;
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
));
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
)
179 dsl_sync_task_nowait_common(dp
, syncfunc
, arg
,
180 blocks_modified
, space_check
, tx
, B_FALSE
);
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
)
187 dsl_sync_task_nowait_common(dp
, syncfunc
, arg
,
188 blocks_modified
, space_check
, tx
, B_TRUE
);
192 * Called in syncing context to execute the synctask.
195 dsl_sync_task_sync(dsl_sync_task_t
*dst
, dmu_tx_t
*tx
)
197 dsl_pool_t
*dp
= dst
->dst_pool
;
199 ASSERT0(dst
->dst_error
);
202 * Check for sufficient space.
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.
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).
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
;
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
));
229 * Check for errors by calling checkfunc.
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
));