xref: /illumos-gate/usr/src/uts/common/fs/zfs/zcp_synctask.c (revision dfc115332c94a2f62058ac7f2bce7631fbd20b3d)
1 /*
2  * CDDL HEADER START
3  *
4  * This file and its contents are supplied under the terms of the
5  * Common Development and Distribution License ("CDDL"), version 1.0.
6  * You may only use this file in accordance with the terms of version
7  * 1.0 of the CDDL.
8  *
9  * A full copy of the text of the CDDL should have accompanied this
10  * source.  A copy of the CDDL is also available via the Internet at
11  * http://www.illumos.org/license/CDDL.
12  *
13  * CDDL HEADER END
14  */
15 
16 /*
17  * Copyright (c) 2016 by Delphix. All rights reserved.
18  */
19 
20 #include "lua.h"
21 #include "lauxlib.h"
22 
23 #include <sys/zcp.h>
24 #include <sys/dsl_dir.h>
25 #include <sys/dsl_pool.h>
26 #include <sys/dsl_prop.h>
27 #include <sys/dsl_synctask.h>
28 #include <sys/dsl_dataset.h>
29 #include <sys/dsl_bookmark.h>
30 #include <sys/dsl_destroy.h>
31 #include <sys/dmu_objset.h>
32 #include <sys/zfs_znode.h>
33 #include <sys/zfeature.h>
34 #include <sys/metaslab.h>
35 
36 #define	DST_AVG_BLKSHIFT 14
37 
38 typedef int (zcp_synctask_func_t)(lua_State *, boolean_t, nvlist_t *);
39 typedef struct zcp_synctask_info {
40 	const char *name;
41 	zcp_synctask_func_t *func;
42 	zfs_space_check_t space_check;
43 	int blocks_modified;
44 	const zcp_arg_t pargs[4];
45 	const zcp_arg_t kwargs[2];
46 } zcp_synctask_info_t;
47 
48 /*
49  * Generic synctask interface for channel program syncfuncs.
50  *
51  * To perform some action in syncing context, we'd generally call
52  * dsl_sync_task(), but since the Lua script is already running inside a
53  * synctask we need to leave out some actions (such as acquiring the config
54  * rwlock and performing space checks).
55  *
56  * If 'sync' is false, executes a dry run and returns the error code.
57  *
58  * This function also handles common fatal error cases for channel program
59  * library functions. If a fatal error occurs, err_dsname will be the dataset
60  * name reported in error messages, if supplied.
61  */
62 static int
63 zcp_sync_task(lua_State *state, dsl_checkfunc_t *checkfunc,
64     dsl_syncfunc_t *syncfunc, void *arg, boolean_t sync, const char *err_dsname)
65 {
66 	int err;
67 	zcp_run_info_t *ri = zcp_run_info(state);
68 
69 	err = checkfunc(arg, ri->zri_tx);
70 	if (!sync)
71 		return (err);
72 
73 	if (err == 0) {
74 		syncfunc(arg, ri->zri_tx);
75 	} else if (err == EIO) {
76 		if (err_dsname != NULL) {
77 			return (luaL_error(state,
78 			    "I/O error while accessing dataset '%s'",
79 			    err_dsname));
80 		} else {
81 			return (luaL_error(state,
82 			    "I/O error while accessing dataset."));
83 		}
84 	}
85 
86 	return (err);
87 }
88 
89 
90 static int zcp_synctask_destroy(lua_State *, boolean_t, nvlist_t *);
91 static zcp_synctask_info_t zcp_synctask_destroy_info = {
92 	.name = "destroy",
93 	.func = zcp_synctask_destroy,
94 	.space_check = ZFS_SPACE_CHECK_NONE,
95 	.blocks_modified = 0,
96 	.pargs = {
97 	    {.za_name = "filesystem | snapshot", .za_lua_type = LUA_TSTRING},
98 	    {NULL, NULL}
99 	},
100 	.kwargs = {
101 	    {.za_name = "defer", .za_lua_type = LUA_TBOOLEAN},
102 	    {NULL, NULL}
103 	}
104 };
105 
106 /* ARGSUSED */
107 static int
108 zcp_synctask_destroy(lua_State *state, boolean_t sync, nvlist_t *err_details)
109 {
110 	int err;
111 	const char *dsname = lua_tostring(state, 1);
112 
113 	boolean_t issnap = (strchr(dsname, '@') != NULL);
114 
115 	if (!issnap && !lua_isnil(state, 2)) {
116 		return (luaL_error(state,
117 		    "'deferred' kwarg only supported for snapshots: %s",
118 		    dsname));
119 	}
120 
121 	if (issnap) {
122 		dsl_destroy_snapshot_arg_t ddsa = { 0 };
123 		ddsa.ddsa_name = dsname;
124 		if (!lua_isnil(state, 2)) {
125 			ddsa.ddsa_defer = lua_toboolean(state, 2);
126 		} else {
127 			ddsa.ddsa_defer = B_FALSE;
128 		}
129 
130 		err = zcp_sync_task(state, dsl_destroy_snapshot_check,
131 		    dsl_destroy_snapshot_sync, &ddsa, sync, dsname);
132 	} else {
133 		dsl_destroy_head_arg_t ddha = { 0 };
134 		ddha.ddha_name = dsname;
135 
136 		err = zcp_sync_task(state, dsl_destroy_head_check,
137 		    dsl_destroy_head_sync, &ddha, sync, dsname);
138 	}
139 
140 	return (err);
141 }
142 
143 static int zcp_synctask_promote(lua_State *, boolean_t, nvlist_t *err_details);
144 static zcp_synctask_info_t zcp_synctask_promote_info = {
145 	.name = "promote",
146 	.func = zcp_synctask_promote,
147 	.space_check = ZFS_SPACE_CHECK_RESERVED,
148 	.blocks_modified = 3,
149 	.pargs = {
150 	    {.za_name = "clone", .za_lua_type = LUA_TSTRING},
151 	    {NULL, NULL}
152 	},
153 	.kwargs = {
154 	    {NULL, NULL}
155 	}
156 };
157 
158 static int
159 zcp_synctask_promote(lua_State *state, boolean_t sync, nvlist_t *err_details)
160 {
161 	int err;
162 	dsl_dataset_promote_arg_t ddpa = { 0 };
163 	const char *dsname = lua_tostring(state, 1);
164 	zcp_run_info_t *ri = zcp_run_info(state);
165 
166 	ddpa.ddpa_clonename = dsname;
167 	ddpa.err_ds = err_details;
168 	ddpa.cr = ri->zri_cred;
169 
170 	/*
171 	 * If there was a snapshot name conflict, then err_ds will be filled
172 	 * with a list of conflicting snapshot names.
173 	 */
174 	err = zcp_sync_task(state, dsl_dataset_promote_check,
175 	    dsl_dataset_promote_sync, &ddpa, sync, dsname);
176 
177 	return (err);
178 }
179 
180 void
181 zcp_synctask_wrapper_cleanup(void *arg)
182 {
183 	fnvlist_free(arg);
184 }
185 
186 static int
187 zcp_synctask_wrapper(lua_State *state)
188 {
189 	int err;
190 	int num_ret = 1;
191 	nvlist_t *err_details = fnvlist_alloc();
192 
193 	/*
194 	 * Make sure err_details is properly freed, even if a fatal error is
195 	 * thrown during the synctask.
196 	 */
197 	zcp_register_cleanup(state, &zcp_synctask_wrapper_cleanup, err_details);
198 
199 	zcp_synctask_info_t *info = lua_touserdata(state, lua_upvalueindex(1));
200 	boolean_t sync = lua_toboolean(state, lua_upvalueindex(2));
201 
202 	zcp_run_info_t *ri = zcp_run_info(state);
203 	dsl_pool_t *dp = ri->zri_pool;
204 
205 	/* MOS space is triple-dittoed, so we multiply by 3. */
206 	uint64_t funcspace = (info->blocks_modified << DST_AVG_BLKSHIFT) * 3;
207 
208 	zcp_parse_args(state, info->name, info->pargs, info->kwargs);
209 
210 	err = 0;
211 	if (info->space_check != ZFS_SPACE_CHECK_NONE && funcspace > 0) {
212 		uint64_t quota = dsl_pool_adjustedsize(dp,
213 		    info->space_check == ZFS_SPACE_CHECK_RESERVED) -
214 		    metaslab_class_get_deferred(spa_normal_class(dp->dp_spa));
215 		uint64_t used = dsl_dir_phys(dp->dp_root_dir)->dd_used_bytes +
216 		    ri->zri_space_used;
217 
218 		if (used + funcspace > quota) {
219 			err = SET_ERROR(ENOSPC);
220 		}
221 	}
222 
223 	if (err == 0) {
224 		err = info->func(state, sync, err_details);
225 	}
226 
227 	if (err == 0) {
228 		ri->zri_space_used += funcspace;
229 	}
230 
231 	lua_pushnumber(state, (lua_Number)err);
232 	if (fnvlist_num_pairs(err_details) > 0) {
233 		(void) zcp_nvlist_to_lua(state, err_details, NULL, 0);
234 		num_ret++;
235 	}
236 
237 	zcp_clear_cleanup(state);
238 	fnvlist_free(err_details);
239 
240 	return (num_ret);
241 }
242 
243 int
244 zcp_load_synctask_lib(lua_State *state, boolean_t sync)
245 {
246 	int i;
247 	zcp_synctask_info_t *zcp_synctask_funcs[] = {
248 		&zcp_synctask_destroy_info,
249 		&zcp_synctask_promote_info,
250 		NULL
251 	};
252 
253 	lua_newtable(state);
254 
255 	for (i = 0; zcp_synctask_funcs[i] != NULL; i++) {
256 		zcp_synctask_info_t *info = zcp_synctask_funcs[i];
257 		lua_pushlightuserdata(state, info);
258 		lua_pushboolean(state, sync);
259 		lua_pushcclosure(state, &zcp_synctask_wrapper, 2);
260 		lua_setfield(state, -2, info->name);
261 		info++;
262 	}
263 
264 	return (1);
265 }
266