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#include <sys/lua/lua.h> 21#include <sys/lua/lauxlib.h> 22 23#include <sys/dmu.h> 24#include <sys/dsl_prop.h> 25#include <sys/dsl_synctask.h> 26#include <sys/dsl_bookmark.h> 27#include <sys/dsl_dataset.h> 28#include <sys/dsl_pool.h> 29#include <sys/dmu_tx.h> 30#include <sys/dmu_objset.h> 31#include <sys/zap.h> 32#include <sys/dsl_dir.h> 33#include <sys/zcp_prop.h> 34 35#include <sys/zcp.h> 36 37#include "zfs_comutil.h" 38 39typedef int (zcp_list_func_t)(lua_State *); 40typedef struct zcp_list_info { 41 const char *name; 42 zcp_list_func_t *func; 43 zcp_list_func_t *gc; 44 const zcp_arg_t pargs[4]; 45 const zcp_arg_t kwargs[2]; 46} zcp_list_info_t; 47 48static int 49zcp_clones_iter(lua_State *state) 50{ 51 int err; 52 char clonename[ZFS_MAX_DATASET_NAME_LEN]; 53 uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1)); 54 uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); 55 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 56 dsl_dataset_t *ds, *clone; 57 zap_attribute_t za; 58 zap_cursor_t zc; 59 60 err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 61 if (err == ENOENT) { 62 return (0); 63 } else if (err != 0) { 64 return (luaL_error(state, 65 "unexpected error %d from dsl_dataset_hold_obj(dsobj)", 66 err)); 67 } 68 69 if (dsl_dataset_phys(ds)->ds_next_clones_obj == 0) { 70 dsl_dataset_rele(ds, FTAG); 71 return (0); 72 } 73 74 zap_cursor_init_serialized(&zc, dp->dp_meta_objset, 75 dsl_dataset_phys(ds)->ds_next_clones_obj, cursor); 76 dsl_dataset_rele(ds, FTAG); 77 78 err = zap_cursor_retrieve(&zc, &za); 79 if (err != 0) { 80 zap_cursor_fini(&zc); 81 if (err != ENOENT) { 82 return (luaL_error(state, 83 "unexpected error %d from zap_cursor_retrieve()", 84 err)); 85 } 86 return (0); 87 } 88 zap_cursor_advance(&zc); 89 cursor = zap_cursor_serialize(&zc); 90 zap_cursor_fini(&zc); 91 92 err = dsl_dataset_hold_obj(dp, za.za_first_integer, FTAG, &clone); 93 if (err != 0) { 94 return (luaL_error(state, 95 "unexpected error %d from " 96 "dsl_dataset_hold_obj(za_first_integer)", err)); 97 } 98 99 dsl_dir_name(clone->ds_dir, clonename); 100 dsl_dataset_rele(clone, FTAG); 101 102 lua_pushnumber(state, cursor); 103 lua_replace(state, lua_upvalueindex(2)); 104 105 (void) lua_pushstring(state, clonename); 106 return (1); 107} 108 109static int zcp_clones_list(lua_State *); 110static const zcp_list_info_t zcp_clones_list_info = { 111 .name = "clones", 112 .func = zcp_clones_list, 113 .gc = NULL, 114 .pargs = { 115 { .za_name = "snapshot", .za_lua_type = LUA_TSTRING }, 116 {NULL, 0} 117 }, 118 .kwargs = { 119 {NULL, 0} 120 } 121}; 122 123static int 124zcp_clones_list(lua_State *state) 125{ 126 const char *snapname = lua_tostring(state, 1); 127 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 128 129 /* 130 * zcp_dataset_hold will either successfully return the requested 131 * dataset or throw a lua error and longjmp out of the zfs.list.clones 132 * call without returning. 133 */ 134 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, snapname, FTAG); 135 if (ds == NULL) 136 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 137 boolean_t issnap = ds->ds_is_snapshot; 138 uint64_t cursor = 0; 139 uint64_t dsobj = ds->ds_object; 140 dsl_dataset_rele(ds, FTAG); 141 142 if (!issnap) { 143 return (zcp_argerror(state, 1, "%s is not a snapshot", 144 snapname)); 145 } 146 147 lua_pushnumber(state, dsobj); 148 lua_pushnumber(state, cursor); 149 lua_pushcclosure(state, &zcp_clones_iter, 2); 150 return (1); 151} 152 153static int 154zcp_snapshots_iter(lua_State *state) 155{ 156 int err; 157 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 158 uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1)); 159 uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); 160 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 161 dsl_dataset_t *ds; 162 objset_t *os; 163 char *p; 164 165 err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 166 if (err != 0) { 167 return (luaL_error(state, 168 "unexpected error %d from dsl_dataset_hold_obj(dsobj)", 169 err)); 170 } 171 172 dsl_dataset_name(ds, snapname); 173 VERIFY3U(sizeof (snapname), >, 174 strlcat(snapname, "@", sizeof (snapname))); 175 176 p = strchr(snapname, '\0'); 177 VERIFY0(dmu_objset_from_ds(ds, &os)); 178 err = dmu_snapshot_list_next(os, 179 sizeof (snapname) - (p - snapname), p, NULL, &cursor, NULL); 180 dsl_dataset_rele(ds, FTAG); 181 182 if (err == ENOENT) { 183 return (0); 184 } else if (err != 0) { 185 return (luaL_error(state, 186 "unexpected error %d from dmu_snapshot_list_next()", err)); 187 } 188 189 lua_pushnumber(state, cursor); 190 lua_replace(state, lua_upvalueindex(2)); 191 192 (void) lua_pushstring(state, snapname); 193 return (1); 194} 195 196static int zcp_snapshots_list(lua_State *); 197static const zcp_list_info_t zcp_snapshots_list_info = { 198 .name = "snapshots", 199 .func = zcp_snapshots_list, 200 .gc = NULL, 201 .pargs = { 202 { .za_name = "filesystem | volume", .za_lua_type = LUA_TSTRING }, 203 {NULL, 0} 204 }, 205 .kwargs = { 206 {NULL, 0} 207 } 208}; 209 210static int 211zcp_snapshots_list(lua_State *state) 212{ 213 const char *fsname = lua_tostring(state, 1); 214 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 215 boolean_t issnap; 216 uint64_t dsobj; 217 218 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, fsname, FTAG); 219 if (ds == NULL) 220 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 221 issnap = ds->ds_is_snapshot; 222 dsobj = ds->ds_object; 223 dsl_dataset_rele(ds, FTAG); 224 225 if (issnap) { 226 return (zcp_argerror(state, 1, 227 "argument %s cannot be a snapshot", fsname)); 228 } 229 230 lua_pushnumber(state, dsobj); 231 lua_pushnumber(state, 0); 232 lua_pushcclosure(state, &zcp_snapshots_iter, 2); 233 return (1); 234} 235 236static int 237zcp_children_iter(lua_State *state) 238{ 239 int err; 240 char childname[ZFS_MAX_DATASET_NAME_LEN]; 241 uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1)); 242 uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); 243 zcp_run_info_t *ri = zcp_run_info(state); 244 dsl_pool_t *dp = ri->zri_pool; 245 dsl_dataset_t *ds; 246 objset_t *os; 247 char *p; 248 249 err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 250 if (err != 0) { 251 return (luaL_error(state, 252 "unexpected error %d from dsl_dataset_hold_obj(dsobj)", 253 err)); 254 } 255 256 dsl_dataset_name(ds, childname); 257 VERIFY3U(sizeof (childname), >, 258 strlcat(childname, "/", sizeof (childname))); 259 p = strchr(childname, '\0'); 260 261 VERIFY0(dmu_objset_from_ds(ds, &os)); 262 do { 263 err = dmu_dir_list_next(os, 264 sizeof (childname) - (p - childname), p, NULL, &cursor); 265 } while (err == 0 && zfs_dataset_name_hidden(childname)); 266 dsl_dataset_rele(ds, FTAG); 267 268 if (err == ENOENT) { 269 return (0); 270 } else if (err != 0) { 271 return (luaL_error(state, 272 "unexpected error %d from dmu_dir_list_next()", 273 err)); 274 } 275 276 lua_pushnumber(state, cursor); 277 lua_replace(state, lua_upvalueindex(2)); 278 279 (void) lua_pushstring(state, childname); 280 return (1); 281} 282 283static int zcp_children_list(lua_State *); 284static const zcp_list_info_t zcp_children_list_info = { 285 .name = "children", 286 .func = zcp_children_list, 287 .gc = NULL, 288 .pargs = { 289 { .za_name = "filesystem | volume", .za_lua_type = LUA_TSTRING }, 290 {NULL, 0} 291 }, 292 .kwargs = { 293 {NULL, 0} 294 } 295}; 296 297static int 298zcp_children_list(lua_State *state) 299{ 300 const char *fsname = lua_tostring(state, 1); 301 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 302 boolean_t issnap; 303 uint64_t dsobj; 304 305 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, fsname, FTAG); 306 if (ds == NULL) 307 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 308 309 issnap = ds->ds_is_snapshot; 310 dsobj = ds->ds_object; 311 dsl_dataset_rele(ds, FTAG); 312 313 if (issnap) { 314 return (zcp_argerror(state, 1, 315 "argument %s cannot be a snapshot", fsname)); 316 } 317 318 lua_pushnumber(state, dsobj); 319 lua_pushnumber(state, 0); 320 lua_pushcclosure(state, &zcp_children_iter, 2); 321 return (1); 322} 323 324static int 325zcp_user_props_list_gc(lua_State *state) 326{ 327 nvlist_t **props = lua_touserdata(state, 1); 328 if (*props != NULL) 329 fnvlist_free(*props); 330 return (0); 331} 332 333static int 334zcp_user_props_iter(lua_State *state) 335{ 336 const char *source, *val; 337 nvlist_t *nvprop; 338 nvlist_t **props = lua_touserdata(state, lua_upvalueindex(1)); 339 nvpair_t *pair = lua_touserdata(state, lua_upvalueindex(2)); 340 341 do { 342 pair = nvlist_next_nvpair(*props, pair); 343 if (pair == NULL) { 344 fnvlist_free(*props); 345 *props = NULL; 346 return (0); 347 } 348 } while (!zfs_prop_user(nvpair_name(pair))); 349 350 lua_pushlightuserdata(state, pair); 351 lua_replace(state, lua_upvalueindex(2)); 352 353 nvprop = fnvpair_value_nvlist(pair); 354 val = fnvlist_lookup_string(nvprop, ZPROP_VALUE); 355 source = fnvlist_lookup_string(nvprop, ZPROP_SOURCE); 356 357 (void) lua_pushstring(state, nvpair_name(pair)); 358 (void) lua_pushstring(state, val); 359 (void) lua_pushstring(state, source); 360 return (3); 361} 362 363static int zcp_user_props_list(lua_State *); 364static const zcp_list_info_t zcp_user_props_list_info = { 365 .name = "user_properties", 366 .func = zcp_user_props_list, 367 .gc = zcp_user_props_list_gc, 368 .pargs = { 369 { .za_name = "filesystem | snapshot | volume", 370 .za_lua_type = LUA_TSTRING }, 371 {NULL, 0} 372 }, 373 .kwargs = { 374 {NULL, 0} 375 } 376}; 377 378/* 379 * 'properties' was the initial name for 'user_properties' seen 380 * above. 'user_properties' is a better name as it distinguishes 381 * these properties from 'system_properties' which are different. 382 * In order to avoid breaking compatibility between different 383 * versions of ZFS, we declare 'properties' as an alias for 384 * 'user_properties'. 385 */ 386static const zcp_list_info_t zcp_props_list_info = { 387 .name = "properties", 388 .func = zcp_user_props_list, 389 .gc = zcp_user_props_list_gc, 390 .pargs = { 391 { .za_name = "filesystem | snapshot | volume", 392 .za_lua_type = LUA_TSTRING }, 393 {NULL, 0} 394 }, 395 .kwargs = { 396 {NULL, 0} 397 } 398}; 399 400static int 401zcp_user_props_list(lua_State *state) 402{ 403 const char *dsname = lua_tostring(state, 1); 404 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 405 objset_t *os; 406 nvlist_t **props = lua_newuserdata(state, sizeof (nvlist_t *)); 407 408 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dsname, FTAG); 409 if (ds == NULL) 410 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 411 VERIFY0(dmu_objset_from_ds(ds, &os)); 412 VERIFY0(dsl_prop_get_all(os, props)); 413 dsl_dataset_rele(ds, FTAG); 414 415 /* 416 * Set the metatable for the properties list to free it on 417 * completion. 418 */ 419 luaL_getmetatable(state, zcp_user_props_list_info.name); 420 (void) lua_setmetatable(state, -2); 421 422 lua_pushlightuserdata(state, NULL); 423 lua_pushcclosure(state, &zcp_user_props_iter, 2); 424 return (1); 425} 426 427 428/* 429 * Populate nv with all valid system properties and their values for the given 430 * dataset. 431 */ 432static void 433zcp_dataset_system_props(dsl_dataset_t *ds, nvlist_t *nv) 434{ 435 for (int prop = ZFS_PROP_TYPE; prop < ZFS_NUM_PROPS; prop++) { 436 /* Do not display hidden props */ 437 if (!zfs_prop_visible(prop)) 438 continue; 439 /* Do not display props not valid for this dataset */ 440 if (!prop_valid_for_ds(ds, prop)) 441 continue; 442 fnvlist_add_boolean(nv, zfs_prop_to_name(prop)); 443 } 444} 445 446static int zcp_system_props_list(lua_State *); 447static const zcp_list_info_t zcp_system_props_list_info = { 448 .name = "system_properties", 449 .func = zcp_system_props_list, 450 .pargs = { 451 { .za_name = "dataset", .za_lua_type = LUA_TSTRING }, 452 {NULL, 0} 453 }, 454 .kwargs = { 455 {NULL, 0} 456 } 457}; 458 459/* 460 * Get a list of all visible system properties and their values for a given 461 * dataset. Returned on the stack as a Lua table. 462 */ 463static int 464zcp_system_props_list(lua_State *state) 465{ 466 int error; 467 char errbuf[128]; 468 const char *dataset_name; 469 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 470 const zcp_list_info_t *libinfo = &zcp_system_props_list_info; 471 zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs); 472 dataset_name = lua_tostring(state, 1); 473 nvlist_t *nv = fnvlist_alloc(); 474 475 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dataset_name, FTAG); 476 if (ds == NULL) 477 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 478 479 /* Get the names of all valid system properties for this dataset */ 480 zcp_dataset_system_props(ds, nv); 481 dsl_dataset_rele(ds, FTAG); 482 483 /* push list as lua table */ 484 error = zcp_nvlist_to_lua(state, nv, errbuf, sizeof (errbuf)); 485 nvlist_free(nv); 486 if (error != 0) { 487 return (luaL_error(state, 488 "Error returning nvlist: %s", errbuf)); 489 } 490 return (1); 491} 492 493static int 494zcp_bookmarks_iter(lua_State *state) 495{ 496 char ds_name[ZFS_MAX_DATASET_NAME_LEN]; 497 char bookmark_name[ZFS_MAX_DATASET_NAME_LEN]; 498 uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1)); 499 uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); 500 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 501 dsl_dataset_t *ds; 502 zap_attribute_t za; 503 zap_cursor_t zc; 504 505 int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 506 if (err == ENOENT) { 507 return (0); 508 } else if (err != 0) { 509 return (luaL_error(state, 510 "unexpected error %d from dsl_dataset_hold_obj(dsobj)", 511 err)); 512 } 513 514 if (!dsl_dataset_is_zapified(ds)) { 515 dsl_dataset_rele(ds, FTAG); 516 return (0); 517 } 518 519 err = zap_lookup(dp->dp_meta_objset, ds->ds_object, 520 DS_FIELD_BOOKMARK_NAMES, sizeof (ds->ds_bookmarks_obj), 1, 521 &ds->ds_bookmarks_obj); 522 if (err != 0 && err != ENOENT) { 523 dsl_dataset_rele(ds, FTAG); 524 return (luaL_error(state, 525 "unexpected error %d from zap_lookup()", err)); 526 } 527 if (ds->ds_bookmarks_obj == 0) { 528 dsl_dataset_rele(ds, FTAG); 529 return (0); 530 } 531 532 /* Store the dataset's name so we can append the bookmark's name */ 533 dsl_dataset_name(ds, ds_name); 534 535 zap_cursor_init_serialized(&zc, ds->ds_dir->dd_pool->dp_meta_objset, 536 ds->ds_bookmarks_obj, cursor); 537 dsl_dataset_rele(ds, FTAG); 538 539 err = zap_cursor_retrieve(&zc, &za); 540 if (err != 0) { 541 zap_cursor_fini(&zc); 542 if (err != ENOENT) { 543 return (luaL_error(state, 544 "unexpected error %d from zap_cursor_retrieve()", 545 err)); 546 } 547 return (0); 548 } 549 zap_cursor_advance(&zc); 550 cursor = zap_cursor_serialize(&zc); 551 zap_cursor_fini(&zc); 552 553 /* Create the full "pool/fs#bookmark" string to return */ 554 int n = snprintf(bookmark_name, ZFS_MAX_DATASET_NAME_LEN, "%s#%s", 555 ds_name, za.za_name); 556 if (n >= ZFS_MAX_DATASET_NAME_LEN) { 557 return (luaL_error(state, 558 "unexpected error %d from snprintf()", ENAMETOOLONG)); 559 } 560 561 lua_pushnumber(state, cursor); 562 lua_replace(state, lua_upvalueindex(2)); 563 564 (void) lua_pushstring(state, bookmark_name); 565 return (1); 566} 567 568static int zcp_bookmarks_list(lua_State *); 569static const zcp_list_info_t zcp_bookmarks_list_info = { 570 .name = "bookmarks", 571 .func = zcp_bookmarks_list, 572 .pargs = { 573 { .za_name = "dataset", .za_lua_type = LUA_TSTRING }, 574 {NULL, 0} 575 }, 576 .kwargs = { 577 {NULL, 0} 578 } 579}; 580 581static int 582zcp_bookmarks_list(lua_State *state) 583{ 584 const char *dsname = lua_tostring(state, 1); 585 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 586 587 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dsname, FTAG); 588 if (ds == NULL) 589 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 590 591 boolean_t issnap = ds->ds_is_snapshot; 592 uint64_t dsobj = ds->ds_object; 593 uint64_t cursor = 0; 594 dsl_dataset_rele(ds, FTAG); 595 596 if (issnap) { 597 return (zcp_argerror(state, 1, "%s is a snapshot", dsname)); 598 } 599 600 lua_pushnumber(state, dsobj); 601 lua_pushnumber(state, cursor); 602 lua_pushcclosure(state, &zcp_bookmarks_iter, 2); 603 return (1); 604} 605 606static int 607zcp_holds_iter(lua_State *state) 608{ 609 uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1)); 610 uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); 611 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 612 dsl_dataset_t *ds; 613 zap_attribute_t za; 614 zap_cursor_t zc; 615 616 int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 617 if (err == ENOENT) { 618 return (0); 619 } else if (err != 0) { 620 return (luaL_error(state, 621 "unexpected error %d from dsl_dataset_hold_obj(dsobj)", 622 err)); 623 } 624 625 if (dsl_dataset_phys(ds)->ds_userrefs_obj == 0) { 626 dsl_dataset_rele(ds, FTAG); 627 return (0); 628 } 629 630 zap_cursor_init_serialized(&zc, ds->ds_dir->dd_pool->dp_meta_objset, 631 dsl_dataset_phys(ds)->ds_userrefs_obj, cursor); 632 dsl_dataset_rele(ds, FTAG); 633 634 err = zap_cursor_retrieve(&zc, &za); 635 if (err != 0) { 636 zap_cursor_fini(&zc); 637 if (err != ENOENT) { 638 return (luaL_error(state, 639 "unexpected error %d from zap_cursor_retrieve()", 640 err)); 641 } 642 return (0); 643 } 644 zap_cursor_advance(&zc); 645 cursor = zap_cursor_serialize(&zc); 646 zap_cursor_fini(&zc); 647 648 lua_pushnumber(state, cursor); 649 lua_replace(state, lua_upvalueindex(2)); 650 651 (void) lua_pushstring(state, za.za_name); 652 (void) lua_pushnumber(state, za.za_first_integer); 653 return (2); 654} 655 656static int zcp_holds_list(lua_State *); 657static const zcp_list_info_t zcp_holds_list_info = { 658 .name = "holds", 659 .func = zcp_holds_list, 660 .gc = NULL, 661 .pargs = { 662 { .za_name = "snapshot", .za_lua_type = LUA_TSTRING }, 663 {NULL, 0} 664 }, 665 .kwargs = { 666 {NULL, 0} 667 } 668}; 669 670/* 671 * Iterate over all the holds for a given dataset. Each iteration returns 672 * a hold's tag and its timestamp as an integer. 673 */ 674static int 675zcp_holds_list(lua_State *state) 676{ 677 const char *snapname = lua_tostring(state, 1); 678 dsl_pool_t *dp = zcp_run_info(state)->zri_pool; 679 680 dsl_dataset_t *ds = zcp_dataset_hold(state, dp, snapname, FTAG); 681 if (ds == NULL) 682 return (1); /* not reached; zcp_dataset_hold() longjmp'd */ 683 684 boolean_t issnap = ds->ds_is_snapshot; 685 uint64_t dsobj = ds->ds_object; 686 uint64_t cursor = 0; 687 dsl_dataset_rele(ds, FTAG); 688 689 if (!issnap) { 690 return (zcp_argerror(state, 1, "%s is not a snapshot", 691 snapname)); 692 } 693 694 lua_pushnumber(state, dsobj); 695 lua_pushnumber(state, cursor); 696 lua_pushcclosure(state, &zcp_holds_iter, 2); 697 return (1); 698} 699 700static int 701zcp_list_func(lua_State *state) 702{ 703 zcp_list_info_t *info = lua_touserdata(state, lua_upvalueindex(1)); 704 705 zcp_parse_args(state, info->name, info->pargs, info->kwargs); 706 707 return (info->func(state)); 708} 709 710int 711zcp_load_list_lib(lua_State *state) 712{ 713 const zcp_list_info_t *zcp_list_funcs[] = { 714 &zcp_children_list_info, 715 &zcp_snapshots_list_info, 716 &zcp_user_props_list_info, 717 &zcp_props_list_info, 718 &zcp_clones_list_info, 719 &zcp_system_props_list_info, 720 &zcp_bookmarks_list_info, 721 &zcp_holds_list_info, 722 NULL 723 }; 724 725 lua_newtable(state); 726 727 for (int i = 0; zcp_list_funcs[i] != NULL; i++) { 728 const zcp_list_info_t *info = zcp_list_funcs[i]; 729 730 if (info->gc != NULL) { 731 /* 732 * If the function requires garbage collection, create 733 * a metatable with its name and register the __gc 734 * function. 735 */ 736 (void) luaL_newmetatable(state, info->name); 737 (void) lua_pushstring(state, "__gc"); 738 lua_pushcfunction(state, info->gc); 739 lua_settable(state, -3); 740 lua_pop(state, 1); 741 } 742 743 lua_pushlightuserdata(state, (void *)(uintptr_t)info); 744 lua_pushcclosure(state, &zcp_list_func, 1); 745 lua_setfield(state, -2, info->name); 746 } 747 748 return (1); 749} 750