zcp_iter.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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         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 }
Cache object: 1114571393126ce6991499e58e52823f
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/openzfs/module/zfs/zcp_iter.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/module/zfs/zcp_iter.c
