]>
Commit | Line | Data |
---|---|---|
d99a0153 CW |
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 | /* | |
917f475f | 17 | * Copyright (c) 2016, 2018 by Delphix. All rights reserved. |
d99a0153 CW |
18 | */ |
19 | ||
20 | /* | |
21 | * ZFS Channel Programs (ZCP) | |
22 | * | |
23 | * The ZCP interface allows various ZFS commands and operations ZFS | |
24 | * administrative operations (e.g. creating and destroying snapshots, typically | |
25 | * performed via an ioctl to /dev/zfs by the zfs(8) command and | |
26 | * libzfs/libzfs_core) to be run * programmatically as a Lua script. A ZCP | |
27 | * script is run as a dsl_sync_task and fully executed during one transaction | |
28 | * group sync. This ensures that no other changes can be written concurrently | |
29 | * with a running Lua script. Combining multiple calls to the exposed ZFS | |
30 | * functions into one script gives a number of benefits: | |
31 | * | |
32 | * 1. Atomicity. For some compound or iterative operations, it's useful to be | |
33 | * able to guarantee that the state of a pool has not changed between calls to | |
34 | * ZFS. | |
35 | * | |
36 | * 2. Performance. If a large number of changes need to be made (e.g. deleting | |
37 | * many filesystems), there can be a significant performance penalty as a | |
38 | * result of the need to wait for a transaction group sync to pass for every | |
39 | * single operation. When expressed as a single ZCP script, all these changes | |
40 | * can be performed at once in one txg sync. | |
41 | * | |
42 | * A modified version of the Lua 5.2 interpreter is used to run channel program | |
43 | * scripts. The Lua 5.2 manual can be found at: | |
44 | * | |
45 | * http://www.lua.org/manual/5.2/ | |
46 | * | |
47 | * If being run by a user (via an ioctl syscall), executing a ZCP script | |
48 | * requires root privileges in the global zone. | |
49 | * | |
50 | * Scripts are passed to zcp_eval() as a string, then run in a synctask by | |
51 | * zcp_eval_sync(). Arguments can be passed into the Lua script as an nvlist, | |
52 | * which will be converted to a Lua table. Similarly, values returned from | |
53 | * a ZCP script will be converted to an nvlist. See zcp_lua_to_nvlist_impl() | |
54 | * for details on exact allowed types and conversion. | |
55 | * | |
56 | * ZFS functionality is exposed to a ZCP script as a library of function calls. | |
57 | * These calls are sorted into submodules, such as zfs.list and zfs.sync, for | |
58 | * iterators and synctasks, respectively. Each of these submodules resides in | |
59 | * its own source file, with a zcp_*_info structure describing each library | |
60 | * call in the submodule. | |
61 | * | |
62 | * Error handling in ZCP scripts is handled by a number of different methods | |
63 | * based on severity: | |
64 | * | |
65 | * 1. Memory and time limits are in place to prevent a channel program from | |
66 | * consuming excessive system or running forever. If one of these limits is | |
67 | * hit, the channel program will be stopped immediately and return from | |
68 | * zcp_eval() with an error code. No attempt will be made to roll back or undo | |
e1cfd73f | 69 | * any changes made by the channel program before the error occurred. |
d99a0153 CW |
70 | * Consumers invoking zcp_eval() from elsewhere in the kernel may pass a time |
71 | * limit of 0, disabling the time limit. | |
72 | * | |
73 | * 2. Internal Lua errors can occur as a result of a syntax error, calling a | |
74 | * library function with incorrect arguments, invoking the error() function, | |
75 | * failing an assert(), or other runtime errors. In these cases the channel | |
76 | * program will stop executing and return from zcp_eval() with an error code. | |
77 | * In place of a return value, an error message will also be returned in the | |
78 | * 'result' nvlist containing information about the error. No attempt will be | |
79 | * made to roll back or undo any changes made by the channel program before the | |
e1cfd73f | 80 | * error occurred. |
d99a0153 CW |
81 | * |
82 | * 3. If an error occurs inside a ZFS library call which returns an error code, | |
83 | * the error is returned to the Lua script to be handled as desired. | |
84 | * | |
85 | * In the first two cases, Lua's error-throwing mechanism is used, which | |
86 | * longjumps out of the script execution with luaL_error() and returns with the | |
87 | * error. | |
88 | * | |
89 | * See zfs-program(8) for more information on high level usage. | |
90 | */ | |
91 | ||
92 | #include <sys/lua/lua.h> | |
93 | #include <sys/lua/lualib.h> | |
94 | #include <sys/lua/lauxlib.h> | |
95 | ||
96 | #include <sys/dsl_prop.h> | |
97 | #include <sys/dsl_synctask.h> | |
98 | #include <sys/dsl_dataset.h> | |
99 | #include <sys/zcp.h> | |
100 | #include <sys/zcp_iter.h> | |
101 | #include <sys/zcp_prop.h> | |
102 | #include <sys/zcp_global.h> | |
ec213971 | 103 | #include <sys/zvol.h> |
d99a0153 CW |
104 | |
105 | #ifndef KM_NORMALPRI | |
106 | #define KM_NORMALPRI 0 | |
107 | #endif | |
108 | ||
234c91c5 CW |
109 | #define ZCP_NVLIST_MAX_DEPTH 20 |
110 | ||
18168da7 | 111 | static const uint64_t zfs_lua_check_instrlimit_interval = 100; |
917f475f JG |
112 | unsigned long zfs_lua_max_instrlimit = ZCP_MAX_INSTRLIMIT; |
113 | unsigned long zfs_lua_max_memlimit = ZCP_MAX_MEMLIMIT; | |
d99a0153 | 114 | |
234c91c5 CW |
115 | /* |
116 | * Forward declarations for mutually recursive functions | |
117 | */ | |
d99a0153 CW |
118 | static int zcp_nvpair_value_to_lua(lua_State *, nvpair_t *, char *, int); |
119 | static int zcp_lua_to_nvlist_impl(lua_State *, int, nvlist_t *, const char *, | |
120 | int); | |
121 | ||
d99a0153 CW |
122 | /* |
123 | * The outer-most error callback handler for use with lua_pcall(). On | |
124 | * error Lua will call this callback with a single argument that | |
125 | * represents the error value. In most cases this will be a string | |
126 | * containing an error message, but channel programs can use Lua's | |
127 | * error() function to return arbitrary objects as errors. This callback | |
128 | * returns (on the Lua stack) the original error object along with a traceback. | |
129 | * | |
130 | * Fatal Lua errors can occur while resources are held, so we also call any | |
131 | * registered cleanup function here. | |
132 | */ | |
133 | static int | |
134 | zcp_error_handler(lua_State *state) | |
135 | { | |
136 | const char *msg; | |
137 | ||
138 | zcp_cleanup(state); | |
139 | ||
140 | VERIFY3U(1, ==, lua_gettop(state)); | |
141 | msg = lua_tostring(state, 1); | |
142 | luaL_traceback(state, state, msg, 1); | |
143 | return (1); | |
144 | } | |
145 | ||
146 | int | |
147 | zcp_argerror(lua_State *state, int narg, const char *msg, ...) | |
148 | { | |
149 | va_list alist; | |
150 | ||
151 | va_start(alist, msg); | |
152 | const char *buf = lua_pushvfstring(state, msg, alist); | |
153 | va_end(alist); | |
154 | ||
155 | return (luaL_argerror(state, narg, buf)); | |
156 | } | |
157 | ||
158 | /* | |
159 | * Install a new cleanup function, which will be invoked with the given | |
160 | * opaque argument if a fatal error causes the Lua interpreter to longjump out | |
161 | * of a function call. | |
162 | * | |
163 | * If an error occurs, the cleanup function will be invoked exactly once and | |
e1cfd73f | 164 | * then unregistered. |
5b72a38d SD |
165 | * |
166 | * Returns the registered cleanup handler so the caller can deregister it | |
167 | * if no error occurs. | |
d99a0153 | 168 | */ |
5b72a38d | 169 | zcp_cleanup_handler_t * |
d99a0153 CW |
170 | zcp_register_cleanup(lua_State *state, zcp_cleanup_t cleanfunc, void *cleanarg) |
171 | { | |
172 | zcp_run_info_t *ri = zcp_run_info(state); | |
d99a0153 | 173 | |
5b72a38d SD |
174 | zcp_cleanup_handler_t *zch = kmem_alloc(sizeof (*zch), KM_SLEEP); |
175 | zch->zch_cleanup_func = cleanfunc; | |
176 | zch->zch_cleanup_arg = cleanarg; | |
177 | list_insert_head(&ri->zri_cleanup_handlers, zch); | |
178 | ||
179 | return (zch); | |
d99a0153 CW |
180 | } |
181 | ||
182 | void | |
5b72a38d | 183 | zcp_deregister_cleanup(lua_State *state, zcp_cleanup_handler_t *zch) |
d99a0153 CW |
184 | { |
185 | zcp_run_info_t *ri = zcp_run_info(state); | |
5b72a38d SD |
186 | list_remove(&ri->zri_cleanup_handlers, zch); |
187 | kmem_free(zch, sizeof (*zch)); | |
d99a0153 CW |
188 | } |
189 | ||
190 | /* | |
5b72a38d SD |
191 | * Execute the currently registered cleanup handlers then free them and |
192 | * destroy the handler list. | |
d99a0153 CW |
193 | */ |
194 | void | |
195 | zcp_cleanup(lua_State *state) | |
196 | { | |
197 | zcp_run_info_t *ri = zcp_run_info(state); | |
198 | ||
5b72a38d SD |
199 | for (zcp_cleanup_handler_t *zch = |
200 | list_remove_head(&ri->zri_cleanup_handlers); zch != NULL; | |
201 | zch = list_remove_head(&ri->zri_cleanup_handlers)) { | |
202 | zch->zch_cleanup_func(zch->zch_cleanup_arg); | |
203 | kmem_free(zch, sizeof (*zch)); | |
d99a0153 CW |
204 | } |
205 | } | |
206 | ||
d99a0153 CW |
207 | /* |
208 | * Convert the lua table at the given index on the Lua stack to an nvlist | |
209 | * and return it. | |
210 | * | |
211 | * If the table can not be converted for any reason, NULL is returned and | |
212 | * an error message is pushed onto the Lua stack. | |
213 | */ | |
214 | static nvlist_t * | |
215 | zcp_table_to_nvlist(lua_State *state, int index, int depth) | |
216 | { | |
217 | nvlist_t *nvl; | |
218 | /* | |
219 | * Converting a Lua table to an nvlist with key uniqueness checking is | |
220 | * O(n^2) in the number of keys in the nvlist, which can take a long | |
221 | * time when we return a large table from a channel program. | |
222 | * Furthermore, Lua's table interface *almost* guarantees unique keys | |
223 | * on its own (details below). Therefore, we don't use fnvlist_alloc() | |
224 | * here to avoid the built-in uniqueness checking. | |
225 | * | |
226 | * The *almost* is because it's possible to have key collisions between | |
227 | * e.g. the string "1" and the number 1, or the string "true" and the | |
228 | * boolean true, so we explicitly check that when we're looking at a | |
229 | * key which is an integer / boolean or a string that can be parsed as | |
230 | * one of those types. In the worst case this could still devolve into | |
231 | * O(n^2), so we only start doing these checks on boolean/integer keys | |
232 | * once we've seen a string key which fits this weird usage pattern. | |
233 | * | |
234 | * Ultimately, we still want callers to know that the keys in this | |
235 | * nvlist are unique, so before we return this we set the nvlist's | |
236 | * flags to reflect that. | |
237 | */ | |
238 | VERIFY0(nvlist_alloc(&nvl, 0, KM_SLEEP)); | |
239 | ||
240 | /* | |
241 | * Push an empty stack slot where lua_next() will store each | |
242 | * table key. | |
243 | */ | |
244 | lua_pushnil(state); | |
245 | boolean_t saw_str_could_collide = B_FALSE; | |
246 | while (lua_next(state, index) != 0) { | |
247 | /* | |
248 | * The next key-value pair from the table at index is | |
249 | * now on the stack, with the key at stack slot -2 and | |
250 | * the value at slot -1. | |
251 | */ | |
252 | int err = 0; | |
253 | char buf[32]; | |
254 | const char *key = NULL; | |
255 | boolean_t key_could_collide = B_FALSE; | |
256 | ||
257 | switch (lua_type(state, -2)) { | |
258 | case LUA_TSTRING: | |
259 | key = lua_tostring(state, -2); | |
260 | ||
261 | /* check if this could collide with a number or bool */ | |
262 | long long tmp; | |
263 | int parselen; | |
264 | if ((sscanf(key, "%lld%n", &tmp, &parselen) > 0 && | |
265 | parselen == strlen(key)) || | |
266 | strcmp(key, "true") == 0 || | |
267 | strcmp(key, "false") == 0) { | |
268 | key_could_collide = B_TRUE; | |
269 | saw_str_could_collide = B_TRUE; | |
270 | } | |
271 | break; | |
272 | case LUA_TBOOLEAN: | |
273 | key = (lua_toboolean(state, -2) == B_TRUE ? | |
274 | "true" : "false"); | |
275 | if (saw_str_could_collide) { | |
276 | key_could_collide = B_TRUE; | |
277 | } | |
278 | break; | |
279 | case LUA_TNUMBER: | |
280 | VERIFY3U(sizeof (buf), >, | |
281 | snprintf(buf, sizeof (buf), "%lld", | |
282 | (longlong_t)lua_tonumber(state, -2))); | |
283 | key = buf; | |
284 | if (saw_str_could_collide) { | |
285 | key_could_collide = B_TRUE; | |
286 | } | |
287 | break; | |
288 | default: | |
289 | fnvlist_free(nvl); | |
290 | (void) lua_pushfstring(state, "Invalid key " | |
291 | "type '%s' in table", | |
292 | lua_typename(state, lua_type(state, -2))); | |
293 | return (NULL); | |
294 | } | |
295 | /* | |
296 | * Check for type-mismatched key collisions, and throw an error. | |
297 | */ | |
298 | if (key_could_collide && nvlist_exists(nvl, key)) { | |
299 | fnvlist_free(nvl); | |
300 | (void) lua_pushfstring(state, "Collision of " | |
301 | "key '%s' in table", key); | |
302 | return (NULL); | |
303 | } | |
304 | /* | |
305 | * Recursively convert the table value and insert into | |
306 | * the new nvlist with the parsed key. To prevent | |
307 | * stack overflow on circular or heavily nested tables, | |
308 | * we track the current nvlist depth. | |
309 | */ | |
310 | if (depth >= ZCP_NVLIST_MAX_DEPTH) { | |
311 | fnvlist_free(nvl); | |
312 | (void) lua_pushfstring(state, "Maximum table " | |
313 | "depth (%d) exceeded for table", | |
314 | ZCP_NVLIST_MAX_DEPTH); | |
315 | return (NULL); | |
316 | } | |
317 | err = zcp_lua_to_nvlist_impl(state, -1, nvl, key, | |
318 | depth + 1); | |
319 | if (err != 0) { | |
320 | fnvlist_free(nvl); | |
321 | /* | |
322 | * Error message has been pushed to the lua | |
323 | * stack by the recursive call. | |
324 | */ | |
325 | return (NULL); | |
326 | } | |
327 | /* | |
328 | * Pop the value pushed by lua_next(). | |
329 | */ | |
330 | lua_pop(state, 1); | |
331 | } | |
332 | ||
333 | /* | |
334 | * Mark the nvlist as having unique keys. This is a little ugly, but we | |
335 | * ensured above that there are no duplicate keys in the nvlist. | |
336 | */ | |
337 | nvl->nvl_nvflag |= NV_UNIQUE_NAME; | |
338 | ||
339 | return (nvl); | |
340 | } | |
341 | ||
342 | /* | |
343 | * Convert a value from the given index into the lua stack to an nvpair, adding | |
344 | * it to an nvlist with the given key. | |
345 | * | |
346 | * Values are converted as follows: | |
347 | * | |
348 | * string -> string | |
349 | * number -> int64 | |
350 | * boolean -> boolean | |
351 | * nil -> boolean (no value) | |
352 | * | |
353 | * Lua tables are converted to nvlists and then inserted. The table's keys | |
354 | * are converted to strings then used as keys in the nvlist to store each table | |
355 | * element. Keys are converted as follows: | |
356 | * | |
357 | * string -> no change | |
358 | * number -> "%lld" | |
359 | * boolean -> "true" | "false" | |
360 | * nil -> error | |
361 | * | |
362 | * In the case of a key collision, an error is thrown. | |
363 | * | |
364 | * If an error is encountered, a nonzero error code is returned, and an error | |
365 | * string will be pushed onto the Lua stack. | |
366 | */ | |
367 | static int | |
368 | zcp_lua_to_nvlist_impl(lua_State *state, int index, nvlist_t *nvl, | |
369 | const char *key, int depth) | |
370 | { | |
371 | /* | |
372 | * Verify that we have enough remaining space in the lua stack to parse | |
373 | * a key-value pair and push an error. | |
374 | */ | |
375 | if (!lua_checkstack(state, 3)) { | |
376 | (void) lua_pushstring(state, "Lua stack overflow"); | |
377 | return (1); | |
378 | } | |
379 | ||
380 | index = lua_absindex(state, index); | |
381 | ||
382 | switch (lua_type(state, index)) { | |
383 | case LUA_TNIL: | |
384 | fnvlist_add_boolean(nvl, key); | |
385 | break; | |
386 | case LUA_TBOOLEAN: | |
387 | fnvlist_add_boolean_value(nvl, key, | |
388 | lua_toboolean(state, index)); | |
389 | break; | |
390 | case LUA_TNUMBER: | |
391 | fnvlist_add_int64(nvl, key, lua_tonumber(state, index)); | |
392 | break; | |
393 | case LUA_TSTRING: | |
394 | fnvlist_add_string(nvl, key, lua_tostring(state, index)); | |
395 | break; | |
396 | case LUA_TTABLE: { | |
397 | nvlist_t *value_nvl = zcp_table_to_nvlist(state, index, depth); | |
398 | if (value_nvl == NULL) | |
28caa74b | 399 | return (SET_ERROR(EINVAL)); |
d99a0153 CW |
400 | |
401 | fnvlist_add_nvlist(nvl, key, value_nvl); | |
402 | fnvlist_free(value_nvl); | |
403 | break; | |
404 | } | |
405 | default: | |
406 | (void) lua_pushfstring(state, | |
407 | "Invalid value type '%s' for key '%s'", | |
408 | lua_typename(state, lua_type(state, index)), key); | |
28caa74b | 409 | return (SET_ERROR(EINVAL)); |
d99a0153 CW |
410 | } |
411 | ||
412 | return (0); | |
413 | } | |
414 | ||
415 | /* | |
416 | * Convert a lua value to an nvpair, adding it to an nvlist with the given key. | |
417 | */ | |
2dca37d8 | 418 | static void |
d99a0153 CW |
419 | zcp_lua_to_nvlist(lua_State *state, int index, nvlist_t *nvl, const char *key) |
420 | { | |
421 | /* | |
422 | * On error, zcp_lua_to_nvlist_impl pushes an error string onto the Lua | |
423 | * stack before returning with a nonzero error code. If an error is | |
424 | * returned, throw a fatal lua error with the given string. | |
425 | */ | |
426 | if (zcp_lua_to_nvlist_impl(state, index, nvl, key, 0) != 0) | |
427 | (void) lua_error(state); | |
428 | } | |
429 | ||
2dca37d8 | 430 | static int |
d99a0153 CW |
431 | zcp_lua_to_nvlist_helper(lua_State *state) |
432 | { | |
433 | nvlist_t *nv = (nvlist_t *)lua_touserdata(state, 2); | |
434 | const char *key = (const char *)lua_touserdata(state, 1); | |
435 | zcp_lua_to_nvlist(state, 3, nv, key); | |
436 | return (0); | |
437 | } | |
438 | ||
2dca37d8 | 439 | static void |
d99a0153 | 440 | zcp_convert_return_values(lua_State *state, nvlist_t *nvl, |
186898bb | 441 | const char *key, int *result) |
d99a0153 CW |
442 | { |
443 | int err; | |
2dca37d8 | 444 | VERIFY3U(1, ==, lua_gettop(state)); |
d99a0153 CW |
445 | lua_pushcfunction(state, zcp_lua_to_nvlist_helper); |
446 | lua_pushlightuserdata(state, (char *)key); | |
447 | lua_pushlightuserdata(state, nvl); | |
448 | lua_pushvalue(state, 1); | |
449 | lua_remove(state, 1); | |
450 | err = lua_pcall(state, 3, 0, 0); /* zcp_lua_to_nvlist_helper */ | |
451 | if (err != 0) { | |
452 | zcp_lua_to_nvlist(state, 1, nvl, ZCP_RET_ERROR); | |
186898bb | 453 | *result = SET_ERROR(ECHRNG); |
d99a0153 CW |
454 | } |
455 | } | |
456 | ||
457 | /* | |
458 | * Push a Lua table representing nvl onto the stack. If it can't be | |
459 | * converted, return EINVAL, fill in errbuf, and push nothing. errbuf may | |
460 | * be specified as NULL, in which case no error string will be output. | |
461 | * | |
462 | * Most nvlists are converted as simple key->value Lua tables, but we make | |
463 | * an exception for the case where all nvlist entries are BOOLEANs (a string | |
464 | * key without a value). In Lua, a table key pointing to a value of Nil | |
465 | * (no value) is equivalent to the key not existing, so a BOOLEAN nvlist | |
466 | * entry can't be directly converted to a Lua table entry. Nvlists of entirely | |
467 | * BOOLEAN entries are frequently used to pass around lists of datasets, so for | |
468 | * convenience we check for this case, and convert it to a simple Lua array of | |
469 | * strings. | |
470 | */ | |
471 | int | |
472 | zcp_nvlist_to_lua(lua_State *state, nvlist_t *nvl, | |
473 | char *errbuf, int errbuf_len) | |
474 | { | |
475 | nvpair_t *pair; | |
476 | lua_newtable(state); | |
477 | boolean_t has_values = B_FALSE; | |
478 | /* | |
479 | * If the list doesn't have any values, just convert it to a string | |
480 | * array. | |
481 | */ | |
482 | for (pair = nvlist_next_nvpair(nvl, NULL); | |
483 | pair != NULL; pair = nvlist_next_nvpair(nvl, pair)) { | |
484 | if (nvpair_type(pair) != DATA_TYPE_BOOLEAN) { | |
485 | has_values = B_TRUE; | |
486 | break; | |
487 | } | |
488 | } | |
489 | if (!has_values) { | |
490 | int i = 1; | |
491 | for (pair = nvlist_next_nvpair(nvl, NULL); | |
492 | pair != NULL; pair = nvlist_next_nvpair(nvl, pair)) { | |
493 | (void) lua_pushinteger(state, i); | |
494 | (void) lua_pushstring(state, nvpair_name(pair)); | |
495 | (void) lua_settable(state, -3); | |
496 | i++; | |
497 | } | |
498 | } else { | |
499 | for (pair = nvlist_next_nvpair(nvl, NULL); | |
500 | pair != NULL; pair = nvlist_next_nvpair(nvl, pair)) { | |
501 | int err = zcp_nvpair_value_to_lua(state, pair, | |
502 | errbuf, errbuf_len); | |
503 | if (err != 0) { | |
504 | lua_pop(state, 1); | |
505 | return (err); | |
506 | } | |
507 | (void) lua_setfield(state, -2, nvpair_name(pair)); | |
508 | } | |
509 | } | |
510 | return (0); | |
511 | } | |
512 | ||
513 | /* | |
514 | * Push a Lua object representing the value of "pair" onto the stack. | |
515 | * | |
516 | * Only understands boolean_value, string, int64, nvlist, | |
517 | * string_array, and int64_array type values. For other | |
518 | * types, returns EINVAL, fills in errbuf, and pushes nothing. | |
519 | */ | |
520 | static int | |
521 | zcp_nvpair_value_to_lua(lua_State *state, nvpair_t *pair, | |
522 | char *errbuf, int errbuf_len) | |
523 | { | |
524 | int err = 0; | |
525 | ||
526 | if (pair == NULL) { | |
527 | lua_pushnil(state); | |
528 | return (0); | |
529 | } | |
530 | ||
531 | switch (nvpair_type(pair)) { | |
532 | case DATA_TYPE_BOOLEAN_VALUE: | |
533 | (void) lua_pushboolean(state, | |
534 | fnvpair_value_boolean_value(pair)); | |
535 | break; | |
536 | case DATA_TYPE_STRING: | |
537 | (void) lua_pushstring(state, fnvpair_value_string(pair)); | |
538 | break; | |
539 | case DATA_TYPE_INT64: | |
540 | (void) lua_pushinteger(state, fnvpair_value_int64(pair)); | |
541 | break; | |
542 | case DATA_TYPE_NVLIST: | |
543 | err = zcp_nvlist_to_lua(state, | |
544 | fnvpair_value_nvlist(pair), errbuf, errbuf_len); | |
545 | break; | |
546 | case DATA_TYPE_STRING_ARRAY: { | |
547 | char **strarr; | |
548 | uint_t nelem; | |
549 | (void) nvpair_value_string_array(pair, &strarr, &nelem); | |
550 | lua_newtable(state); | |
551 | for (int i = 0; i < nelem; i++) { | |
552 | (void) lua_pushinteger(state, i + 1); | |
553 | (void) lua_pushstring(state, strarr[i]); | |
554 | (void) lua_settable(state, -3); | |
555 | } | |
556 | break; | |
557 | } | |
558 | case DATA_TYPE_UINT64_ARRAY: { | |
559 | uint64_t *intarr; | |
560 | uint_t nelem; | |
561 | (void) nvpair_value_uint64_array(pair, &intarr, &nelem); | |
562 | lua_newtable(state); | |
563 | for (int i = 0; i < nelem; i++) { | |
564 | (void) lua_pushinteger(state, i + 1); | |
565 | (void) lua_pushinteger(state, intarr[i]); | |
566 | (void) lua_settable(state, -3); | |
567 | } | |
568 | break; | |
569 | } | |
570 | case DATA_TYPE_INT64_ARRAY: { | |
571 | int64_t *intarr; | |
572 | uint_t nelem; | |
573 | (void) nvpair_value_int64_array(pair, &intarr, &nelem); | |
574 | lua_newtable(state); | |
575 | for (int i = 0; i < nelem; i++) { | |
576 | (void) lua_pushinteger(state, i + 1); | |
577 | (void) lua_pushinteger(state, intarr[i]); | |
578 | (void) lua_settable(state, -3); | |
579 | } | |
580 | break; | |
581 | } | |
582 | default: { | |
583 | if (errbuf != NULL) { | |
584 | (void) snprintf(errbuf, errbuf_len, | |
585 | "Unhandled nvpair type %d for key '%s'", | |
586 | nvpair_type(pair), nvpair_name(pair)); | |
587 | } | |
28caa74b | 588 | return (SET_ERROR(EINVAL)); |
d99a0153 CW |
589 | } |
590 | } | |
591 | return (err); | |
592 | } | |
593 | ||
594 | int | |
595 | zcp_dataset_hold_error(lua_State *state, dsl_pool_t *dp, const char *dsname, | |
596 | int error) | |
597 | { | |
598 | if (error == ENOENT) { | |
599 | (void) zcp_argerror(state, 1, "no such dataset '%s'", dsname); | |
600 | return (0); /* not reached; zcp_argerror will longjmp */ | |
601 | } else if (error == EXDEV) { | |
602 | (void) zcp_argerror(state, 1, | |
603 | "dataset '%s' is not in the target pool '%s'", | |
604 | dsname, spa_name(dp->dp_spa)); | |
605 | return (0); /* not reached; zcp_argerror will longjmp */ | |
606 | } else if (error == EIO) { | |
607 | (void) luaL_error(state, | |
608 | "I/O error while accessing dataset '%s'", dsname); | |
609 | return (0); /* not reached; luaL_error will longjmp */ | |
610 | } else if (error != 0) { | |
611 | (void) luaL_error(state, | |
612 | "unexpected error %d while accessing dataset '%s'", | |
613 | error, dsname); | |
614 | return (0); /* not reached; luaL_error will longjmp */ | |
615 | } | |
616 | return (0); | |
617 | } | |
618 | ||
619 | /* | |
620 | * Note: will longjmp (via lua_error()) on error. | |
621 | * Assumes that the dsname is argument #1 (for error reporting purposes). | |
622 | */ | |
623 | dsl_dataset_t * | |
624 | zcp_dataset_hold(lua_State *state, dsl_pool_t *dp, const char *dsname, | |
625 | void *tag) | |
626 | { | |
627 | dsl_dataset_t *ds; | |
628 | int error = dsl_dataset_hold(dp, dsname, tag, &ds); | |
629 | (void) zcp_dataset_hold_error(state, dp, dsname, error); | |
630 | return (ds); | |
631 | } | |
632 | ||
633 | static int zcp_debug(lua_State *); | |
18168da7 | 634 | static const zcp_lib_info_t zcp_debug_info = { |
d99a0153 CW |
635 | .name = "debug", |
636 | .func = zcp_debug, | |
637 | .pargs = { | |
18168da7 | 638 | { .za_name = "debug string", .za_lua_type = LUA_TSTRING }, |
d99a0153 CW |
639 | {NULL, 0} |
640 | }, | |
641 | .kwargs = { | |
642 | {NULL, 0} | |
643 | } | |
644 | }; | |
645 | ||
646 | static int | |
647 | zcp_debug(lua_State *state) | |
648 | { | |
649 | const char *dbgstring; | |
650 | zcp_run_info_t *ri = zcp_run_info(state); | |
18168da7 | 651 | const zcp_lib_info_t *libinfo = &zcp_debug_info; |
d99a0153 CW |
652 | |
653 | zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs); | |
654 | ||
655 | dbgstring = lua_tostring(state, 1); | |
656 | ||
8e739b2c RE |
657 | zfs_dbgmsg("txg %lld ZCP: %s", (longlong_t)ri->zri_tx->tx_txg, |
658 | dbgstring); | |
d99a0153 CW |
659 | |
660 | return (0); | |
661 | } | |
662 | ||
663 | static int zcp_exists(lua_State *); | |
18168da7 | 664 | static const zcp_lib_info_t zcp_exists_info = { |
d99a0153 CW |
665 | .name = "exists", |
666 | .func = zcp_exists, | |
667 | .pargs = { | |
18168da7 | 668 | { .za_name = "dataset", .za_lua_type = LUA_TSTRING }, |
d99a0153 CW |
669 | {NULL, 0} |
670 | }, | |
671 | .kwargs = { | |
672 | {NULL, 0} | |
673 | } | |
674 | }; | |
675 | ||
676 | static int | |
677 | zcp_exists(lua_State *state) | |
678 | { | |
679 | zcp_run_info_t *ri = zcp_run_info(state); | |
680 | dsl_pool_t *dp = ri->zri_pool; | |
18168da7 | 681 | const zcp_lib_info_t *libinfo = &zcp_exists_info; |
d99a0153 CW |
682 | |
683 | zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs); | |
684 | ||
685 | const char *dsname = lua_tostring(state, 1); | |
686 | ||
687 | dsl_dataset_t *ds; | |
688 | int error = dsl_dataset_hold(dp, dsname, FTAG, &ds); | |
689 | if (error == 0) { | |
690 | dsl_dataset_rele(ds, FTAG); | |
691 | lua_pushboolean(state, B_TRUE); | |
692 | } else if (error == ENOENT) { | |
693 | lua_pushboolean(state, B_FALSE); | |
694 | } else if (error == EXDEV) { | |
695 | return (luaL_error(state, "dataset '%s' is not in the " | |
696 | "target pool", dsname)); | |
697 | } else if (error == EIO) { | |
698 | return (luaL_error(state, "I/O error opening dataset '%s'", | |
699 | dsname)); | |
700 | } else if (error != 0) { | |
701 | return (luaL_error(state, "unexpected error %d", error)); | |
702 | } | |
703 | ||
475eca49 | 704 | return (1); |
d99a0153 CW |
705 | } |
706 | ||
707 | /* | |
708 | * Allocate/realloc/free a buffer for the lua interpreter. | |
709 | * | |
710 | * When nsize is 0, behaves as free() and returns NULL. | |
711 | * | |
712 | * If ptr is NULL, behaves as malloc() and returns an allocated buffer of size | |
713 | * at least nsize. | |
714 | * | |
715 | * Otherwise, behaves as realloc(), changing the allocation from osize to nsize. | |
716 | * Shrinking the buffer size never fails. | |
717 | * | |
718 | * The original allocated buffer size is stored as a uint64 at the beginning of | |
719 | * the buffer to avoid actually reallocating when shrinking a buffer, since lua | |
720 | * requires that this operation never fail. | |
721 | */ | |
722 | static void * | |
723 | zcp_lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize) | |
724 | { | |
725 | zcp_alloc_arg_t *allocargs = ud; | |
d99a0153 CW |
726 | |
727 | if (nsize == 0) { | |
728 | if (ptr != NULL) { | |
729 | int64_t *allocbuf = (int64_t *)ptr - 1; | |
730 | int64_t allocsize = *allocbuf; | |
731 | ASSERT3S(allocsize, >, 0); | |
732 | ASSERT3S(allocargs->aa_alloc_remaining + allocsize, <=, | |
733 | allocargs->aa_alloc_limit); | |
734 | allocargs->aa_alloc_remaining += allocsize; | |
735 | vmem_free(allocbuf, allocsize); | |
736 | } | |
737 | return (NULL); | |
738 | } else if (ptr == NULL) { | |
739 | int64_t *allocbuf; | |
740 | int64_t allocsize = nsize + sizeof (int64_t); | |
741 | ||
742 | if (!allocargs->aa_must_succeed && | |
743 | (allocsize <= 0 || | |
744 | allocsize > allocargs->aa_alloc_remaining)) { | |
745 | return (NULL); | |
746 | } | |
747 | ||
a724db03 | 748 | allocbuf = vmem_alloc(allocsize, KM_SLEEP); |
d99a0153 CW |
749 | allocargs->aa_alloc_remaining -= allocsize; |
750 | ||
751 | *allocbuf = allocsize; | |
752 | return (allocbuf + 1); | |
753 | } else if (nsize <= osize) { | |
754 | /* | |
755 | * If shrinking the buffer, lua requires that the reallocation | |
756 | * never fail. | |
757 | */ | |
758 | return (ptr); | |
759 | } else { | |
760 | ASSERT3U(nsize, >, osize); | |
761 | ||
762 | uint64_t *luabuf = zcp_lua_alloc(ud, NULL, 0, nsize); | |
763 | if (luabuf == NULL) { | |
764 | return (NULL); | |
765 | } | |
766 | (void) memcpy(luabuf, ptr, osize); | |
767 | VERIFY3P(zcp_lua_alloc(ud, ptr, osize, 0), ==, NULL); | |
768 | return (luabuf); | |
769 | } | |
770 | } | |
771 | ||
d99a0153 CW |
772 | static void |
773 | zcp_lua_counthook(lua_State *state, lua_Debug *ar) | |
774 | { | |
14e4e3cb | 775 | (void) ar; |
d99a0153 CW |
776 | lua_getfield(state, LUA_REGISTRYINDEX, ZCP_RUN_INFO_KEY); |
777 | zcp_run_info_t *ri = lua_touserdata(state, -1); | |
778 | ||
186898bb DB |
779 | /* |
780 | * Check if we were canceled while waiting for the | |
781 | * txg to sync or from our open context thread | |
782 | */ | |
783 | if (ri->zri_canceled || | |
784 | (!ri->zri_sync && issig(JUSTLOOKING) && issig(FORREAL))) { | |
785 | ri->zri_canceled = B_TRUE; | |
786 | (void) lua_pushstring(state, "Channel program was canceled."); | |
787 | (void) lua_error(state); | |
788 | /* Unreachable */ | |
789 | } | |
790 | ||
791 | /* | |
792 | * Check how many instructions the channel program has | |
793 | * executed so far, and compare against the limit. | |
794 | */ | |
d99a0153 CW |
795 | ri->zri_curinstrs += zfs_lua_check_instrlimit_interval; |
796 | if (ri->zri_maxinstrs != 0 && ri->zri_curinstrs > ri->zri_maxinstrs) { | |
797 | ri->zri_timed_out = B_TRUE; | |
798 | (void) lua_pushstring(state, | |
799 | "Channel program timed out."); | |
800 | (void) lua_error(state); | |
186898bb | 801 | /* Unreachable */ |
d99a0153 CW |
802 | } |
803 | } | |
804 | ||
805 | static int | |
806 | zcp_panic_cb(lua_State *state) | |
807 | { | |
808 | panic("unprotected error in call to Lua API (%s)\n", | |
809 | lua_tostring(state, -1)); | |
810 | return (0); | |
811 | } | |
812 | ||
813 | static void | |
186898bb | 814 | zcp_eval_impl(dmu_tx_t *tx, zcp_run_info_t *ri) |
d99a0153 CW |
815 | { |
816 | int err; | |
186898bb | 817 | lua_State *state = ri->zri_state; |
d99a0153 | 818 | |
d99a0153 CW |
819 | VERIFY3U(3, ==, lua_gettop(state)); |
820 | ||
186898bb DB |
821 | /* finish initializing our runtime state */ |
822 | ri->zri_pool = dmu_tx_pool(tx); | |
823 | ri->zri_tx = tx; | |
824 | list_create(&ri->zri_cleanup_handlers, sizeof (zcp_cleanup_handler_t), | |
825 | offsetof(zcp_cleanup_handler_t, zch_node)); | |
826 | ||
d99a0153 CW |
827 | /* |
828 | * Store the zcp_run_info_t struct for this run in the Lua registry. | |
829 | * Registry entries are not directly accessible by the Lua scripts but | |
830 | * can be accessed by our callbacks. | |
831 | */ | |
186898bb | 832 | lua_pushlightuserdata(state, ri); |
d99a0153 CW |
833 | lua_setfield(state, LUA_REGISTRYINDEX, ZCP_RUN_INFO_KEY); |
834 | VERIFY3U(3, ==, lua_gettop(state)); | |
835 | ||
836 | /* | |
837 | * Tell the Lua interpreter to call our handler every count | |
838 | * instructions. Channel programs that execute too many instructions | |
839 | * should die with ETIME. | |
840 | */ | |
841 | (void) lua_sethook(state, zcp_lua_counthook, LUA_MASKCOUNT, | |
842 | zfs_lua_check_instrlimit_interval); | |
843 | ||
844 | /* | |
845 | * Tell the Lua memory allocator to stop using KM_SLEEP before handing | |
846 | * off control to the channel program. Channel programs that use too | |
847 | * much memory should die with ENOSPC. | |
848 | */ | |
186898bb | 849 | ri->zri_allocargs->aa_must_succeed = B_FALSE; |
d99a0153 CW |
850 | |
851 | /* | |
852 | * Call the Lua function that open-context passed us. This pops the | |
853 | * function and its input from the stack and pushes any return | |
854 | * or error values. | |
855 | */ | |
856 | err = lua_pcall(state, 1, LUA_MULTRET, 1); | |
857 | ||
858 | /* | |
859 | * Let Lua use KM_SLEEP while we interpret the return values. | |
860 | */ | |
186898bb | 861 | ri->zri_allocargs->aa_must_succeed = B_TRUE; |
d99a0153 CW |
862 | |
863 | /* | |
864 | * Remove the error handler callback from the stack. At this point, | |
5b72a38d SD |
865 | * there shouldn't be any cleanup handler registered in the handler |
866 | * list (zri_cleanup_handlers), regardless of whether it ran or not. | |
d99a0153 | 867 | */ |
186898bb | 868 | list_destroy(&ri->zri_cleanup_handlers); |
d99a0153 CW |
869 | lua_remove(state, 1); |
870 | ||
871 | switch (err) { | |
872 | case LUA_OK: { | |
873 | /* | |
874 | * Lua supports returning multiple values in a single return | |
875 | * statement. Return values will have been pushed onto the | |
876 | * stack: | |
877 | * 1: Return value 1 | |
878 | * 2: Return value 2 | |
879 | * 3: etc... | |
880 | * To simplify the process of retrieving a return value from a | |
881 | * channel program, we disallow returning more than one value | |
882 | * to ZFS from the Lua script, yielding a singleton return | |
883 | * nvlist of the form { "return": Return value 1 }. | |
884 | */ | |
885 | int return_count = lua_gettop(state); | |
886 | ||
887 | if (return_count == 1) { | |
186898bb DB |
888 | ri->zri_result = 0; |
889 | zcp_convert_return_values(state, ri->zri_outnvl, | |
890 | ZCP_RET_RETURN, &ri->zri_result); | |
d99a0153 | 891 | } else if (return_count > 1) { |
186898bb | 892 | ri->zri_result = SET_ERROR(ECHRNG); |
2dca37d8 | 893 | lua_settop(state, 0); |
d99a0153 CW |
894 | (void) lua_pushfstring(state, "Multiple return " |
895 | "values not supported"); | |
186898bb DB |
896 | zcp_convert_return_values(state, ri->zri_outnvl, |
897 | ZCP_RET_ERROR, &ri->zri_result); | |
d99a0153 CW |
898 | } |
899 | break; | |
900 | } | |
901 | case LUA_ERRRUN: | |
902 | case LUA_ERRGCMM: { | |
903 | /* | |
904 | * The channel program encountered a fatal error within the | |
905 | * script, such as failing an assertion, or calling a function | |
906 | * with incompatible arguments. The error value and the | |
907 | * traceback generated by zcp_error_handler() should be on the | |
908 | * stack. | |
909 | */ | |
910 | VERIFY3U(1, ==, lua_gettop(state)); | |
186898bb DB |
911 | if (ri->zri_timed_out) { |
912 | ri->zri_result = SET_ERROR(ETIME); | |
913 | } else if (ri->zri_canceled) { | |
914 | ri->zri_result = SET_ERROR(EINTR); | |
d99a0153 | 915 | } else { |
186898bb | 916 | ri->zri_result = SET_ERROR(ECHRNG); |
d99a0153 CW |
917 | } |
918 | ||
186898bb DB |
919 | zcp_convert_return_values(state, ri->zri_outnvl, |
920 | ZCP_RET_ERROR, &ri->zri_result); | |
d99a0153 | 921 | |
186898bb DB |
922 | if (ri->zri_result == ETIME && ri->zri_outnvl != NULL) { |
923 | (void) nvlist_add_uint64(ri->zri_outnvl, | |
924 | ZCP_ARG_INSTRLIMIT, ri->zri_curinstrs); | |
d99a0153 CW |
925 | } |
926 | break; | |
927 | } | |
928 | case LUA_ERRERR: { | |
929 | /* | |
930 | * The channel program encountered a fatal error within the | |
931 | * script, and we encountered another error while trying to | |
932 | * compute the traceback in zcp_error_handler(). We can only | |
933 | * return the error message. | |
934 | */ | |
935 | VERIFY3U(1, ==, lua_gettop(state)); | |
186898bb DB |
936 | if (ri->zri_timed_out) { |
937 | ri->zri_result = SET_ERROR(ETIME); | |
938 | } else if (ri->zri_canceled) { | |
939 | ri->zri_result = SET_ERROR(EINTR); | |
d99a0153 | 940 | } else { |
186898bb | 941 | ri->zri_result = SET_ERROR(ECHRNG); |
d99a0153 CW |
942 | } |
943 | ||
186898bb DB |
944 | zcp_convert_return_values(state, ri->zri_outnvl, |
945 | ZCP_RET_ERROR, &ri->zri_result); | |
d99a0153 CW |
946 | break; |
947 | } | |
948 | case LUA_ERRMEM: | |
949 | /* | |
950 | * Lua ran out of memory while running the channel program. | |
951 | * There's not much we can do. | |
952 | */ | |
186898bb | 953 | ri->zri_result = SET_ERROR(ENOSPC); |
d99a0153 CW |
954 | break; |
955 | default: | |
956 | VERIFY0(err); | |
957 | } | |
958 | } | |
959 | ||
5b72a38d | 960 | static void |
186898bb | 961 | zcp_pool_error(zcp_run_info_t *ri, const char *poolname) |
5b72a38d | 962 | { |
186898bb DB |
963 | ri->zri_result = SET_ERROR(ECHRNG); |
964 | lua_settop(ri->zri_state, 0); | |
965 | (void) lua_pushfstring(ri->zri_state, "Could not open pool: %s", | |
5b72a38d | 966 | poolname); |
186898bb DB |
967 | zcp_convert_return_values(ri->zri_state, ri->zri_outnvl, |
968 | ZCP_RET_ERROR, &ri->zri_result); | |
969 | ||
970 | } | |
971 | ||
972 | /* | |
973 | * This callback is called when txg_wait_synced_sig encountered a signal. | |
974 | * The txg_wait_synced_sig will continue to wait for the txg to complete | |
975 | * after calling this callback. | |
976 | */ | |
186898bb DB |
977 | static void |
978 | zcp_eval_sig(void *arg, dmu_tx_t *tx) | |
979 | { | |
14e4e3cb | 980 | (void) tx; |
186898bb | 981 | zcp_run_info_t *ri = arg; |
5b72a38d | 982 | |
186898bb | 983 | ri->zri_canceled = B_TRUE; |
5b72a38d SD |
984 | } |
985 | ||
986 | static void | |
987 | zcp_eval_sync(void *arg, dmu_tx_t *tx) | |
988 | { | |
186898bb | 989 | zcp_run_info_t *ri = arg; |
5b72a38d SD |
990 | |
991 | /* | |
992 | * Open context should have setup the stack to contain: | |
993 | * 1: Error handler callback | |
994 | * 2: Script to run (converted to a Lua function) | |
995 | * 3: nvlist input to function (converted to Lua table or nil) | |
996 | */ | |
186898bb | 997 | VERIFY3U(3, ==, lua_gettop(ri->zri_state)); |
5b72a38d | 998 | |
186898bb | 999 | zcp_eval_impl(tx, ri); |
5b72a38d SD |
1000 | } |
1001 | ||
1002 | static void | |
186898bb | 1003 | zcp_eval_open(zcp_run_info_t *ri, const char *poolname) |
5b72a38d | 1004 | { |
5b72a38d SD |
1005 | int error; |
1006 | dsl_pool_t *dp; | |
1007 | dmu_tx_t *tx; | |
1008 | ||
1009 | /* | |
1010 | * See comment from the same assertion in zcp_eval_sync(). | |
1011 | */ | |
186898bb | 1012 | VERIFY3U(3, ==, lua_gettop(ri->zri_state)); |
5b72a38d SD |
1013 | |
1014 | error = dsl_pool_hold(poolname, FTAG, &dp); | |
1015 | if (error != 0) { | |
186898bb | 1016 | zcp_pool_error(ri, poolname); |
5b72a38d SD |
1017 | return; |
1018 | } | |
1019 | ||
1020 | /* | |
1021 | * As we are running in open-context, we have no transaction associated | |
1022 | * with the channel program. At the same time, functions from the | |
1023 | * zfs.check submodule need to be associated with a transaction as | |
1024 | * they are basically dry-runs of their counterparts in the zfs.sync | |
1025 | * submodule. These functions should be able to run in open-context. | |
1026 | * Therefore we create a new transaction that we later abort once | |
1027 | * the channel program has been evaluated. | |
1028 | */ | |
1029 | tx = dmu_tx_create_dd(dp->dp_mos_dir); | |
1030 | ||
186898bb | 1031 | zcp_eval_impl(tx, ri); |
5b72a38d SD |
1032 | |
1033 | dmu_tx_abort(tx); | |
1034 | ||
1035 | dsl_pool_rele(dp, FTAG); | |
1036 | } | |
1037 | ||
d99a0153 | 1038 | int |
5b72a38d SD |
1039 | zcp_eval(const char *poolname, const char *program, boolean_t sync, |
1040 | uint64_t instrlimit, uint64_t memlimit, nvpair_t *nvarg, nvlist_t *outnvl) | |
d99a0153 CW |
1041 | { |
1042 | int err; | |
1043 | lua_State *state; | |
186898bb | 1044 | zcp_run_info_t runinfo; |
d99a0153 CW |
1045 | |
1046 | if (instrlimit > zfs_lua_max_instrlimit) | |
1047 | return (SET_ERROR(EINVAL)); | |
1048 | if (memlimit == 0 || memlimit > zfs_lua_max_memlimit) | |
1049 | return (SET_ERROR(EINVAL)); | |
1050 | ||
1051 | zcp_alloc_arg_t allocargs = { | |
1052 | .aa_must_succeed = B_TRUE, | |
1053 | .aa_alloc_remaining = (int64_t)memlimit, | |
1054 | .aa_alloc_limit = (int64_t)memlimit, | |
1055 | }; | |
1056 | ||
1057 | /* | |
1058 | * Creates a Lua state with a memory allocator that uses KM_SLEEP. | |
1059 | * This should never fail. | |
1060 | */ | |
1061 | state = lua_newstate(zcp_lua_alloc, &allocargs); | |
1062 | VERIFY(state != NULL); | |
1063 | (void) lua_atpanic(state, zcp_panic_cb); | |
1064 | ||
1065 | /* | |
1066 | * Load core Lua libraries we want access to. | |
1067 | */ | |
1068 | VERIFY3U(1, ==, luaopen_base(state)); | |
1069 | lua_pop(state, 1); | |
1070 | VERIFY3U(1, ==, luaopen_coroutine(state)); | |
1071 | lua_setglobal(state, LUA_COLIBNAME); | |
1072 | VERIFY0(lua_gettop(state)); | |
1073 | VERIFY3U(1, ==, luaopen_string(state)); | |
1074 | lua_setglobal(state, LUA_STRLIBNAME); | |
1075 | VERIFY0(lua_gettop(state)); | |
1076 | VERIFY3U(1, ==, luaopen_table(state)); | |
1077 | lua_setglobal(state, LUA_TABLIBNAME); | |
1078 | VERIFY0(lua_gettop(state)); | |
1079 | ||
1080 | /* | |
1081 | * Load globally visible variables such as errno aliases. | |
1082 | */ | |
1083 | zcp_load_globals(state); | |
1084 | VERIFY0(lua_gettop(state)); | |
1085 | ||
1086 | /* | |
1087 | * Load ZFS-specific modules. | |
1088 | */ | |
1089 | lua_newtable(state); | |
1090 | VERIFY3U(1, ==, zcp_load_list_lib(state)); | |
1091 | lua_setfield(state, -2, "list"); | |
1092 | VERIFY3U(1, ==, zcp_load_synctask_lib(state, B_FALSE)); | |
1093 | lua_setfield(state, -2, "check"); | |
1094 | VERIFY3U(1, ==, zcp_load_synctask_lib(state, B_TRUE)); | |
1095 | lua_setfield(state, -2, "sync"); | |
1096 | VERIFY3U(1, ==, zcp_load_get_lib(state)); | |
1097 | lua_pushcclosure(state, zcp_debug_info.func, 0); | |
1098 | lua_setfield(state, -2, zcp_debug_info.name); | |
1099 | lua_pushcclosure(state, zcp_exists_info.func, 0); | |
1100 | lua_setfield(state, -2, zcp_exists_info.name); | |
1101 | lua_setglobal(state, "zfs"); | |
1102 | VERIFY0(lua_gettop(state)); | |
1103 | ||
1104 | /* | |
1105 | * Push the error-callback that calculates Lua stack traces on | |
1106 | * unexpected failures. | |
1107 | */ | |
1108 | lua_pushcfunction(state, zcp_error_handler); | |
1109 | VERIFY3U(1, ==, lua_gettop(state)); | |
1110 | ||
1111 | /* | |
1112 | * Load the actual script as a function onto the stack as text ("t"). | |
1113 | * The only valid error condition is a syntax error in the script. | |
1114 | * ERRMEM should not be possible because our allocator is using | |
1115 | * KM_SLEEP. ERRGCMM should not be possible because we have not added | |
1116 | * any objects with __gc metamethods to the interpreter that could | |
1117 | * fail. | |
1118 | */ | |
1119 | err = luaL_loadbufferx(state, program, strlen(program), | |
1120 | "channel program", "t"); | |
1121 | if (err == LUA_ERRSYNTAX) { | |
1122 | fnvlist_add_string(outnvl, ZCP_RET_ERROR, | |
1123 | lua_tostring(state, -1)); | |
1124 | lua_close(state); | |
1125 | return (SET_ERROR(EINVAL)); | |
1126 | } | |
1127 | VERIFY0(err); | |
1128 | VERIFY3U(2, ==, lua_gettop(state)); | |
1129 | ||
1130 | /* | |
1131 | * Convert the input nvlist to a Lua object and put it on top of the | |
1132 | * stack. | |
1133 | */ | |
1134 | char errmsg[128]; | |
1135 | err = zcp_nvpair_value_to_lua(state, nvarg, | |
1136 | errmsg, sizeof (errmsg)); | |
1137 | if (err != 0) { | |
1138 | fnvlist_add_string(outnvl, ZCP_RET_ERROR, errmsg); | |
1139 | lua_close(state); | |
1140 | return (SET_ERROR(EINVAL)); | |
1141 | } | |
1142 | VERIFY3U(3, ==, lua_gettop(state)); | |
1143 | ||
186898bb DB |
1144 | runinfo.zri_state = state; |
1145 | runinfo.zri_allocargs = &allocargs; | |
1146 | runinfo.zri_outnvl = outnvl; | |
1147 | runinfo.zri_result = 0; | |
1148 | runinfo.zri_cred = CRED(); | |
e59a377a | 1149 | runinfo.zri_proc = curproc; |
186898bb DB |
1150 | runinfo.zri_timed_out = B_FALSE; |
1151 | runinfo.zri_canceled = B_FALSE; | |
1152 | runinfo.zri_sync = sync; | |
1153 | runinfo.zri_space_used = 0; | |
1154 | runinfo.zri_curinstrs = 0; | |
1155 | runinfo.zri_maxinstrs = instrlimit; | |
ec213971 | 1156 | runinfo.zri_new_zvols = fnvlist_alloc(); |
d99a0153 | 1157 | |
5b72a38d | 1158 | if (sync) { |
186898bb DB |
1159 | err = dsl_sync_task_sig(poolname, NULL, zcp_eval_sync, |
1160 | zcp_eval_sig, &runinfo, 0, ZFS_SPACE_CHECK_ZCP_EVAL); | |
5b72a38d | 1161 | if (err != 0) |
186898bb | 1162 | zcp_pool_error(&runinfo, poolname); |
5b72a38d | 1163 | } else { |
186898bb | 1164 | zcp_eval_open(&runinfo, poolname); |
5b72a38d | 1165 | } |
d99a0153 CW |
1166 | lua_close(state); |
1167 | ||
ec213971 MA |
1168 | /* |
1169 | * Create device minor nodes for any new zvols. | |
1170 | */ | |
1171 | for (nvpair_t *pair = nvlist_next_nvpair(runinfo.zri_new_zvols, NULL); | |
1172 | pair != NULL; | |
1173 | pair = nvlist_next_nvpair(runinfo.zri_new_zvols, pair)) { | |
1174 | zvol_create_minor(nvpair_name(pair)); | |
1175 | } | |
1176 | fnvlist_free(runinfo.zri_new_zvols); | |
1177 | ||
186898bb | 1178 | return (runinfo.zri_result); |
d99a0153 CW |
1179 | } |
1180 | ||
1181 | /* | |
1182 | * Retrieve metadata about the currently running channel program. | |
1183 | */ | |
1184 | zcp_run_info_t * | |
1185 | zcp_run_info(lua_State *state) | |
1186 | { | |
1187 | zcp_run_info_t *ri; | |
1188 | ||
1189 | lua_getfield(state, LUA_REGISTRYINDEX, ZCP_RUN_INFO_KEY); | |
1190 | ri = lua_touserdata(state, -1); | |
1191 | lua_pop(state, 1); | |
1192 | return (ri); | |
1193 | } | |
1194 | ||
1195 | /* | |
1196 | * Argument Parsing | |
1197 | * ================ | |
1198 | * | |
1199 | * The Lua language allows methods to be called with any number | |
1200 | * of arguments of any type. When calling back into ZFS we need to sanitize | |
1201 | * arguments from channel programs to make sure unexpected arguments or | |
1202 | * arguments of the wrong type result in clear error messages. To do this | |
1203 | * in a uniform way all callbacks from channel programs should use the | |
1204 | * zcp_parse_args() function to interpret inputs. | |
1205 | * | |
1206 | * Positional vs Keyword Arguments | |
1207 | * =============================== | |
1208 | * | |
1209 | * Every callback function takes a fixed set of required positional arguments | |
1210 | * and optional keyword arguments. For example, the destroy function takes | |
1211 | * a single positional string argument (the name of the dataset to destroy) | |
1212 | * and an optional "defer" keyword boolean argument. When calling lua functions | |
1213 | * with parentheses, only positional arguments can be used: | |
1214 | * | |
1215 | * zfs.sync.snapshot("rpool@snap") | |
1216 | * | |
1217 | * To use keyword arguments functions should be called with a single argument | |
1218 | * that is a lua table containing mappings of integer -> positional arguments | |
1219 | * and string -> keyword arguments: | |
1220 | * | |
1221 | * zfs.sync.snapshot({1="rpool@snap", defer=true}) | |
1222 | * | |
1223 | * The lua language allows curly braces to be used in place of parenthesis as | |
1224 | * syntactic sugar for this calling convention: | |
1225 | * | |
1226 | * zfs.sync.snapshot{"rpool@snap", defer=true} | |
1227 | */ | |
1228 | ||
1229 | /* | |
1230 | * Throw an error and print the given arguments. If there are too many | |
1231 | * arguments to fit in the output buffer, only the error format string is | |
1232 | * output. | |
1233 | */ | |
1234 | static void | |
1235 | zcp_args_error(lua_State *state, const char *fname, const zcp_arg_t *pargs, | |
1236 | const zcp_arg_t *kwargs, const char *fmt, ...) | |
1237 | { | |
1238 | int i; | |
1239 | char errmsg[512]; | |
1240 | size_t len = sizeof (errmsg); | |
1241 | size_t msglen = 0; | |
1242 | va_list argp; | |
1243 | ||
1244 | va_start(argp, fmt); | |
1245 | VERIFY3U(len, >, vsnprintf(errmsg, len, fmt, argp)); | |
1246 | va_end(argp); | |
1247 | ||
1248 | /* | |
1249 | * Calculate the total length of the final string, including extra | |
1250 | * formatting characters. If the argument dump would be too large, | |
1251 | * only print the error string. | |
1252 | */ | |
1253 | msglen = strlen(errmsg); | |
1254 | msglen += strlen(fname) + 4; /* : + {} + null terminator */ | |
1255 | for (i = 0; pargs[i].za_name != NULL; i++) { | |
1256 | msglen += strlen(pargs[i].za_name); | |
1257 | msglen += strlen(lua_typename(state, pargs[i].za_lua_type)); | |
1258 | if (pargs[i + 1].za_name != NULL || kwargs[0].za_name != NULL) | |
1259 | msglen += 5; /* < + ( + )> + , */ | |
1260 | else | |
1261 | msglen += 4; /* < + ( + )> */ | |
1262 | } | |
1263 | for (i = 0; kwargs[i].za_name != NULL; i++) { | |
1264 | msglen += strlen(kwargs[i].za_name); | |
1265 | msglen += strlen(lua_typename(state, kwargs[i].za_lua_type)); | |
1266 | if (kwargs[i + 1].za_name != NULL) | |
1267 | msglen += 4; /* =( + ) + , */ | |
1268 | else | |
1269 | msglen += 3; /* =( + ) */ | |
1270 | } | |
1271 | ||
1272 | if (msglen >= len) | |
1273 | (void) luaL_error(state, errmsg); | |
1274 | ||
1275 | VERIFY3U(len, >, strlcat(errmsg, ": ", len)); | |
1276 | VERIFY3U(len, >, strlcat(errmsg, fname, len)); | |
1277 | VERIFY3U(len, >, strlcat(errmsg, "{", len)); | |
1278 | for (i = 0; pargs[i].za_name != NULL; i++) { | |
1279 | VERIFY3U(len, >, strlcat(errmsg, "<", len)); | |
1280 | VERIFY3U(len, >, strlcat(errmsg, pargs[i].za_name, len)); | |
1281 | VERIFY3U(len, >, strlcat(errmsg, "(", len)); | |
1282 | VERIFY3U(len, >, strlcat(errmsg, | |
1283 | lua_typename(state, pargs[i].za_lua_type), len)); | |
1284 | VERIFY3U(len, >, strlcat(errmsg, ")>", len)); | |
1285 | if (pargs[i + 1].za_name != NULL || kwargs[0].za_name != NULL) { | |
1286 | VERIFY3U(len, >, strlcat(errmsg, ", ", len)); | |
1287 | } | |
1288 | } | |
1289 | for (i = 0; kwargs[i].za_name != NULL; i++) { | |
1290 | VERIFY3U(len, >, strlcat(errmsg, kwargs[i].za_name, len)); | |
1291 | VERIFY3U(len, >, strlcat(errmsg, "=(", len)); | |
1292 | VERIFY3U(len, >, strlcat(errmsg, | |
1293 | lua_typename(state, kwargs[i].za_lua_type), len)); | |
1294 | VERIFY3U(len, >, strlcat(errmsg, ")", len)); | |
1295 | if (kwargs[i + 1].za_name != NULL) { | |
1296 | VERIFY3U(len, >, strlcat(errmsg, ", ", len)); | |
1297 | } | |
1298 | } | |
1299 | VERIFY3U(len, >, strlcat(errmsg, "}", len)); | |
1300 | ||
1301 | (void) luaL_error(state, errmsg); | |
1302 | panic("unreachable code"); | |
1303 | } | |
1304 | ||
1305 | static void | |
1306 | zcp_parse_table_args(lua_State *state, const char *fname, | |
1307 | const zcp_arg_t *pargs, const zcp_arg_t *kwargs) | |
1308 | { | |
1309 | int i; | |
1310 | int type; | |
1311 | ||
1312 | for (i = 0; pargs[i].za_name != NULL; i++) { | |
1313 | /* | |
1314 | * Check the table for this positional argument, leaving it | |
1315 | * on the top of the stack once we finish validating it. | |
1316 | */ | |
1317 | lua_pushinteger(state, i + 1); | |
1318 | lua_gettable(state, 1); | |
1319 | ||
1320 | type = lua_type(state, -1); | |
1321 | if (type == LUA_TNIL) { | |
1322 | zcp_args_error(state, fname, pargs, kwargs, | |
1323 | "too few arguments"); | |
1324 | panic("unreachable code"); | |
1325 | } else if (type != pargs[i].za_lua_type) { | |
1326 | zcp_args_error(state, fname, pargs, kwargs, | |
1327 | "arg %d wrong type (is '%s', expected '%s')", | |
1328 | i + 1, lua_typename(state, type), | |
1329 | lua_typename(state, pargs[i].za_lua_type)); | |
1330 | panic("unreachable code"); | |
1331 | } | |
1332 | ||
1333 | /* | |
1334 | * Remove the positional argument from the table. | |
1335 | */ | |
1336 | lua_pushinteger(state, i + 1); | |
1337 | lua_pushnil(state); | |
1338 | lua_settable(state, 1); | |
1339 | } | |
1340 | ||
1341 | for (i = 0; kwargs[i].za_name != NULL; i++) { | |
1342 | /* | |
1343 | * Check the table for this keyword argument, which may be | |
1344 | * nil if it was omitted. Leave the value on the top of | |
1345 | * the stack after validating it. | |
1346 | */ | |
1347 | lua_getfield(state, 1, kwargs[i].za_name); | |
1348 | ||
1349 | type = lua_type(state, -1); | |
1350 | if (type != LUA_TNIL && type != kwargs[i].za_lua_type) { | |
1351 | zcp_args_error(state, fname, pargs, kwargs, | |
1352 | "kwarg '%s' wrong type (is '%s', expected '%s')", | |
1353 | kwargs[i].za_name, lua_typename(state, type), | |
1354 | lua_typename(state, kwargs[i].za_lua_type)); | |
1355 | panic("unreachable code"); | |
1356 | } | |
1357 | ||
1358 | /* | |
1359 | * Remove the keyword argument from the table. | |
1360 | */ | |
1361 | lua_pushnil(state); | |
1362 | lua_setfield(state, 1, kwargs[i].za_name); | |
1363 | } | |
1364 | ||
1365 | /* | |
1366 | * Any entries remaining in the table are invalid inputs, print | |
1367 | * an error message based on what the entry is. | |
1368 | */ | |
1369 | lua_pushnil(state); | |
1370 | if (lua_next(state, 1)) { | |
1371 | if (lua_isnumber(state, -2) && lua_tointeger(state, -2) > 0) { | |
1372 | zcp_args_error(state, fname, pargs, kwargs, | |
1373 | "too many positional arguments"); | |
1374 | } else if (lua_isstring(state, -2)) { | |
1375 | zcp_args_error(state, fname, pargs, kwargs, | |
1376 | "invalid kwarg '%s'", lua_tostring(state, -2)); | |
1377 | } else { | |
1378 | zcp_args_error(state, fname, pargs, kwargs, | |
1379 | "kwarg keys must be strings"); | |
1380 | } | |
1381 | panic("unreachable code"); | |
1382 | } | |
1383 | ||
1384 | lua_remove(state, 1); | |
1385 | } | |
1386 | ||
1387 | static void | |
1388 | zcp_parse_pos_args(lua_State *state, const char *fname, const zcp_arg_t *pargs, | |
1389 | const zcp_arg_t *kwargs) | |
1390 | { | |
1391 | int i; | |
1392 | int type; | |
1393 | ||
1394 | for (i = 0; pargs[i].za_name != NULL; i++) { | |
1395 | type = lua_type(state, i + 1); | |
1396 | if (type == LUA_TNONE) { | |
1397 | zcp_args_error(state, fname, pargs, kwargs, | |
1398 | "too few arguments"); | |
1399 | panic("unreachable code"); | |
1400 | } else if (type != pargs[i].za_lua_type) { | |
1401 | zcp_args_error(state, fname, pargs, kwargs, | |
1402 | "arg %d wrong type (is '%s', expected '%s')", | |
1403 | i + 1, lua_typename(state, type), | |
1404 | lua_typename(state, pargs[i].za_lua_type)); | |
1405 | panic("unreachable code"); | |
1406 | } | |
1407 | } | |
1408 | if (lua_gettop(state) != i) { | |
1409 | zcp_args_error(state, fname, pargs, kwargs, | |
1410 | "too many positional arguments"); | |
1411 | panic("unreachable code"); | |
1412 | } | |
1413 | ||
1414 | for (i = 0; kwargs[i].za_name != NULL; i++) { | |
1415 | lua_pushnil(state); | |
1416 | } | |
1417 | } | |
1418 | ||
1419 | /* | |
1420 | * Checks the current Lua stack against an expected set of positional and | |
1421 | * keyword arguments. If the stack does not match the expected arguments | |
1422 | * aborts the current channel program with a useful error message, otherwise | |
1423 | * it re-arranges the stack so that it contains the positional arguments | |
1424 | * followed by the keyword argument values in declaration order. Any missing | |
1425 | * keyword argument will be represented by a nil value on the stack. | |
1426 | * | |
1427 | * If the stack contains exactly one argument of type LUA_TTABLE the curly | |
1428 | * braces calling convention is assumed, otherwise the stack is parsed for | |
1429 | * positional arguments only. | |
1430 | * | |
1431 | * This function should be used by every function callback. It should be called | |
1432 | * before the callback manipulates the Lua stack as it assumes the stack | |
1433 | * represents the function arguments. | |
1434 | */ | |
1435 | void | |
1436 | zcp_parse_args(lua_State *state, const char *fname, const zcp_arg_t *pargs, | |
1437 | const zcp_arg_t *kwargs) | |
1438 | { | |
1439 | if (lua_gettop(state) == 1 && lua_istable(state, 1)) { | |
1440 | zcp_parse_table_args(state, fname, pargs, kwargs); | |
1441 | } else { | |
1442 | zcp_parse_pos_args(state, fname, pargs, kwargs); | |
1443 | } | |
1444 | } | |
917f475f | 1445 | |
917f475f | 1446 | /* BEGIN CSTYLED */ |
03fdcb9a | 1447 | ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_instrlimit, ULONG, ZMOD_RW, |
917f475f JG |
1448 | "Max instruction limit that can be specified for a channel program"); |
1449 | ||
03fdcb9a | 1450 | ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_memlimit, ULONG, ZMOD_RW, |
917f475f JG |
1451 | "Max memory limit that can be specified for a channel program"); |
1452 | /* END CSTYLED */ |