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