2018-02-08 16:16:23 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2018-06-15 22:10:42 +00:00
|
|
|
* Copyright (c) 2016, 2018 by Delphix. All rights reserved.
|
2018-02-08 16:16:23 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _SYS_ZCP_H
|
|
|
|
#define _SYS_ZCP_H
|
|
|
|
|
|
|
|
#include <sys/dmu_tx.h>
|
|
|
|
#include <sys/dsl_pool.h>
|
|
|
|
|
|
|
|
#include <sys/lua/lua.h>
|
|
|
|
#include <sys/lua/lualib.h>
|
|
|
|
#include <sys/lua/lauxlib.h>
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define ZCP_RUN_INFO_KEY "runinfo"
|
|
|
|
|
2018-06-15 22:10:42 +00:00
|
|
|
extern unsigned long zfs_lua_max_instrlimit;
|
|
|
|
extern unsigned long zfs_lua_max_memlimit;
|
2018-02-08 16:16:23 +00:00
|
|
|
|
|
|
|
int zcp_argerror(lua_State *, int, const char *, ...);
|
|
|
|
|
2018-02-08 16:35:09 +00:00
|
|
|
int zcp_eval(const char *, const char *, boolean_t, uint64_t, uint64_t,
|
|
|
|
nvpair_t *, nvlist_t *);
|
2018-02-08 16:16:23 +00:00
|
|
|
|
|
|
|
int zcp_load_list_lib(lua_State *);
|
|
|
|
|
|
|
|
int zcp_load_synctask_lib(lua_State *, boolean_t);
|
|
|
|
|
|
|
|
typedef void (zcp_cleanup_t)(void *);
|
2018-02-08 16:35:09 +00:00
|
|
|
typedef struct zcp_cleanup_handler {
|
|
|
|
zcp_cleanup_t *zch_cleanup_func;
|
|
|
|
void *zch_cleanup_arg;
|
|
|
|
list_node_t zch_node;
|
|
|
|
} zcp_cleanup_handler_t;
|
2018-02-08 16:16:23 +00:00
|
|
|
|
2019-06-22 23:51:46 +00:00
|
|
|
typedef struct zcp_alloc_arg {
|
|
|
|
boolean_t aa_must_succeed;
|
|
|
|
int64_t aa_alloc_remaining;
|
|
|
|
int64_t aa_alloc_limit;
|
|
|
|
} zcp_alloc_arg_t;
|
|
|
|
|
2018-02-08 16:16:23 +00:00
|
|
|
typedef struct zcp_run_info {
|
|
|
|
dsl_pool_t *zri_pool;
|
|
|
|
|
|
|
|
/*
|
2018-02-08 16:35:09 +00:00
|
|
|
* An estimate of the total amount of space consumed by all
|
2018-02-08 16:16:23 +00:00
|
|
|
* synctasks we have successfully performed so far in this
|
|
|
|
* channel program. Used to generate ENOSPC errors for syncfuncs.
|
|
|
|
*/
|
|
|
|
int zri_space_used;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The credentials of the thread which originally invoked the channel
|
|
|
|
* program. Since channel programs are always invoked from the synctask
|
|
|
|
* thread they should always do permissions checks against this cred
|
|
|
|
* rather than the 'current' thread's.
|
|
|
|
*/
|
|
|
|
cred_t *zri_cred;
|
2020-07-12 00:18:02 +00:00
|
|
|
proc_t *zri_proc;
|
2018-02-08 16:16:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The tx in which this channel program is running.
|
|
|
|
*/
|
|
|
|
dmu_tx_t *zri_tx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The maximum number of Lua instructions the channel program is allowed
|
|
|
|
* to execute. If it takes longer than this it will time out. A value
|
|
|
|
* of 0 indicates no instruction limit.
|
|
|
|
*/
|
|
|
|
uint64_t zri_maxinstrs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of Lua instructions the channel program has executed.
|
|
|
|
*/
|
|
|
|
uint64_t zri_curinstrs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Boolean indicating whether or not the channel program exited
|
|
|
|
* because it timed out.
|
|
|
|
*/
|
|
|
|
boolean_t zri_timed_out;
|
|
|
|
|
2019-06-22 23:51:46 +00:00
|
|
|
/*
|
|
|
|
* Channel program was canceled by user
|
|
|
|
*/
|
|
|
|
boolean_t zri_canceled;
|
|
|
|
|
2018-02-08 16:16:23 +00:00
|
|
|
/*
|
2018-02-08 16:35:09 +00:00
|
|
|
* Boolean indicating whether or not we are running in syncing
|
|
|
|
* context.
|
2018-02-08 16:16:23 +00:00
|
|
|
*/
|
2018-02-08 16:35:09 +00:00
|
|
|
boolean_t zri_sync;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* List of currently registered cleanup handlers, which will be
|
|
|
|
* triggered in the event of a fatal error.
|
|
|
|
*/
|
|
|
|
list_t zri_cleanup_handlers;
|
2019-06-22 23:51:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The Lua state context of our channel program.
|
|
|
|
*/
|
|
|
|
lua_State *zri_state;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lua memory allocator arguments.
|
|
|
|
*/
|
|
|
|
zcp_alloc_arg_t *zri_allocargs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Contains output values from zcp script or error string.
|
|
|
|
*/
|
|
|
|
nvlist_t *zri_outnvl;
|
|
|
|
|
async zvol minor node creation interferes with receive
When we finish a zfs receive, dmu_recv_end_sync() calls
zvol_create_minors(async=TRUE). This kicks off some other threads that
create the minor device nodes (in /dev/zvol/poolname/...). These async
threads call zvol_prefetch_minors_impl() and zvol_create_minor(), which
both call dmu_objset_own(), which puts a "long hold" on the dataset.
Since the zvol minor node creation is asynchronous, this can happen
after the `ZFS_IOC_RECV[_NEW]` ioctl and `zfs receive` process have
completed.
After the first receive ioctl has completed, userland may attempt to do
another receive into the same dataset (e.g. the next incremental
stream). This second receive and the asynchronous minor node creation
can interfere with one another in several different ways, because they
both require exclusive access to the dataset:
1. When the second receive is finishing up, dmu_recv_end_check() does
dsl_dataset_handoff_check(), which can fail with EBUSY if the async
minor node creation already has a "long hold" on this dataset. This
causes the 2nd receive to fail.
2. The async udev rule can fail if zvol_id and/or systemd-udevd try to
open the device while the the second receive's async attempt at minor
node creation owns the dataset (via zvol_prefetch_minors_impl). This
causes the minor node (/dev/zd*) to exist, but the udev-generated
/dev/zvol/... to not exist.
3. The async minor node creation can silently fail with EBUSY if the
first receive's zvol_create_minor() trys to own the dataset while the
second receive's zvol_prefetch_minors_impl already owns the dataset.
To address these problems, this change synchronously creates the minor
node. To avoid the lock ordering problems that the asynchrony was
introduced to fix (see #3681), we create the minor nodes from open
context, with no locks held, rather than from syncing contex as was
originally done.
Implementation notes:
We generally do not need to traverse children or prefetch anything (e.g.
when running the recv, snapshot, create, or clone subcommands of zfs).
We only need recursion when importing/opening a pool and when loading
encryption keys. The existing recursive, asynchronous, prefetching code
is preserved for use in these cases.
Channel programs may need to create zvol minor nodes, when creating a
snapshot of a zvol with the snapdev property set. We figure out what
snapshots are created when running the LUA program in syncing context.
In this case we need to remember what snapshots were created, and then
try to create their minor nodes from open context, after the LUA code
has completed.
There are additional zvol use cases that asynchronously own the dataset,
which can cause similar problems. E.g. changing the volmode or snapdev
properties. These are less problematic because they are not recursive
and don't touch datasets that are not involved in the operation, there
is still potential for interference with subsequent operations. In the
future, these cases should be similarly converted to create the zvol
minor node synchronously from open context.
The async tasks of removing and renaming minors do not own the objset,
so they do not have this problem. However, it may make sense to also
convert these operations to happen synchronously from open context, in
the future.
Reviewed-by: Paul Dagnelie <pcd@delphix.com>
Reviewed-by: Prakash Surya <prakash.surya@delphix.com>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Matthew Ahrens <mahrens@delphix.com>
External-issue: DLPX-65948
Closes #7863
Closes #9885
2020-02-03 17:33:14 +00:00
|
|
|
/*
|
|
|
|
* The keys of this nvlist are datasets which may be zvols and may need
|
|
|
|
* to have device minor nodes created. This information is passed from
|
|
|
|
* syncing context (where the zvol is created) to open context (where we
|
|
|
|
* create the minor nodes).
|
|
|
|
*/
|
|
|
|
nvlist_t *zri_new_zvols;
|
|
|
|
|
2019-06-22 23:51:46 +00:00
|
|
|
/*
|
|
|
|
* The errno number returned to caller of zcp_eval().
|
|
|
|
*/
|
|
|
|
int zri_result;
|
2018-02-08 16:16:23 +00:00
|
|
|
} zcp_run_info_t;
|
|
|
|
|
|
|
|
zcp_run_info_t *zcp_run_info(lua_State *);
|
2018-02-08 16:35:09 +00:00
|
|
|
zcp_cleanup_handler_t *zcp_register_cleanup(lua_State *, zcp_cleanup_t, void *);
|
|
|
|
void zcp_deregister_cleanup(lua_State *, zcp_cleanup_handler_t *);
|
2018-02-08 16:16:23 +00:00
|
|
|
void zcp_cleanup(lua_State *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Argument parsing routines for channel program callback functions.
|
|
|
|
*/
|
|
|
|
typedef struct zcp_arg {
|
|
|
|
/*
|
|
|
|
* The name of this argument. For keyword arguments this is the name
|
|
|
|
* functions will use to set the argument. For positional arguments
|
2019-08-30 16:53:15 +00:00
|
|
|
* the name has no programmatic meaning, but will appear in error
|
2018-02-08 16:16:23 +00:00
|
|
|
* messages and help output.
|
|
|
|
*/
|
|
|
|
const char *za_name;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The Lua type this argument should have (e.g. LUA_TSTRING,
|
|
|
|
* LUA_TBOOLEAN) see the lua_type() function documentation for a
|
|
|
|
* complete list. Calling a function with an argument that does
|
|
|
|
* not match the expected type will result in the program terminating.
|
|
|
|
*/
|
|
|
|
const int za_lua_type;
|
|
|
|
} zcp_arg_t;
|
|
|
|
|
|
|
|
void zcp_parse_args(lua_State *, const char *, const zcp_arg_t *,
|
|
|
|
const zcp_arg_t *);
|
|
|
|
int zcp_nvlist_to_lua(lua_State *, nvlist_t *, char *, int);
|
|
|
|
int zcp_dataset_hold_error(lua_State *, dsl_pool_t *, const char *, int);
|
|
|
|
struct dsl_dataset *zcp_dataset_hold(lua_State *, dsl_pool_t *,
|
|
|
|
const char *, void *);
|
|
|
|
|
|
|
|
typedef int (zcp_lib_func_t)(lua_State *);
|
|
|
|
typedef struct zcp_lib_info {
|
|
|
|
const char *name;
|
|
|
|
zcp_lib_func_t *func;
|
|
|
|
const zcp_arg_t pargs[4];
|
|
|
|
const zcp_arg_t kwargs[2];
|
|
|
|
} zcp_lib_info_t;
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* _SYS_ZCP_H */
|