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, 2018 by Delphix. All rights reserved. 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 69 * any changes made by the channel program before the error occurred. 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 80 * error occurred. 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> 103 #include <sys/zvol.h> 104 105 #ifndef KM_NORMALPRI 106 #define KM_NORMALPRI 0 107 #endif 108 109 #define ZCP_NVLIST_MAX_DEPTH 20 110 111 static const uint64_t zfs_lua_check_instrlimit_interval = 100; 112 uint64_t zfs_lua_max_instrlimit = ZCP_MAX_INSTRLIMIT; 113 uint64_t zfs_lua_max_memlimit = ZCP_MAX_MEMLIMIT; 114 115 /* 116 * Forward declarations for mutually recursive functions 117 */ 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 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 164 * then unregistered. 165 * 166 * Returns the registered cleanup handler so the caller can deregister it 167 * if no error occurs. 168 */ 169 zcp_cleanup_handler_t * 170 zcp_register_cleanup(lua_State *state, zcp_cleanup_t cleanfunc, void *cleanarg) 171 { 172 zcp_run_info_t *ri = zcp_run_info(state); 173 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); 180 } 181 182 void 183 zcp_deregister_cleanup(lua_State *state, zcp_cleanup_handler_t *zch) 184 { 185 zcp_run_info_t *ri = zcp_run_info(state); 186 list_remove(&ri->zri_cleanup_handlers, zch); 187 kmem_free(zch, sizeof (*zch)); 188 } 189 190 /* 191 * Execute the currently registered cleanup handlers then free them and 192 * destroy the handler list. 193 */ 194 void 195 zcp_cleanup(lua_State *state) 196 { 197 zcp_run_info_t *ri = zcp_run_info(state); 198 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)); 204 } 205 } 206 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 (void) snprintf(buf, sizeof (buf), "%lld", 281 (longlong_t)lua_tonumber(state, -2)); 282 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) 399 return (SET_ERROR(EINVAL)); 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); 409 return (SET_ERROR(EINVAL)); 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 */ 418 static void 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 430 static int 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 439 static void 440 zcp_convert_return_values(lua_State *state, nvlist_t *nvl, 441 const char *key, int *result) 442 { 443 int err; 444 VERIFY3U(1, ==, lua_gettop(state)); 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); 453 *result = SET_ERROR(ECHRNG); 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 } 588 return (SET_ERROR(EINVAL)); 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 const 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 *); 634 static const zcp_lib_info_t zcp_debug_info = { 635 .name = "debug", 636 .func = zcp_debug, 637 .pargs = { 638 { .za_name = "debug string", .za_lua_type = LUA_TSTRING }, 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); 651 const zcp_lib_info_t *libinfo = &zcp_debug_info; 652 653 zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs); 654 655 dbgstring = lua_tostring(state, 1); 656 657 zfs_dbgmsg("txg %lld ZCP: %s", (longlong_t)ri->zri_tx->tx_txg, 658 dbgstring); 659 660 return (0); 661 } 662 663 static int zcp_exists(lua_State *); 664 static const zcp_lib_info_t zcp_exists_info = { 665 .name = "exists", 666 .func = zcp_exists, 667 .pargs = { 668 { .za_name = "dataset", .za_lua_type = LUA_TSTRING }, 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; 681 const zcp_lib_info_t *libinfo = &zcp_exists_info; 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 704 return (1); 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; 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 748 allocbuf = vmem_alloc(allocsize, KM_SLEEP); 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 772 static void 773 zcp_lua_counthook(lua_State *state, lua_Debug *ar) 774 { 775 (void) ar; 776 lua_getfield(state, LUA_REGISTRYINDEX, ZCP_RUN_INFO_KEY); 777 zcp_run_info_t *ri = lua_touserdata(state, -1); 778 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 */ 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); 801 /* Unreachable */ 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 814 zcp_eval_impl(dmu_tx_t *tx, zcp_run_info_t *ri) 815 { 816 int err; 817 lua_State *state = ri->zri_state; 818 819 VERIFY3U(3, ==, lua_gettop(state)); 820 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 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 */ 832 lua_pushlightuserdata(state, ri); 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 */ 849 ri->zri_allocargs->aa_must_succeed = B_FALSE; 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 */ 861 ri->zri_allocargs->aa_must_succeed = B_TRUE; 862 863 /* 864 * Remove the error handler callback from the stack. At this point, 865 * there shouldn't be any cleanup handler registered in the handler 866 * list (zri_cleanup_handlers), regardless of whether it ran or not. 867 */ 868 list_destroy(&ri->zri_cleanup_handlers); 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) { 888 ri->zri_result = 0; 889 zcp_convert_return_values(state, ri->zri_outnvl, 890 ZCP_RET_RETURN, &ri->zri_result); 891 } else if (return_count > 1) { 892 ri->zri_result = SET_ERROR(ECHRNG); 893 lua_settop(state, 0); 894 (void) lua_pushfstring(state, "Multiple return " 895 "values not supported"); 896 zcp_convert_return_values(state, ri->zri_outnvl, 897 ZCP_RET_ERROR, &ri->zri_result); 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)); 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); 915 } else { 916 ri->zri_result = SET_ERROR(ECHRNG); 917 } 918 919 zcp_convert_return_values(state, ri->zri_outnvl, 920 ZCP_RET_ERROR, &ri->zri_result); 921 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); 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)); 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); 940 } else { 941 ri->zri_result = SET_ERROR(ECHRNG); 942 } 943 944 zcp_convert_return_values(state, ri->zri_outnvl, 945 ZCP_RET_ERROR, &ri->zri_result); 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 */ 953 ri->zri_result = SET_ERROR(ENOSPC); 954 break; 955 default: 956 VERIFY0(err); 957 } 958 } 959 960 static void 961 zcp_pool_error(zcp_run_info_t *ri, const char *poolname, int error) 962 { 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 " 966 "errno: %d", poolname, error); 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 */ 977 static void 978 zcp_eval_sig(void *arg, dmu_tx_t *tx) 979 { 980 (void) tx; 981 zcp_run_info_t *ri = arg; 982 983 ri->zri_canceled = B_TRUE; 984 } 985 986 static void 987 zcp_eval_sync(void *arg, dmu_tx_t *tx) 988 { 989 zcp_run_info_t *ri = arg; 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 */ 997 VERIFY3U(3, ==, lua_gettop(ri->zri_state)); 998 999 zcp_eval_impl(tx, ri); 1000 } 1001 1002 static void 1003 zcp_eval_open(zcp_run_info_t *ri, const char *poolname) 1004 { 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 */ 1012 VERIFY3U(3, ==, lua_gettop(ri->zri_state)); 1013 1014 error = dsl_pool_hold(poolname, FTAG, &dp); 1015 if (error != 0) { 1016 zcp_pool_error(ri, poolname, error); 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 1031 zcp_eval_impl(tx, ri); 1032 1033 dmu_tx_abort(tx); 1034 1035 dsl_pool_rele(dp, FTAG); 1036 } 1037 1038 int 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) 1041 { 1042 int err; 1043 lua_State *state; 1044 zcp_run_info_t runinfo; 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 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(); 1149 runinfo.zri_proc = curproc; 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; 1156 runinfo.zri_new_zvols = fnvlist_alloc(); 1157 1158 if (sync) { 1159 err = dsl_sync_task_sig(poolname, NULL, zcp_eval_sync, 1160 zcp_eval_sig, &runinfo, 0, ZFS_SPACE_CHECK_ZCP_EVAL); 1161 if (err != 0) 1162 zcp_pool_error(&runinfo, poolname, err); 1163 } else { 1164 zcp_eval_open(&runinfo, poolname); 1165 } 1166 lua_close(state); 1167 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 1178 return (runinfo.zri_result); 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 } 1445 1446 ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_instrlimit, U64, ZMOD_RW, 1447 "Max instruction limit that can be specified for a channel program"); 1448 1449 ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_memlimit, U64, ZMOD_RW, 1450 "Max memory limit that can be specified for a channel program"); 1451