sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zcp_synctask.c

   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, 0}
  99         },
 100         .kwargs = {
 101             {.za_name = "defer", .za_lua_type = LUA_TBOOLEAN},
 102             {NULL, 0}
 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, 0}
 152         },
 153         .kwargs = {
 154             {NULL, 0}
 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 }