d99a015343
Authored by: Chris Williamson <chris.williamson@delphix.com> Reviewed by: Matthew Ahrens <mahrens@delphix.com> Reviewed by: George Wilson <george.wilson@delphix.com> Reviewed by: John Kennedy <john.kennedy@delphix.com> Reviewed by: Dan Kimmel <dan.kimmel@delphix.com> Approved by: Garrett D'Amore <garrett@damore.org> Ported-by: Don Brady <don.brady@delphix.com> Ported-by: John Kennedy <john.kennedy@delphix.com> OpenZFS-issue: https://www.illumos.org/issues/7431 OpenZFS-commit: https://github.com/openzfs/openzfs/commit/dfc11533 Porting Notes: * The CLI long option arguments for '-t' and '-m' don't parse on linux * Switched from kmem_alloc to vmem_alloc in zcp_lua_alloc * Lua implementation is built as its own module (zlua.ko) * Lua headers consumed directly by zfs code moved to 'include/sys/lua/' * There is no native setjmp/longjump available in stock Linux kernel. Brought over implementations from illumos and FreeBSD * The get_temporary_prop() was adapted due to VFS platform differences * Use of inline functions in lua parser to reduce stack usage per C call * Skip some ZFS Test Suite ZCP tests on sparc64 to avoid stack overflow
532 lines
13 KiB
C
532 lines
13 KiB
C
/*
|
|
* CDDL HEADER START
|
|
*
|
|
* This file and its contents are supplied under the terms of the
|
|
* Common Development and Distribution License ("CDDL"), version 1.0.
|
|
* You may only use this file in accordance with the terms of version
|
|
* 1.0 of the CDDL.
|
|
*
|
|
* A full copy of the text of the CDDL should have accompanied this
|
|
* source. A copy of the CDDL is also available via the Internet at
|
|
* http://www.illumos.org/license/CDDL.
|
|
*
|
|
* CDDL HEADER END
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2016 by Delphix. All rights reserved.
|
|
*/
|
|
|
|
#include <sys/lua/lua.h>
|
|
#include <sys/lua/lauxlib.h>
|
|
|
|
#include <sys/dmu.h>
|
|
#include <sys/dsl_prop.h>
|
|
#include <sys/dsl_synctask.h>
|
|
#include <sys/dsl_dataset.h>
|
|
#include <sys/dsl_pool.h>
|
|
#include <sys/dmu_tx.h>
|
|
#include <sys/dmu_objset.h>
|
|
#include <sys/zap.h>
|
|
#include <sys/dsl_dir.h>
|
|
#include <sys/zcp_prop.h>
|
|
|
|
#include <sys/zcp.h>
|
|
|
|
typedef int (zcp_list_func_t)(lua_State *);
|
|
typedef struct zcp_list_info {
|
|
const char *name;
|
|
zcp_list_func_t *func;
|
|
zcp_list_func_t *gc;
|
|
const zcp_arg_t pargs[4];
|
|
const zcp_arg_t kwargs[2];
|
|
} zcp_list_info_t;
|
|
|
|
static int
|
|
zcp_clones_iter(lua_State *state)
|
|
{
|
|
int err;
|
|
char clonename[ZFS_MAX_DATASET_NAME_LEN];
|
|
uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1));
|
|
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
dsl_dataset_t *ds, *clone;
|
|
zap_attribute_t za;
|
|
zap_cursor_t zc;
|
|
|
|
err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
|
|
if (err == ENOENT) {
|
|
return (0);
|
|
} else if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from dsl_dataset_hold_obj(dsobj)",
|
|
err));
|
|
}
|
|
|
|
if (dsl_dataset_phys(ds)->ds_next_clones_obj == 0) {
|
|
dsl_dataset_rele(ds, FTAG);
|
|
return (0);
|
|
}
|
|
|
|
zap_cursor_init_serialized(&zc, dp->dp_meta_objset,
|
|
dsl_dataset_phys(ds)->ds_next_clones_obj, cursor);
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
err = zap_cursor_retrieve(&zc, &za);
|
|
if (err != 0) {
|
|
zap_cursor_fini(&zc);
|
|
if (err != ENOENT) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from zap_cursor_retrieve()",
|
|
err));
|
|
}
|
|
return (0);
|
|
}
|
|
zap_cursor_advance(&zc);
|
|
cursor = zap_cursor_serialize(&zc);
|
|
zap_cursor_fini(&zc);
|
|
|
|
err = dsl_dataset_hold_obj(dp, za.za_first_integer, FTAG, &clone);
|
|
if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from "
|
|
"dsl_dataset_hold_obj(za_first_integer)", err));
|
|
}
|
|
|
|
dsl_dir_name(clone->ds_dir, clonename);
|
|
dsl_dataset_rele(clone, FTAG);
|
|
|
|
lua_pushnumber(state, cursor);
|
|
lua_replace(state, lua_upvalueindex(2));
|
|
|
|
(void) lua_pushstring(state, clonename);
|
|
return (1);
|
|
}
|
|
|
|
static int zcp_clones_list(lua_State *);
|
|
static zcp_list_info_t zcp_clones_list_info = {
|
|
.name = "clones",
|
|
.func = zcp_clones_list,
|
|
.gc = NULL,
|
|
.pargs = {
|
|
{ .za_name = "snapshot", .za_lua_type = LUA_TSTRING},
|
|
{NULL, 0}
|
|
},
|
|
.kwargs = {
|
|
{NULL, 0}
|
|
}
|
|
};
|
|
|
|
static int
|
|
zcp_clones_list(lua_State *state)
|
|
{
|
|
const char *snapname = lua_tostring(state, 1);
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
boolean_t issnap;
|
|
uint64_t dsobj, cursor;
|
|
|
|
/*
|
|
* zcp_dataset_hold will either successfully return the requested
|
|
* dataset or throw a lua error and longjmp out of the zfs.list.clones
|
|
* call without returning.
|
|
*/
|
|
dsl_dataset_t *ds = zcp_dataset_hold(state, dp, snapname, FTAG);
|
|
if (ds == NULL)
|
|
return (1); /* not reached; zcp_dataset_hold() longjmp'd */
|
|
cursor = 0;
|
|
issnap = ds->ds_is_snapshot;
|
|
dsobj = ds->ds_object;
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
if (!issnap) {
|
|
return (zcp_argerror(state, 1, "%s is not a snapshot",
|
|
snapname));
|
|
}
|
|
|
|
lua_pushnumber(state, dsobj);
|
|
lua_pushnumber(state, cursor);
|
|
lua_pushcclosure(state, &zcp_clones_iter, 2);
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
zcp_snapshots_iter(lua_State *state)
|
|
{
|
|
int err;
|
|
char snapname[ZFS_MAX_DATASET_NAME_LEN];
|
|
uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1));
|
|
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
dsl_dataset_t *ds;
|
|
objset_t *os;
|
|
char *p;
|
|
|
|
err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
|
|
if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from dsl_dataset_hold_obj(dsobj)",
|
|
err));
|
|
}
|
|
|
|
dsl_dataset_name(ds, snapname);
|
|
VERIFY3U(sizeof (snapname), >,
|
|
strlcat(snapname, "@", sizeof (snapname)));
|
|
|
|
p = strchr(snapname, '\0');
|
|
VERIFY0(dmu_objset_from_ds(ds, &os));
|
|
err = dmu_snapshot_list_next(os,
|
|
sizeof (snapname) - (p - snapname), p, NULL, &cursor, NULL);
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
if (err == ENOENT) {
|
|
return (0);
|
|
} else if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from dmu_snapshot_list_next()", err));
|
|
}
|
|
|
|
lua_pushnumber(state, cursor);
|
|
lua_replace(state, lua_upvalueindex(2));
|
|
|
|
(void) lua_pushstring(state, snapname);
|
|
return (1);
|
|
}
|
|
|
|
static int zcp_snapshots_list(lua_State *);
|
|
static zcp_list_info_t zcp_snapshots_list_info = {
|
|
.name = "snapshots",
|
|
.func = zcp_snapshots_list,
|
|
.gc = NULL,
|
|
.pargs = {
|
|
{ .za_name = "filesystem | volume", .za_lua_type = LUA_TSTRING},
|
|
{NULL, 0}
|
|
},
|
|
.kwargs = {
|
|
{NULL, 0}
|
|
}
|
|
};
|
|
|
|
static int
|
|
zcp_snapshots_list(lua_State *state)
|
|
{
|
|
const char *fsname = lua_tostring(state, 1);
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
boolean_t issnap;
|
|
uint64_t dsobj;
|
|
|
|
dsl_dataset_t *ds = zcp_dataset_hold(state, dp, fsname, FTAG);
|
|
if (ds == NULL)
|
|
return (1); /* not reached; zcp_dataset_hold() longjmp'd */
|
|
issnap = ds->ds_is_snapshot;
|
|
dsobj = ds->ds_object;
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
if (issnap) {
|
|
return (zcp_argerror(state, 1,
|
|
"argument %s cannot be a snapshot", fsname));
|
|
}
|
|
|
|
lua_pushnumber(state, dsobj);
|
|
lua_pushnumber(state, 0);
|
|
lua_pushcclosure(state, &zcp_snapshots_iter, 2);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Note: channel programs only run in the global zone, so all datasets
|
|
* are visible to this zone.
|
|
*/
|
|
static boolean_t
|
|
dataset_name_hidden(const char *name)
|
|
{
|
|
if (strchr(name, '$') != NULL)
|
|
return (B_TRUE);
|
|
if (strchr(name, '%') != NULL)
|
|
return (B_TRUE);
|
|
return (B_FALSE);
|
|
}
|
|
|
|
static int
|
|
zcp_children_iter(lua_State *state)
|
|
{
|
|
int err;
|
|
char childname[ZFS_MAX_DATASET_NAME_LEN];
|
|
uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1));
|
|
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
|
|
zcp_run_info_t *ri = zcp_run_info(state);
|
|
dsl_pool_t *dp = ri->zri_pool;
|
|
dsl_dataset_t *ds;
|
|
objset_t *os;
|
|
char *p;
|
|
|
|
err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
|
|
if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from dsl_dataset_hold_obj(dsobj)",
|
|
err));
|
|
}
|
|
|
|
dsl_dataset_name(ds, childname);
|
|
VERIFY3U(sizeof (childname), >,
|
|
strlcat(childname, "/", sizeof (childname)));
|
|
p = strchr(childname, '\0');
|
|
|
|
VERIFY0(dmu_objset_from_ds(ds, &os));
|
|
do {
|
|
err = dmu_dir_list_next(os,
|
|
sizeof (childname) - (p - childname), p, NULL, &cursor);
|
|
} while (err == 0 && dataset_name_hidden(childname));
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
if (err == ENOENT) {
|
|
return (0);
|
|
} else if (err != 0) {
|
|
return (luaL_error(state,
|
|
"unexpected error %d from dmu_dir_list_next()",
|
|
err));
|
|
}
|
|
|
|
lua_pushnumber(state, cursor);
|
|
lua_replace(state, lua_upvalueindex(2));
|
|
|
|
(void) lua_pushstring(state, childname);
|
|
return (1);
|
|
}
|
|
|
|
static int zcp_children_list(lua_State *);
|
|
static zcp_list_info_t zcp_children_list_info = {
|
|
.name = "children",
|
|
.func = zcp_children_list,
|
|
.gc = NULL,
|
|
.pargs = {
|
|
{ .za_name = "filesystem | volume", .za_lua_type = LUA_TSTRING},
|
|
{NULL, 0}
|
|
},
|
|
.kwargs = {
|
|
{NULL, 0}
|
|
}
|
|
};
|
|
|
|
static int
|
|
zcp_children_list(lua_State *state)
|
|
{
|
|
const char *fsname = lua_tostring(state, 1);
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
boolean_t issnap;
|
|
uint64_t dsobj;
|
|
|
|
dsl_dataset_t *ds = zcp_dataset_hold(state, dp, fsname, FTAG);
|
|
if (ds == NULL)
|
|
return (1); /* not reached; zcp_dataset_hold() longjmp'd */
|
|
|
|
issnap = ds->ds_is_snapshot;
|
|
dsobj = ds->ds_object;
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
if (issnap) {
|
|
return (zcp_argerror(state, 1,
|
|
"argument %s cannot be a snapshot", fsname));
|
|
}
|
|
|
|
lua_pushnumber(state, dsobj);
|
|
lua_pushnumber(state, 0);
|
|
lua_pushcclosure(state, &zcp_children_iter, 2);
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
zcp_props_list_gc(lua_State *state)
|
|
{
|
|
nvlist_t **props = lua_touserdata(state, 1);
|
|
if (*props != NULL)
|
|
fnvlist_free(*props);
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
zcp_props_iter(lua_State *state)
|
|
{
|
|
char *source, *val;
|
|
nvlist_t *nvprop;
|
|
nvlist_t **props = lua_touserdata(state, lua_upvalueindex(1));
|
|
nvpair_t *pair = lua_touserdata(state, lua_upvalueindex(2));
|
|
|
|
do {
|
|
pair = nvlist_next_nvpair(*props, pair);
|
|
if (pair == NULL) {
|
|
fnvlist_free(*props);
|
|
*props = NULL;
|
|
return (0);
|
|
}
|
|
} while (!zfs_prop_user(nvpair_name(pair)));
|
|
|
|
lua_pushlightuserdata(state, pair);
|
|
lua_replace(state, lua_upvalueindex(2));
|
|
|
|
nvprop = fnvpair_value_nvlist(pair);
|
|
val = fnvlist_lookup_string(nvprop, ZPROP_VALUE);
|
|
source = fnvlist_lookup_string(nvprop, ZPROP_SOURCE);
|
|
|
|
(void) lua_pushstring(state, nvpair_name(pair));
|
|
(void) lua_pushstring(state, val);
|
|
(void) lua_pushstring(state, source);
|
|
return (3);
|
|
}
|
|
|
|
static int zcp_props_list(lua_State *);
|
|
static zcp_list_info_t zcp_props_list_info = {
|
|
.name = "properties",
|
|
.func = zcp_props_list,
|
|
.gc = zcp_props_list_gc,
|
|
.pargs = {
|
|
{ .za_name = "filesystem | snapshot | volume",
|
|
.za_lua_type = LUA_TSTRING},
|
|
{NULL, 0}
|
|
},
|
|
.kwargs = {
|
|
{NULL, 0}
|
|
}
|
|
};
|
|
|
|
static int
|
|
zcp_props_list(lua_State *state)
|
|
{
|
|
const char *dsname = lua_tostring(state, 1);
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
objset_t *os;
|
|
nvlist_t **props = lua_newuserdata(state, sizeof (nvlist_t *));
|
|
|
|
dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dsname, FTAG);
|
|
if (ds == NULL)
|
|
return (1); /* not reached; zcp_dataset_hold() longjmp'd */
|
|
VERIFY0(dmu_objset_from_ds(ds, &os));
|
|
VERIFY0(dsl_prop_get_all(os, props));
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
/*
|
|
* Set the metatable for the properties list to free it on completion.
|
|
*/
|
|
luaL_getmetatable(state, zcp_props_list_info.name);
|
|
(void) lua_setmetatable(state, -2);
|
|
|
|
lua_pushlightuserdata(state, NULL);
|
|
lua_pushcclosure(state, &zcp_props_iter, 2);
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* Populate nv with all valid properties and their values for the given
|
|
* dataset.
|
|
*/
|
|
static void
|
|
zcp_dataset_props(dsl_dataset_t *ds, nvlist_t *nv)
|
|
{
|
|
for (int prop = ZFS_PROP_TYPE; prop < ZFS_NUM_PROPS; prop++) {
|
|
/* Do not display hidden props */
|
|
if (!zfs_prop_visible(prop))
|
|
continue;
|
|
/* Do not display props not valid for this dataset */
|
|
if (!prop_valid_for_ds(ds, prop))
|
|
continue;
|
|
fnvlist_add_boolean(nv, zfs_prop_to_name(prop));
|
|
}
|
|
}
|
|
|
|
static int zcp_system_props_list(lua_State *);
|
|
static zcp_list_info_t zcp_system_props_list_info = {
|
|
.name = "system_properties",
|
|
.func = zcp_system_props_list,
|
|
.pargs = {
|
|
{ .za_name = "dataset", .za_lua_type = LUA_TSTRING},
|
|
{NULL, 0}
|
|
},
|
|
.kwargs = {
|
|
{NULL, 0}
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Get a list of all visble properties and their values for a given dataset.
|
|
* Returned on the stack as a Lua table.
|
|
*/
|
|
static int
|
|
zcp_system_props_list(lua_State *state)
|
|
{
|
|
int error;
|
|
char errbuf[128];
|
|
const char *dataset_name;
|
|
dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
|
|
zcp_list_info_t *libinfo = &zcp_system_props_list_info;
|
|
zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs);
|
|
dataset_name = lua_tostring(state, 1);
|
|
nvlist_t *nv = fnvlist_alloc();
|
|
|
|
dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dataset_name, FTAG);
|
|
if (ds == NULL)
|
|
return (1); /* not reached; zcp_dataset_hold() longjmp'd */
|
|
|
|
/* Get the names of all valid properties for this dataset */
|
|
zcp_dataset_props(ds, nv);
|
|
dsl_dataset_rele(ds, FTAG);
|
|
|
|
/* push list as lua table */
|
|
error = zcp_nvlist_to_lua(state, nv, errbuf, sizeof (errbuf));
|
|
nvlist_free(nv);
|
|
if (error != 0) {
|
|
return (luaL_error(state,
|
|
"Error returning nvlist: %s", errbuf));
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
zcp_list_func(lua_State *state)
|
|
{
|
|
zcp_list_info_t *info = lua_touserdata(state, lua_upvalueindex(1));
|
|
|
|
zcp_parse_args(state, info->name, info->pargs, info->kwargs);
|
|
|
|
return (info->func(state));
|
|
}
|
|
|
|
int
|
|
zcp_load_list_lib(lua_State *state)
|
|
{
|
|
int i;
|
|
zcp_list_info_t *zcp_list_funcs[] = {
|
|
&zcp_children_list_info,
|
|
&zcp_snapshots_list_info,
|
|
&zcp_props_list_info,
|
|
&zcp_clones_list_info,
|
|
&zcp_system_props_list_info,
|
|
NULL
|
|
};
|
|
|
|
lua_newtable(state);
|
|
|
|
for (i = 0; zcp_list_funcs[i] != NULL; i++) {
|
|
zcp_list_info_t *info = zcp_list_funcs[i];
|
|
|
|
if (info->gc != NULL) {
|
|
/*
|
|
* If the function requires garbage collection, create
|
|
* a metatable with its name and register the __gc
|
|
* function.
|
|
*/
|
|
(void) luaL_newmetatable(state, info->name);
|
|
(void) lua_pushstring(state, "__gc");
|
|
lua_pushcfunction(state, info->gc);
|
|
lua_settable(state, -3);
|
|
lua_pop(state, 1);
|
|
}
|
|
|
|
lua_pushlightuserdata(state, info);
|
|
lua_pushcclosure(state, &zcp_list_func, 1);
|
|
lua_setfield(state, -2, info->name);
|
|
info++;
|
|
}
|
|
|
|
return (1);
|
|
}
|