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