zcp_get.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 by Delphix. All rights reserved.
   18  */
   19 
   20 #include <sys/lua/lua.h>
   21 #include <sys/lua/lualib.h>
   22 #include <sys/lua/lauxlib.h>
   23 
   24 #include <zfs_prop.h>
   25 
   26 #include <sys/dsl_prop.h>
   27 #include <sys/dsl_synctask.h>
   28 #include <sys/dsl_dataset.h>
   29 #include <sys/dsl_dir.h>
   30 #include <sys/dmu_objset.h>
   31 #include <sys/mntent.h>
   32 #include <sys/sunddi.h>
   33 #include <sys/zap.h>
   34 #include <sys/zcp.h>
   35 #include <sys/zcp_iter.h>
   36 #include <sys/zcp_global.h>
   37 #include <sys/zcp_prop.h>
   38 #include <sys/zfs_ioctl.h>
   39 #include <sys/zfs_znode.h>
   40 #include <sys/zvol.h>
   41 
   42 #ifdef _KERNEL
   43 #include <sys/zfs_quota.h>
   44 #include <sys/zfs_vfsops.h>
   45 #endif
   46 
   47 static int
   48 get_objset_type(dsl_dataset_t *ds, zfs_type_t *type)
   49 {
   50         int error;
   51         objset_t *os;
   52         error = dmu_objset_from_ds(ds, &os);
   53         if (error != 0)
   54                 return (error);
   55         if (ds->ds_is_snapshot) {
   56                 *type = ZFS_TYPE_SNAPSHOT;
   57         } else {
   58                 switch (os->os_phys->os_type) {
   59                 case DMU_OST_ZFS:
   60                         *type = ZFS_TYPE_FILESYSTEM;
   61                         break;
   62                 case DMU_OST_ZVOL:
   63                         *type = ZFS_TYPE_VOLUME;
   64                         break;
   65                 default:
   66                         return (EINVAL);
   67                 }
   68         }
   69         return (0);
   70 }
   71 
   72 /*
   73  * Returns the string name of ds's type in str (a buffer which should be
   74  * at least 12 bytes long).
   75  */
   76 static int
   77 get_objset_type_name(dsl_dataset_t *ds, char *str)
   78 {
   79         zfs_type_t type = ZFS_TYPE_INVALID;
   80         int error = get_objset_type(ds, &type);
   81         if (error != 0)
   82                 return (error);
   83         switch (type) {
   84         case ZFS_TYPE_SNAPSHOT:
   85                 (void) strlcpy(str, "snapshot", ZAP_MAXVALUELEN);
   86                 break;
   87         case ZFS_TYPE_FILESYSTEM:
   88                 (void) strlcpy(str, "filesystem", ZAP_MAXVALUELEN);
   89                 break;
   90         case ZFS_TYPE_VOLUME:
   91                 (void) strlcpy(str, "volume", ZAP_MAXVALUELEN);
   92                 break;
   93         default:
   94                 return (EINVAL);
   95         }
   96         return (0);
   97 }
   98 
   99 /*
  100  * Determines the source of a property given its setpoint and
  101  * property type. It pushes the source to the lua stack.
  102  */
  103 static void
  104 get_prop_src(lua_State *state, const char *setpoint, zfs_prop_t prop)
  105 {
  106         if (zfs_prop_readonly(prop) || (prop == ZFS_PROP_VERSION)) {
  107                 lua_pushnil(state);
  108         } else {
  109                 const char *src;
  110                 if (strcmp("", setpoint) == 0) {
  111                         src = "default";
  112                 } else {
  113                         src = setpoint;
  114                 }
  115                 (void) lua_pushstring(state, src);
  116         }
  117 }
  118 
  119 /*
  120  * Given an error encountered while getting properties, either longjmp's for
  121  * a fatal error or pushes nothing to the stack for a non fatal one.
  122  */
  123 static int
  124 zcp_handle_error(lua_State *state, const char *dataset_name,
  125     const char *property_name, int error)
  126 {
  127         ASSERT3S(error, !=, 0);
  128         if (error == ENOENT) {
  129                 return (0);
  130         } else if (error == EINVAL) {
  131                 return (luaL_error(state,
  132                     "property '%s' is not a valid property on dataset '%s'",
  133                     property_name, dataset_name));
  134         } else if (error == EIO) {
  135                 return (luaL_error(state,
  136                     "I/O error while retrieving property '%s' on dataset '%s'",
  137                     property_name, dataset_name));
  138         } else {
  139                 return (luaL_error(state, "unexpected error %d while "
  140                     "retrieving property '%s' on dataset '%s'",
  141                     error, property_name, dataset_name));
  142         }
  143 }
  144 
  145 /*
  146  * Look up a user defined property in the zap object. If it exists, push it
  147  * and the setpoint onto the stack, otherwise don't push anything.
  148  */
  149 static int
  150 zcp_get_user_prop(lua_State *state, dsl_pool_t *dp, const char *dataset_name,
  151     const char *property_name)
  152 {
  153         int error;
  154         char *buf;
  155         char setpoint[ZFS_MAX_DATASET_NAME_LEN];
  156         /*
  157          * zcp_dataset_hold will either successfully return the requested
  158          * dataset or throw a lua error and longjmp out of the zfs.get_prop call
  159          * without returning.
  160          */
  161         dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dataset_name, FTAG);
  162         if (ds == NULL)
  163                 return (1); /* not reached; zcp_dataset_hold() longjmp'd */
  164 
  165         buf = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
  166         error = dsl_prop_get_ds(ds, property_name, 1, ZAP_MAXVALUELEN,
  167             buf, setpoint);
  168         dsl_dataset_rele(ds, FTAG);
  169 
  170         if (error != 0) {
  171                 kmem_free(buf, ZAP_MAXVALUELEN);
  172                 return (zcp_handle_error(state, dataset_name, property_name,
  173                     error));
  174         }
  175         (void) lua_pushstring(state, buf);
  176         (void) lua_pushstring(state, setpoint);
  177         kmem_free(buf, ZAP_MAXVALUELEN);
  178         return (2);
  179 }
  180 
  181 /*
  182  * Check if the property we're looking for is stored in the ds_dir. If so,
  183  * return it in the 'val' argument. Return 0 on success and ENOENT and if
  184  * the property is not present.
  185  */
  186 static int
  187 get_dsl_dir_prop(dsl_dataset_t *ds, zfs_prop_t zfs_prop,
  188     uint64_t *val)
  189 {
  190         dsl_dir_t *dd = ds->ds_dir;
  191         mutex_enter(&dd->dd_lock);
  192         switch (zfs_prop) {
  193         case ZFS_PROP_USEDSNAP:
  194                 *val = dsl_dir_get_usedsnap(dd);
  195                 break;
  196         case ZFS_PROP_USEDCHILD:
  197                 *val = dsl_dir_get_usedchild(dd);
  198                 break;
  199         case ZFS_PROP_USEDDS:
  200                 *val = dsl_dir_get_usedds(dd);
  201                 break;
  202         case ZFS_PROP_USEDREFRESERV:
  203                 *val = dsl_dir_get_usedrefreserv(dd);
  204                 break;
  205         case ZFS_PROP_LOGICALUSED:
  206                 *val = dsl_dir_get_logicalused(dd);
  207                 break;
  208         default:
  209                 mutex_exit(&dd->dd_lock);
  210                 return (SET_ERROR(ENOENT));
  211         }
  212         mutex_exit(&dd->dd_lock);
  213         return (0);
  214 }
  215 
  216 /*
  217  * Check if the property we're looking for is stored at the dsl_dataset or
  218  * dsl_dir level. If so, push the property value and source onto the lua stack
  219  * and return 0. If it is not present or a failure occurs in lookup, return a
  220  * non-zero error value.
  221  */
  222 static int
  223 get_special_prop(lua_State *state, dsl_dataset_t *ds, const char *dsname,
  224     zfs_prop_t zfs_prop)
  225 {
  226         int error = 0;
  227         objset_t *os;
  228         uint64_t numval = 0;
  229         char *strval = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
  230         char setpoint[ZFS_MAX_DATASET_NAME_LEN] =
  231             "Internal error - setpoint not determined";
  232         zfs_type_t ds_type = ZFS_TYPE_INVALID;
  233         zprop_type_t prop_type = zfs_prop_get_type(zfs_prop);
  234         (void) get_objset_type(ds, &ds_type);
  235 
  236         switch (zfs_prop) {
  237         case ZFS_PROP_REFRATIO:
  238                 numval = dsl_get_refratio(ds);
  239                 break;
  240         case ZFS_PROP_USED:
  241                 numval = dsl_get_used(ds);
  242                 break;
  243         case ZFS_PROP_CLONES: {
  244                 nvlist_t *clones = fnvlist_alloc();
  245                 error = get_clones_stat_impl(ds, clones);
  246                 if (error == 0) {
  247                         /* push list to lua stack */
  248                         VERIFY0(zcp_nvlist_to_lua(state, clones, NULL, 0ULL));
  249                         /* source */
  250                         (void) lua_pushnil(state);
  251                 }
  252                 nvlist_free(clones);
  253                 kmem_free(strval, ZAP_MAXVALUELEN);
  254                 return (error);
  255         }
  256         case ZFS_PROP_COMPRESSRATIO:
  257                 numval = dsl_get_compressratio(ds);
  258                 break;
  259         case ZFS_PROP_CREATION:
  260                 numval = dsl_get_creation(ds);
  261                 break;
  262         case ZFS_PROP_REFERENCED:
  263                 numval = dsl_get_referenced(ds);
  264                 break;
  265         case ZFS_PROP_AVAILABLE:
  266                 numval = dsl_get_available(ds);
  267                 break;
  268         case ZFS_PROP_LOGICALREFERENCED:
  269                 numval = dsl_get_logicalreferenced(ds);
  270                 break;
  271         case ZFS_PROP_CREATETXG:
  272                 numval = dsl_get_creationtxg(ds);
  273                 break;
  274         case ZFS_PROP_GUID:
  275                 numval = dsl_get_guid(ds);
  276                 break;
  277         case ZFS_PROP_UNIQUE:
  278                 numval = dsl_get_unique(ds);
  279                 break;
  280         case ZFS_PROP_OBJSETID:
  281                 numval = dsl_get_objsetid(ds);
  282                 break;
  283         case ZFS_PROP_ORIGIN:
  284                 dsl_dir_get_origin(ds->ds_dir, strval);
  285                 break;
  286         case ZFS_PROP_USERACCOUNTING:
  287                 error = dmu_objset_from_ds(ds, &os);
  288                 if (error == 0)
  289                         numval = dmu_objset_userspace_present(os);
  290                 break;
  291         case ZFS_PROP_WRITTEN:
  292                 error = dsl_get_written(ds, &numval);
  293                 break;
  294         case ZFS_PROP_TYPE:
  295                 error = get_objset_type_name(ds, strval);
  296                 break;
  297         case ZFS_PROP_PREV_SNAP:
  298                 error = dsl_get_prev_snap(ds, strval);
  299                 break;
  300         case ZFS_PROP_NAME:
  301                 dsl_dataset_name(ds, strval);
  302                 break;
  303         case ZFS_PROP_MOUNTPOINT:
  304                 error = dsl_get_mountpoint(ds, dsname, strval, setpoint);
  305                 break;
  306         case ZFS_PROP_VERSION:
  307                 /* should be a snapshot or filesystem */
  308                 ASSERT(ds_type != ZFS_TYPE_VOLUME);
  309                 error = dmu_objset_from_ds(ds, &os);
  310                 /* look in the master node for the version */
  311                 if (error == 0) {
  312                         error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
  313                             sizeof (numval), 1, &numval);
  314                 }
  315                 break;
  316         case ZFS_PROP_DEFER_DESTROY:
  317                 numval = dsl_get_defer_destroy(ds);
  318                 break;
  319         case ZFS_PROP_USERREFS:
  320                 numval = dsl_get_userrefs(ds);
  321                 break;
  322         case ZFS_PROP_FILESYSTEM_COUNT:
  323                 error = dsl_dir_get_filesystem_count(ds->ds_dir, &numval);
  324                 (void) strlcpy(setpoint, "", ZFS_MAX_DATASET_NAME_LEN);
  325                 break;
  326         case ZFS_PROP_SNAPSHOT_COUNT:
  327                 error = dsl_dir_get_snapshot_count(ds->ds_dir, &numval);
  328                 (void) strlcpy(setpoint, "", ZFS_MAX_DATASET_NAME_LEN);
  329                 break;
  330         case ZFS_PROP_NUMCLONES:
  331                 numval = dsl_get_numclones(ds);
  332                 break;
  333         case ZFS_PROP_INCONSISTENT:
  334                 numval = dsl_get_inconsistent(ds);
  335                 break;
  336         case ZFS_PROP_IVSET_GUID:
  337                 if (dsl_dataset_is_zapified(ds)) {
  338                         error = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,
  339                             ds->ds_object, DS_FIELD_IVSET_GUID,
  340                             sizeof (numval), 1, &numval);
  341                 } else {
  342                         error = ENOENT;
  343                 }
  344                 break;
  345         case ZFS_PROP_RECEIVE_RESUME_TOKEN: {
  346                 char *token = get_receive_resume_token(ds);
  347                 if (token != NULL) {
  348                         (void) strlcpy(strval, token, ZAP_MAXVALUELEN);
  349                         kmem_strfree(token);
  350                 } else {
  351                         error = ENOENT;
  352                 }
  353                 break;
  354         }
  355         case ZFS_PROP_VOLSIZE:
  356                 ASSERT(ds_type == ZFS_TYPE_VOLUME ||
  357                     ds_type == ZFS_TYPE_SNAPSHOT);
  358                 error = dmu_objset_from_ds(ds, &os);
  359                 if (error == 0) {
  360                         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size",
  361                             sizeof (numval), 1, &numval);
  362                 }
  363                 if (error == 0)
  364                         (void) strlcpy(setpoint, dsname,
  365                             ZFS_MAX_DATASET_NAME_LEN);
  366 
  367                 break;
  368         case ZFS_PROP_VOLBLOCKSIZE: {
  369                 ASSERT(ds_type == ZFS_TYPE_VOLUME);
  370                 dmu_object_info_t doi;
  371                 error = dmu_objset_from_ds(ds, &os);
  372                 if (error == 0) {
  373                         error = dmu_object_info(os, ZVOL_OBJ, &doi);
  374                         if (error == 0)
  375                                 numval = doi.doi_data_block_size;
  376                 }
  377                 break;
  378         }
  379 
  380         case ZFS_PROP_KEYSTATUS:
  381         case ZFS_PROP_KEYFORMAT: {
  382                 /* provide defaults in case no crypto obj exists */
  383                 setpoint[0] = '\0';
  384                 if (zfs_prop == ZFS_PROP_KEYSTATUS)
  385                         numval = ZFS_KEYSTATUS_NONE;
  386                 else
  387                         numval = ZFS_KEYFORMAT_NONE;
  388 
  389                 nvlist_t *nvl, *propval;
  390                 nvl = fnvlist_alloc();
  391                 dsl_dataset_crypt_stats(ds, nvl);
  392                 if (nvlist_lookup_nvlist(nvl, zfs_prop_to_name(zfs_prop),
  393                     &propval) == 0) {
  394                         char *source;
  395 
  396                         (void) nvlist_lookup_uint64(propval, ZPROP_VALUE,
  397                             &numval);
  398                         if (nvlist_lookup_string(propval, ZPROP_SOURCE,
  399                             &source) == 0)
  400                                 strlcpy(setpoint, source, sizeof (setpoint));
  401                 }
  402                 nvlist_free(nvl);
  403                 break;
  404         }
  405 
  406         case ZFS_PROP_SNAPSHOTS_CHANGED:
  407                 numval = dsl_dir_snap_cmtime(ds->ds_dir).tv_sec;
  408                 break;
  409 
  410         default:
  411                 /* Did not match these props, check in the dsl_dir */
  412                 error = get_dsl_dir_prop(ds, zfs_prop, &numval);
  413         }
  414         if (error != 0) {
  415                 kmem_free(strval, ZAP_MAXVALUELEN);
  416                 return (error);
  417         }
  418 
  419         switch (prop_type) {
  420         case PROP_TYPE_NUMBER: {
  421                 (void) lua_pushnumber(state, numval);
  422                 break;
  423         }
  424         case PROP_TYPE_STRING: {
  425                 (void) lua_pushstring(state, strval);
  426                 break;
  427         }
  428         case PROP_TYPE_INDEX: {
  429                 const char *propval;
  430                 error = zfs_prop_index_to_string(zfs_prop, numval, &propval);
  431                 if (error != 0) {
  432                         kmem_free(strval, ZAP_MAXVALUELEN);
  433                         return (error);
  434                 }
  435                 (void) lua_pushstring(state, propval);
  436                 break;
  437         }
  438         }
  439         kmem_free(strval, ZAP_MAXVALUELEN);
  440 
  441         /* Push the source to the stack */
  442         get_prop_src(state, setpoint, zfs_prop);
  443         return (0);
  444 }
  445 
  446 /*
  447  * Look up a property and its source in the zap object. If the value is
  448  * present and successfully retrieved, push the value and source on the
  449  * lua stack and return 0. On failure, return a non-zero error value.
  450  */
  451 static int
  452 get_zap_prop(lua_State *state, dsl_dataset_t *ds, zfs_prop_t zfs_prop)
  453 {
  454         int error = 0;
  455         char setpoint[ZFS_MAX_DATASET_NAME_LEN];
  456         char *strval = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
  457         uint64_t numval;
  458         const char *prop_name = zfs_prop_to_name(zfs_prop);
  459         zprop_type_t prop_type = zfs_prop_get_type(zfs_prop);
  460 
  461         if (prop_type == PROP_TYPE_STRING) {
  462                 /* Push value to lua stack */
  463                 error = dsl_prop_get_ds(ds, prop_name, 1,
  464                     ZAP_MAXVALUELEN, strval, setpoint);
  465                 if (error == 0)
  466                         (void) lua_pushstring(state, strval);
  467         } else {
  468                 error = dsl_prop_get_ds(ds, prop_name, sizeof (numval),
  469                     1, &numval, setpoint);
  470                 if (error != 0)
  471                         goto out;
  472 #ifdef _KERNEL
  473                 /* Fill in temporary value for prop, if applicable */
  474                 (void) zfs_get_temporary_prop(ds, zfs_prop, &numval, setpoint);
  475 #else
  476                 kmem_free(strval, ZAP_MAXVALUELEN);
  477                 return (luaL_error(state,
  478                     "temporary properties only supported in kernel mode",
  479                     prop_name));
  480 #endif
  481                 /* Push value to lua stack */
  482                 if (prop_type == PROP_TYPE_INDEX) {
  483                         const char *propval;
  484                         error = zfs_prop_index_to_string(zfs_prop, numval,
  485                             &propval);
  486                         if (error == 0)
  487                                 (void) lua_pushstring(state, propval);
  488                 } else {
  489                         if (error == 0)
  490                                 (void) lua_pushnumber(state, numval);
  491                 }
  492         }
  493 out:
  494         kmem_free(strval, ZAP_MAXVALUELEN);
  495         if (error == 0)
  496                 get_prop_src(state, setpoint, zfs_prop);
  497         return (error);
  498 }
  499 
  500 /*
  501  * Determine whether property is valid for a given dataset
  502  */
  503 boolean_t
  504 prop_valid_for_ds(dsl_dataset_t *ds, zfs_prop_t zfs_prop)
  505 {
  506         zfs_type_t zfs_type = ZFS_TYPE_INVALID;
  507 
  508         /* properties not supported */
  509         if ((zfs_prop == ZFS_PROP_ISCSIOPTIONS) ||
  510             (zfs_prop == ZFS_PROP_MOUNTED))
  511                 return (B_FALSE);
  512 
  513         /* if we want the origin prop, ds must be a clone */
  514         if ((zfs_prop == ZFS_PROP_ORIGIN) && (!dsl_dir_is_clone(ds->ds_dir)))
  515                 return (B_FALSE);
  516 
  517         int error = get_objset_type(ds, &zfs_type);
  518         if (error != 0)
  519                 return (B_FALSE);
  520         return (zfs_prop_valid_for_type(zfs_prop, zfs_type, B_FALSE));
  521 }
  522 
  523 /*
  524  * Look up a given dataset property. On success return 2, the number of
  525  * values pushed to the lua stack (property value and source). On a fatal
  526  * error, longjmp. On a non fatal error push nothing.
  527  */
  528 static int
  529 zcp_get_system_prop(lua_State *state, dsl_pool_t *dp, const char *dataset_name,
  530     zfs_prop_t zfs_prop)
  531 {
  532         int error;
  533         /*
  534          * zcp_dataset_hold will either successfully return the requested
  535          * dataset or throw a lua error and longjmp out of the zfs.get_prop call
  536          * without returning.
  537          */
  538         dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dataset_name, FTAG);
  539         if (ds == NULL)
  540                 return (1); /* not reached; zcp_dataset_hold() longjmp'd */
  541 
  542         /* Check that the property is valid for the given dataset */
  543         const char *prop_name = zfs_prop_to_name(zfs_prop);
  544         if (!prop_valid_for_ds(ds, zfs_prop)) {
  545                 dsl_dataset_rele(ds, FTAG);
  546                 return (0);
  547         }
  548 
  549         /* Check if the property can be accessed directly */
  550         error = get_special_prop(state, ds, dataset_name, zfs_prop);
  551         if (error == 0) {
  552                 dsl_dataset_rele(ds, FTAG);
  553                 /* The value and source have been pushed by get_special_prop */
  554                 return (2);
  555         }
  556         if (error != ENOENT) {
  557                 dsl_dataset_rele(ds, FTAG);
  558                 return (zcp_handle_error(state, dataset_name,
  559                     prop_name, error));
  560         }
  561 
  562         /* If we were unable to find it, look in the zap object */
  563         error = get_zap_prop(state, ds, zfs_prop);
  564         dsl_dataset_rele(ds, FTAG);
  565         if (error != 0) {
  566                 return (zcp_handle_error(state, dataset_name,
  567                     prop_name, error));
  568         }
  569         /* The value and source have been pushed by get_zap_prop */
  570         return (2);
  571 }
  572 
  573 #ifdef _KERNEL
  574 static zfs_userquota_prop_t
  575 get_userquota_prop(const char *prop_name)
  576 {
  577         zfs_userquota_prop_t type;
  578         /* Figure out the property type ({user|group}{quota|used}) */
  579         for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++) {
  580                 if (strncmp(prop_name, zfs_userquota_prop_prefixes[type],
  581                     strlen(zfs_userquota_prop_prefixes[type])) == 0)
  582                         break;
  583         }
  584         return (type);
  585 }
  586 
  587 /*
  588  * Given the name of a zfs_userquota_prop, this function determines the
  589  * prop type as well as the numeric group/user ids based on the string
  590  * following the '@' in the property name. On success, returns 0. On failure,
  591  * returns a non-zero error.
  592  * 'domain' must be free'd by caller using kmem_strfree()
  593  */
  594 static int
  595 parse_userquota_prop(const char *prop_name, zfs_userquota_prop_t *type,
  596     char **domain, uint64_t *rid)
  597 {
  598         char *cp, *end, *domain_val;
  599 
  600         *type = get_userquota_prop(prop_name);
  601         if (*type >= ZFS_NUM_USERQUOTA_PROPS)
  602                 return (EINVAL);
  603 
  604         *rid = 0;
  605         cp = strchr(prop_name, '@') + 1;
  606         if (strncmp(cp, "S-1-", 4) == 0) {
  607                 /*
  608                  * It's a numeric SID (eg "S-1-234-567-89") and we want to
  609                  * separate the domain id and the rid
  610                  */
  611                 int domain_len = strrchr(cp, '-') - cp;
  612                 domain_val = kmem_alloc(domain_len + 1, KM_SLEEP);
  613                 (void) strlcpy(domain_val, cp, domain_len + 1);
  614                 cp += domain_len + 1;
  615 
  616                 (void) ddi_strtoll(cp, &end, 10, (longlong_t *)rid);
  617                 if (*end != '\0') {
  618                         kmem_strfree(domain_val);
  619                         return (EINVAL);
  620                 }
  621         } else {
  622                 /* It's only a user/group ID (eg "12345"), just get the rid */
  623                 domain_val = NULL;
  624                 (void) ddi_strtoll(cp, &end, 10, (longlong_t *)rid);
  625                 if (*end != '\0')
  626                         return (EINVAL);
  627         }
  628         *domain = domain_val;
  629         return (0);
  630 }
  631 
  632 /*
  633  * Look up {user|group}{quota|used} property for given dataset. On success
  634  * push the value (quota or used amount) and the setpoint. On failure, push
  635  * a lua error.
  636  */
  637 static int
  638 zcp_get_userquota_prop(lua_State *state, dsl_pool_t *dp,
  639     const char *dataset_name, const char *prop_name)
  640 {
  641         zfsvfs_t *zfvp;
  642         zfsvfs_t *zfsvfs;
  643         int error;
  644         zfs_userquota_prop_t type;
  645         char *domain;
  646         uint64_t rid, value = 0;
  647         objset_t *os;
  648 
  649         dsl_dataset_t *ds = zcp_dataset_hold(state, dp, dataset_name, FTAG);
  650         if (ds == NULL)
  651                 return (1); /* not reached; zcp_dataset_hold() longjmp'd */
  652 
  653         error = parse_userquota_prop(prop_name, &type, &domain, &rid);
  654         if (error == 0) {
  655                 error = dmu_objset_from_ds(ds, &os);
  656                 if (error == 0) {
  657                         zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
  658                         error = zfsvfs_create_impl(&zfvp, zfsvfs, os);
  659                         if (error == 0) {
  660                                 error = zfs_userspace_one(zfvp, type, domain,
  661                                     rid, &value);
  662                                 zfsvfs_free(zfvp);
  663                         }
  664                 }
  665                 if (domain != NULL)
  666                         kmem_strfree(domain);
  667         }
  668         dsl_dataset_rele(ds, FTAG);
  669 
  670         if ((value == 0) && ((type == ZFS_PROP_USERQUOTA) ||
  671             (type == ZFS_PROP_GROUPQUOTA)))
  672                 error = SET_ERROR(ENOENT);
  673         if (error != 0) {
  674                 return (zcp_handle_error(state, dataset_name,
  675                     prop_name, error));
  676         }
  677 
  678         (void) lua_pushnumber(state, value);
  679         (void) lua_pushstring(state, dataset_name);
  680         return (2);
  681 }
  682 #endif
  683 
  684 /*
  685  * Determines the name of the snapshot referenced in the written property
  686  * name. Returns snapshot name in snap_name, a buffer that must be at least
  687  * as large as ZFS_MAX_DATASET_NAME_LEN
  688  */
  689 static void
  690 parse_written_prop(const char *dataset_name, const char *prop_name,
  691     char *snap_name)
  692 {
  693         ASSERT(zfs_prop_written(prop_name));
  694         const char *name = prop_name + ZFS_WRITTEN_PROP_PREFIX_LEN;
  695         if (strchr(name, '@') == NULL) {
  696                 (void) snprintf(snap_name, ZFS_MAX_DATASET_NAME_LEN, "%s@%s",
  697                     dataset_name, name);
  698         } else {
  699                 (void) strlcpy(snap_name, name, ZFS_MAX_DATASET_NAME_LEN);
  700         }
  701 }
  702 
  703 /*
  704  * Look up written@ property for given dataset. On success
  705  * push the value and the setpoint. If error is fatal, we will
  706  * longjmp, otherwise push nothing.
  707  */
  708 static int
  709 zcp_get_written_prop(lua_State *state, dsl_pool_t *dp,
  710     const char *dataset_name, const char *prop_name)
  711 {
  712         char snap_name[ZFS_MAX_DATASET_NAME_LEN];
  713         uint64_t used, comp, uncomp;
  714         dsl_dataset_t *old;
  715         int error = 0;
  716 
  717         parse_written_prop(dataset_name, prop_name, snap_name);
  718         dsl_dataset_t *new = zcp_dataset_hold(state, dp, dataset_name, FTAG);
  719         if (new == NULL)
  720                 return (1); /* not reached; zcp_dataset_hold() longjmp'd */
  721 
  722         error = dsl_dataset_hold(dp, snap_name, FTAG, &old);
  723         if (error != 0) {
  724                 dsl_dataset_rele(new, FTAG);
  725                 return (zcp_dataset_hold_error(state, dp, snap_name,
  726                     error));
  727         }
  728         error = dsl_dataset_space_written(old, new,
  729             &used, &comp, &uncomp);
  730 
  731         dsl_dataset_rele(old, FTAG);
  732         dsl_dataset_rele(new, FTAG);
  733 
  734         if (error != 0) {
  735                 return (zcp_handle_error(state, dataset_name,
  736                     snap_name, error));
  737         }
  738         (void) lua_pushnumber(state, used);
  739         (void) lua_pushstring(state, dataset_name);
  740         return (2);
  741 }
  742 
  743 static int zcp_get_prop(lua_State *state);
  744 static const zcp_lib_info_t zcp_get_prop_info = {
  745         .name = "get_prop",
  746         .func = zcp_get_prop,
  747         .pargs = {
  748             { .za_name = "dataset", .za_lua_type = LUA_TSTRING },
  749             { .za_name = "property", .za_lua_type =  LUA_TSTRING },
  750             {NULL, 0}
  751         },
  752         .kwargs = {
  753             {NULL, 0}
  754         }
  755 };
  756 
  757 static int
  758 zcp_get_prop(lua_State *state)
  759 {
  760         const char *dataset_name;
  761         const char *property_name;
  762         dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
  763         const zcp_lib_info_t *libinfo = &zcp_get_prop_info;
  764 
  765         zcp_parse_args(state, libinfo->name, libinfo->pargs, libinfo->kwargs);
  766 
  767         dataset_name = lua_tostring(state, 1);
  768         property_name = lua_tostring(state, 2);
  769 
  770         /* User defined property */
  771         if (zfs_prop_user(property_name)) {
  772                 return (zcp_get_user_prop(state, dp,
  773                     dataset_name, property_name));
  774         }
  775         /* userspace property */
  776         if (zfs_prop_userquota(property_name)) {
  777 #ifdef _KERNEL
  778                 return (zcp_get_userquota_prop(state, dp,
  779                     dataset_name, property_name));
  780 #else
  781                 return (luaL_error(state,
  782                     "user quota properties only supported in kernel mode",
  783                     property_name));
  784 #endif
  785         }
  786         /* written@ property */
  787         if (zfs_prop_written(property_name)) {
  788                 return (zcp_get_written_prop(state, dp,
  789                     dataset_name, property_name));
  790         }
  791 
  792         zfs_prop_t zfs_prop = zfs_name_to_prop(property_name);
  793         /* Valid system property */
  794         if (zfs_prop != ZPROP_INVAL) {
  795                 return (zcp_get_system_prop(state, dp, dataset_name,
  796                     zfs_prop));
  797         }
  798 
  799         /* Invalid property name */
  800         return (luaL_error(state,
  801             "'%s' is not a valid property", property_name));
  802 }
  803 
  804 int
  805 zcp_load_get_lib(lua_State *state)
  806 {
  807         lua_pushcclosure(state, zcp_get_prop_info.func, 0);
  808         lua_setfield(state, -2, zcp_get_prop_info.name);
  809 
  810         return (1);
  811 }
Cache object: bc1505416d234ddbe0f6ce26ea2ac3e5
[ 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_get.c

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