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
get_objset_type(dsl_dataset_t * ds,zfs_type_t * type)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
get_objset_type_name(dsl_dataset_t * ds,char * str)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
get_prop_src(lua_State * state,const char * setpoint,zfs_prop_t prop)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
zcp_handle_error(lua_State * state,const char * dataset_name,const char * property_name,int error)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
zcp_get_user_prop(lua_State * state,dsl_pool_t * dp,const char * dataset_name,const char * property_name)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
get_dsl_dir_prop(dsl_dataset_t * ds,zfs_prop_t zfs_prop,uint64_t * val)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
get_special_prop(lua_State * state,dsl_dataset_t * ds,const char * dsname,zfs_prop_t zfs_prop)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
get_zap_prop(lua_State * state,dsl_dataset_t * ds,zfs_prop_t zfs_prop)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
prop_valid_for_ds(dsl_dataset_t * ds,zfs_prop_t zfs_prop)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
zcp_get_system_prop(lua_State * state,dsl_pool_t * dp,const char * dataset_name,zfs_prop_t zfs_prop)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
get_userquota_prop(const char * prop_name)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
parse_userquota_prop(const char * prop_name,zfs_userquota_prop_t * type,char ** domain,uint64_t * rid)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
zcp_get_userquota_prop(lua_State * state,dsl_pool_t * dp,const char * dataset_name,const char * prop_name)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
parse_written_prop(const char * dataset_name,const char * prop_name,char * snap_name)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
zcp_get_written_prop(lua_State * state,dsl_pool_t * dp,const char * dataset_name,const char * prop_name)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
zcp_get_prop(lua_State * state)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
zcp_load_get_lib(lua_State * state)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 }
812