module/zfs/zcp_get.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 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                         const 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 }