module/zfs/zcp_iter.c

   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
  39 typedef int (zcp_list_func_t)(lua_State *);
  40 typedef 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
  48 static int
  49 zcp_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
 109 static int zcp_clones_list(lua_State *);
 110 static 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
 123 static int
 124 zcp_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
 153 static int
 154 zcp_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
 196 static int zcp_snapshots_list(lua_State *);
 197 static 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
 210 static int
 211 zcp_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
 236 static int
 237 zcp_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
 283 static int zcp_children_list(lua_State *);
 284 static 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
 297 static int
 298 zcp_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
 324 static int
 325 zcp_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
 333 static int
 334 zcp_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
 363 static int zcp_user_props_list(lua_State *);
 364 static 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  */
 386 static 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
 400 static int
 401 zcp_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  */
 432 static void
 433 zcp_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
 446 static int zcp_system_props_list(lua_State *);
 447 static 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  */
 463 static int
 464 zcp_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
 493 static int
 494 zcp_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
 568 static int zcp_bookmarks_list(lua_State *);
 569 static 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
 581 static int
 582 zcp_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
 606 static int
 607 zcp_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
 656 static int zcp_holds_list(lua_State *);
 657 static 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  */
 674 static int
 675 zcp_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
 700 static int
 701 zcp_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
 710 int
 711 zcp_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 }