1dfc11533SChris Williamson /*
2dfc11533SChris Williamson * CDDL HEADER START
3dfc11533SChris Williamson *
4dfc11533SChris Williamson * This file and its contents are supplied under the terms of the
5dfc11533SChris Williamson * Common Development and Distribution License ("CDDL"), version 1.0.
6dfc11533SChris Williamson * You may only use this file in accordance with the terms of version
7dfc11533SChris Williamson * 1.0 of the CDDL.
8dfc11533SChris Williamson *
9dfc11533SChris Williamson * A full copy of the text of the CDDL should have accompanied this
10dfc11533SChris Williamson * source. A copy of the CDDL is also available via the Internet at
11dfc11533SChris Williamson * http://www.illumos.org/license/CDDL.
12dfc11533SChris Williamson *
13dfc11533SChris Williamson * CDDL HEADER END
14dfc11533SChris Williamson */
15dfc11533SChris Williamson
16dfc11533SChris Williamson /*
17000cce6bSBrad Lewis * Copyright (c) 2016, 2017 by Delphix. All rights reserved.
182d85dedbSJason King * Copyright 2020 Joyent, Inc.
19dfc11533SChris Williamson */
20dfc11533SChris Williamson
21dfc11533SChris Williamson #include "lua.h"
22dfc11533SChris Williamson #include "lauxlib.h"
23dfc11533SChris Williamson
24dfc11533SChris Williamson #include <sys/zcp.h>
25b2d2f356SSara Hartse #include <sys/zcp_set.h>
26*d8f839f9SJason King #include <sys/zcp_change_key.h>
27*d8f839f9SJason King #include <sys/dsl_crypt.h>
28dfc11533SChris Williamson #include <sys/dsl_dir.h>
29dfc11533SChris Williamson #include <sys/dsl_pool.h>
30dfc11533SChris Williamson #include <sys/dsl_prop.h>
31dfc11533SChris Williamson #include <sys/dsl_synctask.h>
32dfc11533SChris Williamson #include <sys/dsl_dataset.h>
33dfc11533SChris Williamson #include <sys/dsl_bookmark.h>
34dfc11533SChris Williamson #include <sys/dsl_destroy.h>
35dfc11533SChris Williamson #include <sys/dmu_objset.h>
36dfc11533SChris Williamson #include <sys/zfs_znode.h>
37dfc11533SChris Williamson #include <sys/zfeature.h>
38dfc11533SChris Williamson #include <sys/metaslab.h>
39dfc11533SChris Williamson
40dfc11533SChris Williamson #define DST_AVG_BLKSHIFT 14
41dfc11533SChris Williamson
422d85dedbSJason King typedef struct zcp_inherit_prop_arg {
432d85dedbSJason King lua_State *zipa_state;
442d85dedbSJason King const char *zipa_prop;
452d85dedbSJason King dsl_props_set_arg_t zipa_dpsa;
462d85dedbSJason King } zcp_inherit_prop_arg_t;
472d85dedbSJason King
48dfc11533SChris Williamson typedef int (zcp_synctask_func_t)(lua_State *, boolean_t, nvlist_t *);
49dfc11533SChris Williamson typedef struct zcp_synctask_info {
50dfc11533SChris Williamson const char *name;
51dfc11533SChris Williamson zcp_synctask_func_t *func;
52dfc11533SChris Williamson const zcp_arg_t pargs[4];
53dfc11533SChris Williamson const zcp_arg_t kwargs[2];
542840dce1SChris Williamson zfs_space_check_t space_check;
552840dce1SChris Williamson int blocks_modified;
56dfc11533SChris Williamson } zcp_synctask_info_t;
57dfc11533SChris Williamson
58dfc11533SChris Williamson /*
59dfc11533SChris Williamson * Generic synctask interface for channel program syncfuncs.
60dfc11533SChris Williamson *
61dfc11533SChris Williamson * To perform some action in syncing context, we'd generally call
62dfc11533SChris Williamson * dsl_sync_task(), but since the Lua script is already running inside a
63dfc11533SChris Williamson * synctask we need to leave out some actions (such as acquiring the config
64dfc11533SChris Williamson * rwlock and performing space checks).
65dfc11533SChris Williamson *
66dfc11533SChris Williamson * If 'sync' is false, executes a dry run and returns the error code.
67dfc11533SChris Williamson *
68a3b28680SSerapheim Dimitropoulos * If we are not running in syncing context and we are not doing a dry run
69a3b28680SSerapheim Dimitropoulos * (meaning we are running a zfs.sync function in open-context) then we
70a3b28680SSerapheim Dimitropoulos * return a Lua error.
71a3b28680SSerapheim Dimitropoulos *
72dfc11533SChris Williamson * This function also handles common fatal error cases for channel program
73dfc11533SChris Williamson * library functions. If a fatal error occurs, err_dsname will be the dataset
74dfc11533SChris Williamson * name reported in error messages, if supplied.
75dfc11533SChris Williamson */
76dfc11533SChris Williamson static int
zcp_sync_task(lua_State * state,dsl_checkfunc_t * checkfunc,dsl_syncfunc_t * syncfunc,void * arg,boolean_t sync,const char * err_dsname)77dfc11533SChris Williamson zcp_sync_task(lua_State *state, dsl_checkfunc_t *checkfunc,
78dfc11533SChris Williamson dsl_syncfunc_t *syncfunc, void *arg, boolean_t sync, const char *err_dsname)
79dfc11533SChris Williamson {
80dfc11533SChris Williamson int err;
81dfc11533SChris Williamson zcp_run_info_t *ri = zcp_run_info(state);
82dfc11533SChris Williamson
83dfc11533SChris Williamson err = checkfunc(arg, ri->zri_tx);
84dfc11533SChris Williamson if (!sync)
85dfc11533SChris Williamson return (err);
86dfc11533SChris Williamson
87a3b28680SSerapheim Dimitropoulos if (!ri->zri_sync) {
88a3b28680SSerapheim Dimitropoulos return (luaL_error(state, "running functions from the zfs.sync "
89a3b28680SSerapheim Dimitropoulos "submodule requires passing sync=TRUE to "
90a3b28680SSerapheim Dimitropoulos "lzc_channel_program() (i.e. do not specify the \"-n\" "
91a3b28680SSerapheim Dimitropoulos "command line argument)"));
92a3b28680SSerapheim Dimitropoulos }
93a3b28680SSerapheim Dimitropoulos
94dfc11533SChris Williamson if (err == 0) {
95dfc11533SChris Williamson syncfunc(arg, ri->zri_tx);
96dfc11533SChris Williamson } else if (err == EIO) {
97dfc11533SChris Williamson if (err_dsname != NULL) {
98dfc11533SChris Williamson return (luaL_error(state,
99dfc11533SChris Williamson "I/O error while accessing dataset '%s'",
100dfc11533SChris Williamson err_dsname));
101dfc11533SChris Williamson } else {
102dfc11533SChris Williamson return (luaL_error(state,
103dfc11533SChris Williamson "I/O error while accessing dataset."));
104dfc11533SChris Williamson }
105dfc11533SChris Williamson }
106dfc11533SChris Williamson
107dfc11533SChris Williamson return (err);
108dfc11533SChris Williamson }
109dfc11533SChris Williamson
110dfc11533SChris Williamson
111dfc11533SChris Williamson static int zcp_synctask_destroy(lua_State *, boolean_t, nvlist_t *);
112dfc11533SChris Williamson static zcp_synctask_info_t zcp_synctask_destroy_info = {
113dfc11533SChris Williamson .name = "destroy",
114dfc11533SChris Williamson .func = zcp_synctask_destroy,
115dfc11533SChris Williamson .pargs = {
116dfc11533SChris Williamson {.za_name = "filesystem | snapshot", .za_lua_type = LUA_TSTRING},
117dd328bf6SToomas Soome {NULL, 0}
118dfc11533SChris Williamson },
119dfc11533SChris Williamson .kwargs = {
120dfc11533SChris Williamson {.za_name = "defer", .za_lua_type = LUA_TBOOLEAN},
121dd328bf6SToomas Soome {NULL, 0}
1222840dce1SChris Williamson },
12386714001SSerapheim Dimitropoulos .space_check = ZFS_SPACE_CHECK_DESTROY,
1242840dce1SChris Williamson .blocks_modified = 0
125dfc11533SChris Williamson };
126dfc11533SChris Williamson
127dfc11533SChris Williamson /* ARGSUSED */
128dfc11533SChris Williamson static int
zcp_synctask_destroy(lua_State * state,boolean_t sync,nvlist_t * err_details)129dfc11533SChris Williamson zcp_synctask_destroy(lua_State *state, boolean_t sync, nvlist_t *err_details)
130dfc11533SChris Williamson {
131dfc11533SChris Williamson int err;
132dfc11533SChris Williamson const char *dsname = lua_tostring(state, 1);
133dfc11533SChris Williamson
134dfc11533SChris Williamson boolean_t issnap = (strchr(dsname, '@') != NULL);
135dfc11533SChris Williamson
136dfc11533SChris Williamson if (!issnap && !lua_isnil(state, 2)) {
137dfc11533SChris Williamson return (luaL_error(state,
138dfc11533SChris Williamson "'deferred' kwarg only supported for snapshots: %s",
139dfc11533SChris Williamson dsname));
140dfc11533SChris Williamson }
141dfc11533SChris Williamson
142dfc11533SChris Williamson if (issnap) {
143dfc11533SChris Williamson dsl_destroy_snapshot_arg_t ddsa = { 0 };
144dfc11533SChris Williamson ddsa.ddsa_name = dsname;
145dfc11533SChris Williamson if (!lua_isnil(state, 2)) {
146dfc11533SChris Williamson ddsa.ddsa_defer = lua_toboolean(state, 2);
147dfc11533SChris Williamson } else {
148dfc11533SChris Williamson ddsa.ddsa_defer = B_FALSE;
149dfc11533SChris Williamson }
150dfc11533SChris Williamson
151dfc11533SChris Williamson err = zcp_sync_task(state, dsl_destroy_snapshot_check,
152dfc11533SChris Williamson dsl_destroy_snapshot_sync, &ddsa, sync, dsname);
153dfc11533SChris Williamson } else {
154dfc11533SChris Williamson dsl_destroy_head_arg_t ddha = { 0 };
155dfc11533SChris Williamson ddha.ddha_name = dsname;
156dfc11533SChris Williamson
157dfc11533SChris Williamson err = zcp_sync_task(state, dsl_destroy_head_check,
158dfc11533SChris Williamson dsl_destroy_head_sync, &ddha, sync, dsname);
159dfc11533SChris Williamson }
160dfc11533SChris Williamson
161dfc11533SChris Williamson return (err);
162dfc11533SChris Williamson }
163dfc11533SChris Williamson
1642840dce1SChris Williamson static int zcp_synctask_promote(lua_State *, boolean_t, nvlist_t *);
165dfc11533SChris Williamson static zcp_synctask_info_t zcp_synctask_promote_info = {
166dfc11533SChris Williamson .name = "promote",
167dfc11533SChris Williamson .func = zcp_synctask_promote,
168dfc11533SChris Williamson .pargs = {
169dfc11533SChris Williamson {.za_name = "clone", .za_lua_type = LUA_TSTRING},
170dd328bf6SToomas Soome {NULL, 0}
171dfc11533SChris Williamson },
172dfc11533SChris Williamson .kwargs = {
173dd328bf6SToomas Soome {NULL, 0}
1742840dce1SChris Williamson },
1752840dce1SChris Williamson .space_check = ZFS_SPACE_CHECK_RESERVED,
1762840dce1SChris Williamson .blocks_modified = 3
177dfc11533SChris Williamson };
178dfc11533SChris Williamson
179dfc11533SChris Williamson static int
zcp_synctask_promote(lua_State * state,boolean_t sync,nvlist_t * err_details)180dfc11533SChris Williamson zcp_synctask_promote(lua_State *state, boolean_t sync, nvlist_t *err_details)
181dfc11533SChris Williamson {
182dfc11533SChris Williamson int err;
183dfc11533SChris Williamson dsl_dataset_promote_arg_t ddpa = { 0 };
184dfc11533SChris Williamson const char *dsname = lua_tostring(state, 1);
185dfc11533SChris Williamson zcp_run_info_t *ri = zcp_run_info(state);
186dfc11533SChris Williamson
187dfc11533SChris Williamson ddpa.ddpa_clonename = dsname;
188dfc11533SChris Williamson ddpa.err_ds = err_details;
189dfc11533SChris Williamson ddpa.cr = ri->zri_cred;
190dfc11533SChris Williamson
191dfc11533SChris Williamson /*
192dfc11533SChris Williamson * If there was a snapshot name conflict, then err_ds will be filled
193dfc11533SChris Williamson * with a list of conflicting snapshot names.
194dfc11533SChris Williamson */
195dfc11533SChris Williamson err = zcp_sync_task(state, dsl_dataset_promote_check,
196dfc11533SChris Williamson dsl_dataset_promote_sync, &ddpa, sync, dsname);
197dfc11533SChris Williamson
198dfc11533SChris Williamson return (err);
199dfc11533SChris Williamson }
200dfc11533SChris Williamson
201000cce6bSBrad Lewis static int zcp_synctask_rollback(lua_State *, boolean_t, nvlist_t *err_details);
202000cce6bSBrad Lewis static zcp_synctask_info_t zcp_synctask_rollback_info = {
203000cce6bSBrad Lewis .name = "rollback",
204000cce6bSBrad Lewis .func = zcp_synctask_rollback,
205000cce6bSBrad Lewis .space_check = ZFS_SPACE_CHECK_RESERVED,
206000cce6bSBrad Lewis .blocks_modified = 1,
207000cce6bSBrad Lewis .pargs = {
208000cce6bSBrad Lewis {.za_name = "filesystem", .za_lua_type = LUA_TSTRING},
209dd328bf6SToomas Soome {NULL, 0}
210000cce6bSBrad Lewis },
211000cce6bSBrad Lewis .kwargs = {
212dd328bf6SToomas Soome {NULL, 0}
213000cce6bSBrad Lewis }
214000cce6bSBrad Lewis };
215000cce6bSBrad Lewis
216000cce6bSBrad Lewis static int
zcp_synctask_rollback(lua_State * state,boolean_t sync,nvlist_t * err_details)217000cce6bSBrad Lewis zcp_synctask_rollback(lua_State *state, boolean_t sync, nvlist_t *err_details)
218000cce6bSBrad Lewis {
219000cce6bSBrad Lewis int err;
220000cce6bSBrad Lewis const char *dsname = lua_tostring(state, 1);
221000cce6bSBrad Lewis dsl_dataset_rollback_arg_t ddra = { 0 };
222000cce6bSBrad Lewis
223000cce6bSBrad Lewis ddra.ddra_fsname = dsname;
224000cce6bSBrad Lewis ddra.ddra_result = err_details;
225000cce6bSBrad Lewis
226000cce6bSBrad Lewis err = zcp_sync_task(state, dsl_dataset_rollback_check,
227000cce6bSBrad Lewis dsl_dataset_rollback_sync, &ddra, sync, dsname);
228000cce6bSBrad Lewis
229000cce6bSBrad Lewis return (err);
230000cce6bSBrad Lewis }
231000cce6bSBrad Lewis
2322840dce1SChris Williamson static int zcp_synctask_snapshot(lua_State *, boolean_t, nvlist_t *);
2332840dce1SChris Williamson static zcp_synctask_info_t zcp_synctask_snapshot_info = {
2342840dce1SChris Williamson .name = "snapshot",
2352840dce1SChris Williamson .func = zcp_synctask_snapshot,
2362840dce1SChris Williamson .pargs = {
2372840dce1SChris Williamson {.za_name = "filesystem@snapname | volume@snapname",
2382840dce1SChris Williamson .za_lua_type = LUA_TSTRING},
239dd328bf6SToomas Soome {NULL, 0}
2402840dce1SChris Williamson },
2412840dce1SChris Williamson .kwargs = {
242dd328bf6SToomas Soome {NULL, 0}
2432840dce1SChris Williamson },
2442840dce1SChris Williamson .space_check = ZFS_SPACE_CHECK_NORMAL,
2452840dce1SChris Williamson .blocks_modified = 3
2462840dce1SChris Williamson };
2472840dce1SChris Williamson
2482840dce1SChris Williamson /* ARGSUSED */
2492840dce1SChris Williamson static int
zcp_synctask_snapshot(lua_State * state,boolean_t sync,nvlist_t * err_details)2502840dce1SChris Williamson zcp_synctask_snapshot(lua_State *state, boolean_t sync, nvlist_t *err_details)
2512840dce1SChris Williamson {
2522840dce1SChris Williamson int err;
2532840dce1SChris Williamson dsl_dataset_snapshot_arg_t ddsa = { 0 };
2542840dce1SChris Williamson const char *dsname = lua_tostring(state, 1);
2552840dce1SChris Williamson zcp_run_info_t *ri = zcp_run_info(state);
2562840dce1SChris Williamson
257a3b28680SSerapheim Dimitropoulos /*
258a3b28680SSerapheim Dimitropoulos * On old pools, the ZIL must not be active when a snapshot is created,
259a3b28680SSerapheim Dimitropoulos * but we can't suspend the ZIL because we're already in syncing
260a3b28680SSerapheim Dimitropoulos * context.
261a3b28680SSerapheim Dimitropoulos */
262a3b28680SSerapheim Dimitropoulos if (spa_version(ri->zri_pool->dp_spa) < SPA_VERSION_FAST_SNAP) {
263a3b28680SSerapheim Dimitropoulos return (ENOTSUP);
264a3b28680SSerapheim Dimitropoulos }
265a3b28680SSerapheim Dimitropoulos
2662840dce1SChris Williamson /*
2672840dce1SChris Williamson * We only allow for a single snapshot rather than a list, so the
2682840dce1SChris Williamson * error list output is unnecessary.
2692840dce1SChris Williamson */
2702840dce1SChris Williamson ddsa.ddsa_errors = NULL;
2712840dce1SChris Williamson ddsa.ddsa_props = NULL;
2722840dce1SChris Williamson ddsa.ddsa_cr = ri->zri_cred;
2732840dce1SChris Williamson ddsa.ddsa_snaps = fnvlist_alloc();
2742840dce1SChris Williamson fnvlist_add_boolean(ddsa.ddsa_snaps, dsname);
2752840dce1SChris Williamson
276a3b28680SSerapheim Dimitropoulos zcp_cleanup_handler_t *zch = zcp_register_cleanup(state,
277a3b28680SSerapheim Dimitropoulos (zcp_cleanup_t *)&fnvlist_free, ddsa.ddsa_snaps);
2782840dce1SChris Williamson
2792840dce1SChris Williamson err = zcp_sync_task(state, dsl_dataset_snapshot_check,
2802840dce1SChris Williamson dsl_dataset_snapshot_sync, &ddsa, sync, dsname);
2812840dce1SChris Williamson
282a3b28680SSerapheim Dimitropoulos zcp_deregister_cleanup(state, zch);
2832840dce1SChris Williamson fnvlist_free(ddsa.ddsa_snaps);
2842840dce1SChris Williamson
2852840dce1SChris Williamson return (err);
2862840dce1SChris Williamson }
2872840dce1SChris Williamson
2882d85dedbSJason King static int zcp_synctask_inherit_prop(lua_State *, boolean_t,
2892d85dedbSJason King nvlist_t *err_details);
2902d85dedbSJason King static zcp_synctask_info_t zcp_synctask_inherit_prop_info = {
2912d85dedbSJason King .name = "inherit",
2922d85dedbSJason King .func = zcp_synctask_inherit_prop,
2932d85dedbSJason King .space_check = ZFS_SPACE_CHECK_RESERVED,
2942d85dedbSJason King .blocks_modified = 2, /* 2 * numprops */
2952d85dedbSJason King .pargs = {
2962d85dedbSJason King { .za_name = "dataset", .za_lua_type = LUA_TSTRING },
2972d85dedbSJason King { .za_name = "property", .za_lua_type = LUA_TSTRING },
2982d85dedbSJason King { NULL, 0 }
2992d85dedbSJason King },
3002d85dedbSJason King .kwargs = {
3012d85dedbSJason King { NULL, 0 }
3022d85dedbSJason King },
3032d85dedbSJason King };
3042d85dedbSJason King
3052d85dedbSJason King static int
zcp_synctask_inherit_prop_check(void * arg,dmu_tx_t * tx)3062d85dedbSJason King zcp_synctask_inherit_prop_check(void *arg, dmu_tx_t *tx)
3072d85dedbSJason King {
3082d85dedbSJason King zcp_inherit_prop_arg_t *args = arg;
3092d85dedbSJason King zfs_prop_t prop = zfs_name_to_prop(args->zipa_prop);
3102d85dedbSJason King
3112d85dedbSJason King if (prop == ZPROP_INVAL) {
3122d85dedbSJason King if (zfs_prop_user(args->zipa_prop))
3132d85dedbSJason King return (0);
3142d85dedbSJason King
3152d85dedbSJason King return (EINVAL);
3162d85dedbSJason King }
3172d85dedbSJason King
3182d85dedbSJason King if (zfs_prop_readonly(prop))
3192d85dedbSJason King return (EINVAL);
3202d85dedbSJason King
3212d85dedbSJason King if (!zfs_prop_inheritable(prop))
3222d85dedbSJason King return (EINVAL);
3232d85dedbSJason King
3242d85dedbSJason King return (dsl_props_set_check(&args->zipa_dpsa, tx));
3252d85dedbSJason King }
3262d85dedbSJason King
3272d85dedbSJason King static void
zcp_synctask_inherit_prop_sync(void * arg,dmu_tx_t * tx)3282d85dedbSJason King zcp_synctask_inherit_prop_sync(void *arg, dmu_tx_t *tx)
3292d85dedbSJason King {
3302d85dedbSJason King zcp_inherit_prop_arg_t *args = arg;
3312d85dedbSJason King dsl_props_set_arg_t *dpsa = &args->zipa_dpsa;
3322d85dedbSJason King
3332d85dedbSJason King dsl_props_set_sync(dpsa, tx);
3342d85dedbSJason King }
3352d85dedbSJason King
3362d85dedbSJason King static int
zcp_synctask_inherit_prop(lua_State * state,boolean_t sync,nvlist_t * err_details)3372d85dedbSJason King zcp_synctask_inherit_prop(lua_State *state, boolean_t sync,
3382d85dedbSJason King nvlist_t *err_details)
3392d85dedbSJason King {
3402d85dedbSJason King int err;
3412d85dedbSJason King zcp_inherit_prop_arg_t zipa = { 0 };
3422d85dedbSJason King dsl_props_set_arg_t *dpsa = &zipa.zipa_dpsa;
3432d85dedbSJason King
3442d85dedbSJason King const char *dsname = lua_tostring(state, 1);
3452d85dedbSJason King const char *prop = lua_tostring(state, 2);
3462d85dedbSJason King
3472d85dedbSJason King zipa.zipa_state = state;
3482d85dedbSJason King zipa.zipa_prop = prop;
3492d85dedbSJason King dpsa->dpsa_dsname = dsname;
3502d85dedbSJason King dpsa->dpsa_source = ZPROP_SRC_INHERITED;
3512d85dedbSJason King dpsa->dpsa_props = fnvlist_alloc();
3522d85dedbSJason King fnvlist_add_boolean(dpsa->dpsa_props, prop);
3532d85dedbSJason King
3542d85dedbSJason King zcp_cleanup_handler_t *zch = zcp_register_cleanup(state,
3552d85dedbSJason King (zcp_cleanup_t *)&fnvlist_free, dpsa->dpsa_props);
3562d85dedbSJason King
3572d85dedbSJason King err = zcp_sync_task(state, zcp_synctask_inherit_prop_check,
3582d85dedbSJason King zcp_synctask_inherit_prop_sync, &zipa, sync, dsname);
3592d85dedbSJason King
3602d85dedbSJason King zcp_deregister_cleanup(state, zch);
3612d85dedbSJason King fnvlist_free(dpsa->dpsa_props);
3622d85dedbSJason King
3632d85dedbSJason King return (err);
3642d85dedbSJason King }
3652d85dedbSJason King
366b2d2f356SSara Hartse static int zcp_synctask_set_prop(lua_State *, boolean_t, nvlist_t *err_details);
367b2d2f356SSara Hartse static zcp_synctask_info_t zcp_synctask_set_prop_info = {
368b2d2f356SSara Hartse .name = "set_prop",
369b2d2f356SSara Hartse .func = zcp_synctask_set_prop,
370b2d2f356SSara Hartse .space_check = ZFS_SPACE_CHECK_RESERVED,
371b2d2f356SSara Hartse .blocks_modified = 2,
372b2d2f356SSara Hartse .pargs = {
373b2d2f356SSara Hartse { .za_name = "dataset", .za_lua_type = LUA_TSTRING},
374b2d2f356SSara Hartse { .za_name = "property", .za_lua_type = LUA_TSTRING},
375b2d2f356SSara Hartse { .za_name = "value", .za_lua_type = LUA_TSTRING},
376b2d2f356SSara Hartse { NULL, 0 }
377b2d2f356SSara Hartse },
378b2d2f356SSara Hartse .kwargs = {
379b2d2f356SSara Hartse { NULL, 0 }
380b2d2f356SSara Hartse }
381b2d2f356SSara Hartse };
382b2d2f356SSara Hartse
383b2d2f356SSara Hartse static int
zcp_synctask_set_prop(lua_State * state,boolean_t sync,nvlist_t * err_details)384b2d2f356SSara Hartse zcp_synctask_set_prop(lua_State *state, boolean_t sync, nvlist_t *err_details)
385b2d2f356SSara Hartse {
386b2d2f356SSara Hartse int err;
387b2d2f356SSara Hartse zcp_set_prop_arg_t args = { 0 };
388b2d2f356SSara Hartse
389b2d2f356SSara Hartse const char *dsname = lua_tostring(state, 1);
390b2d2f356SSara Hartse const char *prop = lua_tostring(state, 2);
391b2d2f356SSara Hartse const char *val = lua_tostring(state, 3);
392b2d2f356SSara Hartse
393b2d2f356SSara Hartse args.state = state;
394b2d2f356SSara Hartse args.dsname = dsname;
395b2d2f356SSara Hartse args.prop = prop;
396b2d2f356SSara Hartse args.val = val;
397b2d2f356SSara Hartse
398b2d2f356SSara Hartse err = zcp_sync_task(state, zcp_set_prop_check, zcp_set_prop_sync,
399b2d2f356SSara Hartse &args, sync, dsname);
400b2d2f356SSara Hartse
401b2d2f356SSara Hartse return (err);
402b2d2f356SSara Hartse }
403b2d2f356SSara Hartse
404*d8f839f9SJason King static int zcp_synctask_change_key(lua_State *, boolean_t, nvlist_t *);
405*d8f839f9SJason King static zcp_synctask_info_t zcp_synctask_change_key_info = {
406*d8f839f9SJason King .name = "change_key",
407*d8f839f9SJason King .func = zcp_synctask_change_key,
408*d8f839f9SJason King .pargs = {
409*d8f839f9SJason King { .za_name = "dataset", .za_lua_type = LUA_TSTRING },
410*d8f839f9SJason King { .za_name = "key", .za_lua_type = LUA_TSTRING },
411*d8f839f9SJason King { .za_name = "format", .za_lua_type = LUA_TSTRING },
412*d8f839f9SJason King { NULL, 0 },
413*d8f839f9SJason King },
414*d8f839f9SJason King .kwargs = {
415*d8f839f9SJason King { NULL, 0 }
416*d8f839f9SJason King },
417*d8f839f9SJason King .space_check = ZFS_SPACE_CHECK_RESERVED,
418*d8f839f9SJason King /*
419*d8f839f9SJason King * This is the same value that is used when zfs change-key is run.
420*d8f839f9SJason King * See spa_keystore_change_key() in dsl_crypt.c
421*d8f839f9SJason King */
422*d8f839f9SJason King .blocks_modified = 15
423*d8f839f9SJason King };
424*d8f839f9SJason King
425*d8f839f9SJason King static int
zcp_synctask_change_key(lua_State * state,boolean_t sync,nvlist_t * err_details)426*d8f839f9SJason King zcp_synctask_change_key(lua_State *state, boolean_t sync, nvlist_t *err_details)
427*d8f839f9SJason King {
428*d8f839f9SJason King int err;
429*d8f839f9SJason King spa_keystore_change_key_args_t skcka = { 0 };
430*d8f839f9SJason King dsl_crypto_params_t *dcp = NULL;
431*d8f839f9SJason King const char *dsname;
432*d8f839f9SJason King const char *key;
433*d8f839f9SJason King const char *format;
434*d8f839f9SJason King size_t keylen;
435*d8f839f9SJason King uint64_t keyformat;
436*d8f839f9SJason King
437*d8f839f9SJason King dsname = lua_tostring(state, 1);
438*d8f839f9SJason King
439*d8f839f9SJason King /*
440*d8f839f9SJason King * The key may be raw key, which could contain NUL within it.
441*d8f839f9SJason King * Use lua_tolstring() instead of lua_tostring() to obtain the length.
442*d8f839f9SJason King */
443*d8f839f9SJason King key = lua_tolstring(state, 2, &keylen);
444*d8f839f9SJason King
445*d8f839f9SJason King format = lua_tostring(state, 3);
446*d8f839f9SJason King
447*d8f839f9SJason King if (zfs_prop_string_to_index(ZFS_PROP_KEYFORMAT, format,
448*d8f839f9SJason King &keyformat) != 0)
449*d8f839f9SJason King return (SET_ERROR(EINVAL));
450*d8f839f9SJason King
451*d8f839f9SJason King err = zcp_synctask_change_key_create_params(key, keylen, keyformat,
452*d8f839f9SJason King &dcp);
453*d8f839f9SJason King if (err != 0)
454*d8f839f9SJason King goto done;
455*d8f839f9SJason King
456*d8f839f9SJason King skcka.skcka_dsname = dsname;
457*d8f839f9SJason King skcka.skcka_cp = dcp;
458*d8f839f9SJason King
459*d8f839f9SJason King zcp_cleanup_handler_t *zch = zcp_register_cleanup(state,
460*d8f839f9SJason King (zcp_cleanup_t *)&zcp_synctask_change_key_cleanup, &skcka);
461*d8f839f9SJason King
462*d8f839f9SJason King err = zcp_sync_task(state, zcp_synctask_change_key_check,
463*d8f839f9SJason King zcp_synctask_change_key_sync, &skcka, sync, dsname);
464*d8f839f9SJason King
465*d8f839f9SJason King zcp_deregister_cleanup(state, zch);
466*d8f839f9SJason King
467*d8f839f9SJason King done:
468*d8f839f9SJason King dsl_crypto_params_free(dcp, (err != 0 || !sync) ? B_TRUE : B_FALSE);
469*d8f839f9SJason King return (err);
470*d8f839f9SJason King }
471*d8f839f9SJason King
472dfc11533SChris Williamson static int
zcp_synctask_wrapper(lua_State * state)473dfc11533SChris Williamson zcp_synctask_wrapper(lua_State *state)
474dfc11533SChris Williamson {
475dfc11533SChris Williamson int err;
476a3b28680SSerapheim Dimitropoulos zcp_cleanup_handler_t *zch;
477dfc11533SChris Williamson int num_ret = 1;
478dfc11533SChris Williamson nvlist_t *err_details = fnvlist_alloc();
479dfc11533SChris Williamson
480dfc11533SChris Williamson /*
481dfc11533SChris Williamson * Make sure err_details is properly freed, even if a fatal error is
482dfc11533SChris Williamson * thrown during the synctask.
483dfc11533SChris Williamson */
484a3b28680SSerapheim Dimitropoulos zch = zcp_register_cleanup(state,
485a3b28680SSerapheim Dimitropoulos (zcp_cleanup_t *)&fnvlist_free, err_details);
486dfc11533SChris Williamson
487dfc11533SChris Williamson zcp_synctask_info_t *info = lua_touserdata(state, lua_upvalueindex(1));
488dfc11533SChris Williamson boolean_t sync = lua_toboolean(state, lua_upvalueindex(2));
489dfc11533SChris Williamson
490dfc11533SChris Williamson zcp_run_info_t *ri = zcp_run_info(state);
491dfc11533SChris Williamson dsl_pool_t *dp = ri->zri_pool;
492dfc11533SChris Williamson
493dfc11533SChris Williamson /* MOS space is triple-dittoed, so we multiply by 3. */
494dfc11533SChris Williamson uint64_t funcspace = (info->blocks_modified << DST_AVG_BLKSHIFT) * 3;
495dfc11533SChris Williamson
496dfc11533SChris Williamson zcp_parse_args(state, info->name, info->pargs, info->kwargs);
497dfc11533SChris Williamson
498dfc11533SChris Williamson err = 0;
49986714001SSerapheim Dimitropoulos if (info->space_check != ZFS_SPACE_CHECK_NONE) {
50086714001SSerapheim Dimitropoulos uint64_t quota = dsl_pool_unreserved_space(dp,
50186714001SSerapheim Dimitropoulos info->space_check);
502dfc11533SChris Williamson uint64_t used = dsl_dir_phys(dp->dp_root_dir)->dd_used_bytes +
503dfc11533SChris Williamson ri->zri_space_used;
504dfc11533SChris Williamson
505dfc11533SChris Williamson if (used + funcspace > quota) {
506dfc11533SChris Williamson err = SET_ERROR(ENOSPC);
507dfc11533SChris Williamson }
508dfc11533SChris Williamson }
509dfc11533SChris Williamson
510dfc11533SChris Williamson if (err == 0) {
511dfc11533SChris Williamson err = info->func(state, sync, err_details);
512dfc11533SChris Williamson }
513dfc11533SChris Williamson
514dfc11533SChris Williamson if (err == 0) {
515dfc11533SChris Williamson ri->zri_space_used += funcspace;
516dfc11533SChris Williamson }
517dfc11533SChris Williamson
518dfc11533SChris Williamson lua_pushnumber(state, (lua_Number)err);
519dfc11533SChris Williamson if (fnvlist_num_pairs(err_details) > 0) {
520dfc11533SChris Williamson (void) zcp_nvlist_to_lua(state, err_details, NULL, 0);
521dfc11533SChris Williamson num_ret++;
522dfc11533SChris Williamson }
523dfc11533SChris Williamson
524a3b28680SSerapheim Dimitropoulos zcp_deregister_cleanup(state, zch);
525dfc11533SChris Williamson fnvlist_free(err_details);
526dfc11533SChris Williamson
527dfc11533SChris Williamson return (num_ret);
528dfc11533SChris Williamson }
529dfc11533SChris Williamson
530dfc11533SChris Williamson int
zcp_load_synctask_lib(lua_State * state,boolean_t sync)531dfc11533SChris Williamson zcp_load_synctask_lib(lua_State *state, boolean_t sync)
532dfc11533SChris Williamson {
533dfc11533SChris Williamson int i;
534dfc11533SChris Williamson zcp_synctask_info_t *zcp_synctask_funcs[] = {
535dfc11533SChris Williamson &zcp_synctask_destroy_info,
536dfc11533SChris Williamson &zcp_synctask_promote_info,
537000cce6bSBrad Lewis &zcp_synctask_rollback_info,
5382840dce1SChris Williamson &zcp_synctask_snapshot_info,
5392d85dedbSJason King &zcp_synctask_inherit_prop_info,
540b2d2f356SSara Hartse &zcp_synctask_set_prop_info,
541*d8f839f9SJason King &zcp_synctask_change_key_info,
542dfc11533SChris Williamson NULL
543dfc11533SChris Williamson };
544dfc11533SChris Williamson
545dfc11533SChris Williamson lua_newtable(state);
546dfc11533SChris Williamson
547dfc11533SChris Williamson for (i = 0; zcp_synctask_funcs[i] != NULL; i++) {
548dfc11533SChris Williamson zcp_synctask_info_t *info = zcp_synctask_funcs[i];
549dfc11533SChris Williamson lua_pushlightuserdata(state, info);
550dfc11533SChris Williamson lua_pushboolean(state, sync);
551dfc11533SChris Williamson lua_pushcclosure(state, &zcp_synctask_wrapper, 2);
552dfc11533SChris Williamson lua_setfield(state, -2, info->name);
553dfc11533SChris Williamson info++;
554dfc11533SChris Williamson }
555dfc11533SChris Williamson
556dfc11533SChris Williamson return (1);
557dfc11533SChris Williamson }
558