1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
25 * Copyright (c) 2012 by Delphix. All rights reserved.
26 */
27
28/*
29 * Internal utility routines for the ZFS library.
30 */
31
32#include <sys/param.h>
33#include <sys/linker.h>
34#include <sys/module.h>
35#include <sys/stat.h>
36
37#include <errno.h>
38#include <fcntl.h>
39#include <libintl.h>
40#include <stdarg.h>
41#include <stdio.h>
42#include <stdlib.h>
43#include <strings.h>
44#include <unistd.h>
45#include <ctype.h>
46#include <math.h>
47#include <sys/mnttab.h>
48#include <sys/mntent.h>
49#include <sys/types.h>
50
51#include <libzfs.h>
52#include <libzfs_core.h>
53
54#include "libzfs_impl.h"
55#include "zfs_prop.h"
56#include "zfeature_common.h"
57
58int aok;
59
60int
61libzfs_errno(libzfs_handle_t *hdl)
62{
63	return (hdl->libzfs_error);
64}
65
66const char *
67libzfs_error_action(libzfs_handle_t *hdl)
68{
69	return (hdl->libzfs_action);
70}
71
72const char *
73libzfs_error_description(libzfs_handle_t *hdl)
74{
75	if (hdl->libzfs_desc[0] != '\0')
76		return (hdl->libzfs_desc);
77
78	switch (hdl->libzfs_error) {
79	case EZFS_NOMEM:
80		return (dgettext(TEXT_DOMAIN, "out of memory"));
81	case EZFS_BADPROP:
82		return (dgettext(TEXT_DOMAIN, "invalid property value"));
83	case EZFS_PROPREADONLY:
84		return (dgettext(TEXT_DOMAIN, "read-only property"));
85	case EZFS_PROPTYPE:
86		return (dgettext(TEXT_DOMAIN, "property doesn't apply to "
87		    "datasets of this type"));
88	case EZFS_PROPNONINHERIT:
89		return (dgettext(TEXT_DOMAIN, "property cannot be inherited"));
90	case EZFS_PROPSPACE:
91		return (dgettext(TEXT_DOMAIN, "invalid quota or reservation"));
92	case EZFS_BADTYPE:
93		return (dgettext(TEXT_DOMAIN, "operation not applicable to "
94		    "datasets of this type"));
95	case EZFS_BUSY:
96		return (dgettext(TEXT_DOMAIN, "pool or dataset is busy"));
97	case EZFS_EXISTS:
98		return (dgettext(TEXT_DOMAIN, "pool or dataset exists"));
99	case EZFS_NOENT:
100		return (dgettext(TEXT_DOMAIN, "no such pool or dataset"));
101	case EZFS_BADSTREAM:
102		return (dgettext(TEXT_DOMAIN, "invalid backup stream"));
103	case EZFS_DSREADONLY:
104		return (dgettext(TEXT_DOMAIN, "dataset is read-only"));
105	case EZFS_VOLTOOBIG:
106		return (dgettext(TEXT_DOMAIN, "volume size exceeds limit for "
107		    "this system"));
108	case EZFS_INVALIDNAME:
109		return (dgettext(TEXT_DOMAIN, "invalid name"));
110	case EZFS_BADRESTORE:
111		return (dgettext(TEXT_DOMAIN, "unable to restore to "
112		    "destination"));
113	case EZFS_BADBACKUP:
114		return (dgettext(TEXT_DOMAIN, "backup failed"));
115	case EZFS_BADTARGET:
116		return (dgettext(TEXT_DOMAIN, "invalid target vdev"));
117	case EZFS_NODEVICE:
118		return (dgettext(TEXT_DOMAIN, "no such device in pool"));
119	case EZFS_BADDEV:
120		return (dgettext(TEXT_DOMAIN, "invalid device"));
121	case EZFS_NOREPLICAS:
122		return (dgettext(TEXT_DOMAIN, "no valid replicas"));
123	case EZFS_RESILVERING:
124		return (dgettext(TEXT_DOMAIN, "currently resilvering"));
125	case EZFS_BADVERSION:
126		return (dgettext(TEXT_DOMAIN, "unsupported version or "
127		    "feature"));
128	case EZFS_POOLUNAVAIL:
129		return (dgettext(TEXT_DOMAIN, "pool is unavailable"));
130	case EZFS_DEVOVERFLOW:
131		return (dgettext(TEXT_DOMAIN, "too many devices in one vdev"));
132	case EZFS_BADPATH:
133		return (dgettext(TEXT_DOMAIN, "must be an absolute path"));
134	case EZFS_CROSSTARGET:
135		return (dgettext(TEXT_DOMAIN, "operation crosses datasets or "
136		    "pools"));
137	case EZFS_ZONED:
138		return (dgettext(TEXT_DOMAIN, "dataset in use by local zone"));
139	case EZFS_MOUNTFAILED:
140		return (dgettext(TEXT_DOMAIN, "mount failed"));
141	case EZFS_UMOUNTFAILED:
142		return (dgettext(TEXT_DOMAIN, "umount failed"));
143	case EZFS_UNSHARENFSFAILED:
144		return (dgettext(TEXT_DOMAIN, "unshare(1M) failed"));
145	case EZFS_SHARENFSFAILED:
146		return (dgettext(TEXT_DOMAIN, "share(1M) failed"));
147	case EZFS_UNSHARESMBFAILED:
148		return (dgettext(TEXT_DOMAIN, "smb remove share failed"));
149	case EZFS_SHARESMBFAILED:
150		return (dgettext(TEXT_DOMAIN, "smb add share failed"));
151	case EZFS_PERM:
152		return (dgettext(TEXT_DOMAIN, "permission denied"));
153	case EZFS_NOSPC:
154		return (dgettext(TEXT_DOMAIN, "out of space"));
155	case EZFS_FAULT:
156		return (dgettext(TEXT_DOMAIN, "bad address"));
157	case EZFS_IO:
158		return (dgettext(TEXT_DOMAIN, "I/O error"));
159	case EZFS_INTR:
160		return (dgettext(TEXT_DOMAIN, "signal received"));
161	case EZFS_ISSPARE:
162		return (dgettext(TEXT_DOMAIN, "device is reserved as a hot "
163		    "spare"));
164	case EZFS_INVALCONFIG:
165		return (dgettext(TEXT_DOMAIN, "invalid vdev configuration"));
166	case EZFS_RECURSIVE:
167		return (dgettext(TEXT_DOMAIN, "recursive dataset dependency"));
168	case EZFS_NOHISTORY:
169		return (dgettext(TEXT_DOMAIN, "no history available"));
170	case EZFS_POOLPROPS:
171		return (dgettext(TEXT_DOMAIN, "failed to retrieve "
172		    "pool properties"));
173	case EZFS_POOL_NOTSUP:
174		return (dgettext(TEXT_DOMAIN, "operation not supported "
175		    "on this type of pool"));
176	case EZFS_POOL_INVALARG:
177		return (dgettext(TEXT_DOMAIN, "invalid argument for "
178		    "this pool operation"));
179	case EZFS_NAMETOOLONG:
180		return (dgettext(TEXT_DOMAIN, "dataset name is too long"));
181	case EZFS_OPENFAILED:
182		return (dgettext(TEXT_DOMAIN, "open failed"));
183	case EZFS_NOCAP:
184		return (dgettext(TEXT_DOMAIN,
185		    "disk capacity information could not be retrieved"));
186	case EZFS_LABELFAILED:
187		return (dgettext(TEXT_DOMAIN, "write of label failed"));
188	case EZFS_BADWHO:
189		return (dgettext(TEXT_DOMAIN, "invalid user/group"));
190	case EZFS_BADPERM:
191		return (dgettext(TEXT_DOMAIN, "invalid permission"));
192	case EZFS_BADPERMSET:
193		return (dgettext(TEXT_DOMAIN, "invalid permission set name"));
194	case EZFS_NODELEGATION:
195		return (dgettext(TEXT_DOMAIN, "delegated administration is "
196		    "disabled on pool"));
197	case EZFS_BADCACHE:
198		return (dgettext(TEXT_DOMAIN, "invalid or missing cache file"));
199	case EZFS_ISL2CACHE:
200		return (dgettext(TEXT_DOMAIN, "device is in use as a cache"));
201	case EZFS_VDEVNOTSUP:
202		return (dgettext(TEXT_DOMAIN, "vdev specification is not "
203		    "supported"));
204	case EZFS_NOTSUP:
205		return (dgettext(TEXT_DOMAIN, "operation not supported "
206		    "on this dataset"));
207	case EZFS_ACTIVE_SPARE:
208		return (dgettext(TEXT_DOMAIN, "pool has active shared spare "
209		    "device"));
210	case EZFS_UNPLAYED_LOGS:
211		return (dgettext(TEXT_DOMAIN, "log device has unplayed intent "
212		    "logs"));
213	case EZFS_REFTAG_RELE:
214		return (dgettext(TEXT_DOMAIN, "no such tag on this dataset"));
215	case EZFS_REFTAG_HOLD:
216		return (dgettext(TEXT_DOMAIN, "tag already exists on this "
217		    "dataset"));
218	case EZFS_TAGTOOLONG:
219		return (dgettext(TEXT_DOMAIN, "tag too long"));
220	case EZFS_PIPEFAILED:
221		return (dgettext(TEXT_DOMAIN, "pipe create failed"));
222	case EZFS_THREADCREATEFAILED:
223		return (dgettext(TEXT_DOMAIN, "thread create failed"));
224	case EZFS_POSTSPLIT_ONLINE:
225		return (dgettext(TEXT_DOMAIN, "disk was split from this pool "
226		    "into a new one"));
227	case EZFS_SCRUBBING:
228		return (dgettext(TEXT_DOMAIN, "currently scrubbing; "
229		    "use 'zpool scrub -s' to cancel current scrub"));
230	case EZFS_NO_SCRUB:
231		return (dgettext(TEXT_DOMAIN, "there is no active scrub"));
232	case EZFS_DIFF:
233		return (dgettext(TEXT_DOMAIN, "unable to generate diffs"));
234	case EZFS_DIFFDATA:
235		return (dgettext(TEXT_DOMAIN, "invalid diff data"));
236	case EZFS_POOLREADONLY:
237		return (dgettext(TEXT_DOMAIN, "pool is read-only"));
238	case EZFS_UNKNOWN:
239		return (dgettext(TEXT_DOMAIN, "unknown error"));
240	default:
241		assert(hdl->libzfs_error == 0);
242		return (dgettext(TEXT_DOMAIN, "no error"));
243	}
244}
245
246/*PRINTFLIKE2*/
247void
248zfs_error_aux(libzfs_handle_t *hdl, const char *fmt, ...)
249{
250	va_list ap;
251
252	va_start(ap, fmt);
253
254	(void) vsnprintf(hdl->libzfs_desc, sizeof (hdl->libzfs_desc),
255	    fmt, ap);
256	hdl->libzfs_desc_active = 1;
257
258	va_end(ap);
259}
260
261static void
262zfs_verror(libzfs_handle_t *hdl, int error, const char *fmt, va_list ap)
263{
264	(void) vsnprintf(hdl->libzfs_action, sizeof (hdl->libzfs_action),
265	    fmt, ap);
266	hdl->libzfs_error = error;
267
268	if (hdl->libzfs_desc_active)
269		hdl->libzfs_desc_active = 0;
270	else
271		hdl->libzfs_desc[0] = '\0';
272
273	if (hdl->libzfs_printerr) {
274		if (error == EZFS_UNKNOWN) {
275			(void) fprintf(stderr, dgettext(TEXT_DOMAIN, "internal "
276			    "error: %s\n"), libzfs_error_description(hdl));
277			abort();
278		}
279
280		(void) fprintf(stderr, "%s: %s\n", hdl->libzfs_action,
281		    libzfs_error_description(hdl));
282		if (error == EZFS_NOMEM)
283			exit(1);
284	}
285}
286
287int
288zfs_error(libzfs_handle_t *hdl, int error, const char *msg)
289{
290	return (zfs_error_fmt(hdl, error, "%s", msg));
291}
292
293/*PRINTFLIKE3*/
294int
295zfs_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...)
296{
297	va_list ap;
298
299	va_start(ap, fmt);
300
301	zfs_verror(hdl, error, fmt, ap);
302
303	va_end(ap);
304
305	return (-1);
306}
307
308static int
309zfs_common_error(libzfs_handle_t *hdl, int error, const char *fmt,
310    va_list ap)
311{
312	switch (error) {
313	case EPERM:
314	case EACCES:
315		zfs_verror(hdl, EZFS_PERM, fmt, ap);
316		return (-1);
317
318	case ECANCELED:
319		zfs_verror(hdl, EZFS_NODELEGATION, fmt, ap);
320		return (-1);
321
322	case EIO:
323		zfs_verror(hdl, EZFS_IO, fmt, ap);
324		return (-1);
325
326	case EFAULT:
327		zfs_verror(hdl, EZFS_FAULT, fmt, ap);
328		return (-1);
329
330	case EINTR:
331		zfs_verror(hdl, EZFS_INTR, fmt, ap);
332		return (-1);
333	}
334
335	return (0);
336}
337
338int
339zfs_standard_error(libzfs_handle_t *hdl, int error, const char *msg)
340{
341	return (zfs_standard_error_fmt(hdl, error, "%s", msg));
342}
343
344/*PRINTFLIKE3*/
345int
346zfs_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...)
347{
348	va_list ap;
349
350	va_start(ap, fmt);
351
352	if (zfs_common_error(hdl, error, fmt, ap) != 0) {
353		va_end(ap);
354		return (-1);
355	}
356
357	switch (error) {
358	case ENXIO:
359	case ENODEV:
360	case EPIPE:
361		zfs_verror(hdl, EZFS_IO, fmt, ap);
362		break;
363
364	case ENOENT:
365		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
366		    "dataset does not exist"));
367		zfs_verror(hdl, EZFS_NOENT, fmt, ap);
368		break;
369
370	case ENOSPC:
371	case EDQUOT:
372		zfs_verror(hdl, EZFS_NOSPC, fmt, ap);
373		return (-1);
374
375	case EEXIST:
376		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
377		    "dataset already exists"));
378		zfs_verror(hdl, EZFS_EXISTS, fmt, ap);
379		break;
380
381	case EBUSY:
382		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
383		    "dataset is busy"));
384		zfs_verror(hdl, EZFS_BUSY, fmt, ap);
385		break;
386	case EROFS:
387		zfs_verror(hdl, EZFS_POOLREADONLY, fmt, ap);
388		break;
389	case ENAMETOOLONG:
390		zfs_verror(hdl, EZFS_NAMETOOLONG, fmt, ap);
391		break;
392	case ENOTSUP:
393		zfs_verror(hdl, EZFS_BADVERSION, fmt, ap);
394		break;
395	case EAGAIN:
396		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
397		    "pool I/O is currently suspended"));
398		zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap);
399		break;
400	default:
401		zfs_error_aux(hdl, strerror(error));
402		zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap);
403		break;
404	}
405
406	va_end(ap);
407	return (-1);
408}
409
410int
411zpool_standard_error(libzfs_handle_t *hdl, int error, const char *msg)
412{
413	return (zpool_standard_error_fmt(hdl, error, "%s", msg));
414}
415
416/*PRINTFLIKE3*/
417int
418zpool_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...)
419{
420	va_list ap;
421
422	va_start(ap, fmt);
423
424	if (zfs_common_error(hdl, error, fmt, ap) != 0) {
425		va_end(ap);
426		return (-1);
427	}
428
429	switch (error) {
430	case ENODEV:
431		zfs_verror(hdl, EZFS_NODEVICE, fmt, ap);
432		break;
433
434	case ENOENT:
435		zfs_error_aux(hdl,
436		    dgettext(TEXT_DOMAIN, "no such pool or dataset"));
437		zfs_verror(hdl, EZFS_NOENT, fmt, ap);
438		break;
439
440	case EEXIST:
441		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
442		    "pool already exists"));
443		zfs_verror(hdl, EZFS_EXISTS, fmt, ap);
444		break;
445
446	case EBUSY:
447		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool is busy"));
448		zfs_verror(hdl, EZFS_BUSY, fmt, ap);
449		break;
450
451	case ENXIO:
452		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
453		    "one or more devices is currently unavailable"));
454		zfs_verror(hdl, EZFS_BADDEV, fmt, ap);
455		break;
456
457	case ENAMETOOLONG:
458		zfs_verror(hdl, EZFS_DEVOVERFLOW, fmt, ap);
459		break;
460
461	case ENOTSUP:
462		zfs_verror(hdl, EZFS_POOL_NOTSUP, fmt, ap);
463		break;
464
465	case EINVAL:
466		zfs_verror(hdl, EZFS_POOL_INVALARG, fmt, ap);
467		break;
468
469	case ENOSPC:
470	case EDQUOT:
471		zfs_verror(hdl, EZFS_NOSPC, fmt, ap);
472		return (-1);
473
474	case EAGAIN:
475		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
476		    "pool I/O is currently suspended"));
477		zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap);
478		break;
479
480	case EROFS:
481		zfs_verror(hdl, EZFS_POOLREADONLY, fmt, ap);
482		break;
483
484	default:
485		zfs_error_aux(hdl, strerror(error));
486		zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap);
487	}
488
489	va_end(ap);
490	return (-1);
491}
492
493/*
494 * Display an out of memory error message and abort the current program.
495 */
496int
497no_memory(libzfs_handle_t *hdl)
498{
499	return (zfs_error(hdl, EZFS_NOMEM, "internal error"));
500}
501
502/*
503 * A safe form of malloc() which will die if the allocation fails.
504 */
505void *
506zfs_alloc(libzfs_handle_t *hdl, size_t size)
507{
508	void *data;
509
510	if ((data = calloc(1, size)) == NULL)
511		(void) no_memory(hdl);
512
513	return (data);
514}
515
516/*
517 * A safe form of asprintf() which will die if the allocation fails.
518 */
519/*PRINTFLIKE2*/
520char *
521zfs_asprintf(libzfs_handle_t *hdl, const char *fmt, ...)
522{
523	va_list ap;
524	char *ret;
525	int err;
526
527	va_start(ap, fmt);
528
529	err = vasprintf(&ret, fmt, ap);
530
531	va_end(ap);
532
533	if (err < 0)
534		(void) no_memory(hdl);
535
536	return (ret);
537}
538
539/*
540 * A safe form of realloc(), which also zeroes newly allocated space.
541 */
542void *
543zfs_realloc(libzfs_handle_t *hdl, void *ptr, size_t oldsize, size_t newsize)
544{
545	void *ret;
546
547	if ((ret = realloc(ptr, newsize)) == NULL) {
548		(void) no_memory(hdl);
549		return (NULL);
550	}
551
552	bzero((char *)ret + oldsize, (newsize - oldsize));
553	return (ret);
554}
555
556/*
557 * A safe form of strdup() which will die if the allocation fails.
558 */
559char *
560zfs_strdup(libzfs_handle_t *hdl, const char *str)
561{
562	char *ret;
563
564	if ((ret = strdup(str)) == NULL)
565		(void) no_memory(hdl);
566
567	return (ret);
568}
569
570/*
571 * Convert a number to an appropriately human-readable output.
572 */
573void
574zfs_nicenum(uint64_t num, char *buf, size_t buflen)
575{
576	uint64_t n = num;
577	int index = 0;
578	char u;
579
580	while (n >= 1024) {
581		n /= 1024;
582		index++;
583	}
584
585	u = " KMGTPE"[index];
586
587	if (index == 0) {
588		(void) snprintf(buf, buflen, "%llu", n);
589	} else if ((num & ((1ULL << 10 * index) - 1)) == 0) {
590		/*
591		 * If this is an even multiple of the base, always display
592		 * without any decimal precision.
593		 */
594		(void) snprintf(buf, buflen, "%llu%c", n, u);
595	} else {
596		/*
597		 * We want to choose a precision that reflects the best choice
598		 * for fitting in 5 characters.  This can get rather tricky when
599		 * we have numbers that are very close to an order of magnitude.
600		 * For example, when displaying 10239 (which is really 9.999K),
601		 * we want only a single place of precision for 10.0K.  We could
602		 * develop some complex heuristics for this, but it's much
603		 * easier just to try each combination in turn.
604		 */
605		int i;
606		for (i = 2; i >= 0; i--) {
607			if (snprintf(buf, buflen, "%.*f%c", i,
608			    (double)num / (1ULL << 10 * index), u) <= 5)
609				break;
610		}
611	}
612}
613
614void
615libzfs_print_on_error(libzfs_handle_t *hdl, boolean_t printerr)
616{
617	hdl->libzfs_printerr = printerr;
618}
619
620static int
621libzfs_load(void)
622{
623	int error;
624
625	if (modfind("zfs") < 0) {
626		/* Not present in kernel, try loading it. */
627		if (kldload("zfs") < 0 || modfind("zfs") < 0) {
628			if (errno != EEXIST)
629				return (-1);
630		}
631	}
632	return (0);
633}
634
635libzfs_handle_t *
636libzfs_init(void)
637{
638	libzfs_handle_t *hdl;
639
640	if ((hdl = calloc(1, sizeof (libzfs_handle_t))) == NULL) {
641		return (NULL);
642	}
643
644	if (libzfs_load() < 0) {
645		free(hdl);
646		return (NULL);
647	}
648
649	if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR)) < 0) {
650		free(hdl);
651		return (NULL);
652	}
653
654	if ((hdl->libzfs_mnttab = fopen(MNTTAB, "r")) == NULL) {
655		(void) close(hdl->libzfs_fd);
656		free(hdl);
657		return (NULL);
658	}
659
660	hdl->libzfs_sharetab = fopen(ZFS_EXPORTS_PATH, "r");
661
662	if (libzfs_core_init() != 0) {
663		(void) close(hdl->libzfs_fd);
664		(void) fclose(hdl->libzfs_mnttab);
665		(void) fclose(hdl->libzfs_sharetab);
666		free(hdl);
667		return (NULL);
668	}
669
670	zfs_prop_init();
671	zpool_prop_init();
672	zpool_feature_init();
673	libzfs_mnttab_init(hdl);
674
675	return (hdl);
676}
677
678void
679libzfs_fini(libzfs_handle_t *hdl)
680{
681	(void) close(hdl->libzfs_fd);
682	if (hdl->libzfs_mnttab)
683		(void) fclose(hdl->libzfs_mnttab);
684	if (hdl->libzfs_sharetab)
685		(void) fclose(hdl->libzfs_sharetab);
686	zfs_uninit_libshare(hdl);
687	zpool_free_handles(hdl);
688#ifdef sun
689	libzfs_fru_clear(hdl, B_TRUE);
690#endif
691	namespace_clear(hdl);
692	libzfs_mnttab_fini(hdl);
693	libzfs_core_fini();
694	free(hdl);
695}
696
697libzfs_handle_t *
698zpool_get_handle(zpool_handle_t *zhp)
699{
700	return (zhp->zpool_hdl);
701}
702
703libzfs_handle_t *
704zfs_get_handle(zfs_handle_t *zhp)
705{
706	return (zhp->zfs_hdl);
707}
708
709zpool_handle_t *
710zfs_get_pool_handle(const zfs_handle_t *zhp)
711{
712	return (zhp->zpool_hdl);
713}
714
715/*
716 * Given a name, determine whether or not it's a valid path
717 * (starts with '/' or "./").  If so, walk the mnttab trying
718 * to match the device number.  If not, treat the path as an
719 * fs/vol/snap name.
720 */
721zfs_handle_t *
722zfs_path_to_zhandle(libzfs_handle_t *hdl, char *path, zfs_type_t argtype)
723{
724	struct stat64 statbuf;
725	struct extmnttab entry;
726	int ret;
727
728	if (path[0] != '/' && strncmp(path, "./", strlen("./")) != 0) {
729		/*
730		 * It's not a valid path, assume it's a name of type 'argtype'.
731		 */
732		return (zfs_open(hdl, path, argtype));
733	}
734
735	if (stat64(path, &statbuf) != 0) {
736		(void) fprintf(stderr, "%s: %s\n", path, strerror(errno));
737		return (NULL);
738	}
739
740#ifdef sun
741	rewind(hdl->libzfs_mnttab);
742	while ((ret = getextmntent(hdl->libzfs_mnttab, &entry, 0)) == 0) {
743		if (makedevice(entry.mnt_major, entry.mnt_minor) ==
744		    statbuf.st_dev) {
745			break;
746		}
747	}
748#else
749	{
750		struct statfs sfs;
751
752		ret = statfs(path, &sfs);
753		if (ret == 0)
754			statfs2mnttab(&sfs, &entry);
755		else {
756			(void) fprintf(stderr, "%s: %s\n", path,
757			    strerror(errno));
758		}
759	}
760#endif	/* sun */
761	if (ret != 0) {
762		return (NULL);
763	}
764
765	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
766		(void) fprintf(stderr, gettext("'%s': not a ZFS filesystem\n"),
767		    path);
768		return (NULL);
769	}
770
771	return (zfs_open(hdl, entry.mnt_special, ZFS_TYPE_FILESYSTEM));
772}
773
774/*
775 * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from
776 * an ioctl().
777 */
778int
779zcmd_alloc_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, size_t len)
780{
781	if (len == 0)
782		len = 16 * 1024;
783	zc->zc_nvlist_dst_size = len;
784	if ((zc->zc_nvlist_dst = (uint64_t)(uintptr_t)
785	    zfs_alloc(hdl, zc->zc_nvlist_dst_size)) == 0)
786		return (-1);
787
788	return (0);
789}
790
791/*
792 * Called when an ioctl() which returns an nvlist fails with ENOMEM.  This will
793 * expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was
794 * filled in by the kernel to indicate the actual required size.
795 */
796int
797zcmd_expand_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc)
798{
799	free((void *)(uintptr_t)zc->zc_nvlist_dst);
800	if ((zc->zc_nvlist_dst = (uint64_t)(uintptr_t)
801	    zfs_alloc(hdl, zc->zc_nvlist_dst_size))
802	    == 0)
803		return (-1);
804
805	return (0);
806}
807
808/*
809 * Called to free the src and dst nvlists stored in the command structure.
810 */
811void
812zcmd_free_nvlists(zfs_cmd_t *zc)
813{
814	free((void *)(uintptr_t)zc->zc_nvlist_conf);
815	free((void *)(uintptr_t)zc->zc_nvlist_src);
816	free((void *)(uintptr_t)zc->zc_nvlist_dst);
817}
818
819static int
820zcmd_write_nvlist_com(libzfs_handle_t *hdl, uint64_t *outnv, uint64_t *outlen,
821    nvlist_t *nvl)
822{
823	char *packed;
824	size_t len;
825
826	verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0);
827
828	if ((packed = zfs_alloc(hdl, len)) == NULL)
829		return (-1);
830
831	verify(nvlist_pack(nvl, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
832
833	*outnv = (uint64_t)(uintptr_t)packed;
834	*outlen = len;
835
836	return (0);
837}
838
839int
840zcmd_write_conf_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl)
841{
842	return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_conf,
843	    &zc->zc_nvlist_conf_size, nvl));
844}
845
846int
847zcmd_write_src_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl)
848{
849	return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_src,
850	    &zc->zc_nvlist_src_size, nvl));
851}
852
853/*
854 * Unpacks an nvlist from the ZFS ioctl command structure.
855 */
856int
857zcmd_read_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t **nvlp)
858{
859	if (nvlist_unpack((void *)(uintptr_t)zc->zc_nvlist_dst,
860	    zc->zc_nvlist_dst_size, nvlp, 0) != 0)
861		return (no_memory(hdl));
862
863	return (0);
864}
865
866int
867zfs_ioctl(libzfs_handle_t *hdl, int request, zfs_cmd_t *zc)
868{
869	return (ioctl(hdl->libzfs_fd, request, zc));
870}
871
872/*
873 * ================================================================
874 * API shared by zfs and zpool property management
875 * ================================================================
876 */
877
878static void
879zprop_print_headers(zprop_get_cbdata_t *cbp, zfs_type_t type)
880{
881	zprop_list_t *pl = cbp->cb_proplist;
882	int i;
883	char *title;
884	size_t len;
885
886	cbp->cb_first = B_FALSE;
887	if (cbp->cb_scripted)
888		return;
889
890	/*
891	 * Start with the length of the column headers.
892	 */
893	cbp->cb_colwidths[GET_COL_NAME] = strlen(dgettext(TEXT_DOMAIN, "NAME"));
894	cbp->cb_colwidths[GET_COL_PROPERTY] = strlen(dgettext(TEXT_DOMAIN,
895	    "PROPERTY"));
896	cbp->cb_colwidths[GET_COL_VALUE] = strlen(dgettext(TEXT_DOMAIN,
897	    "VALUE"));
898	cbp->cb_colwidths[GET_COL_RECVD] = strlen(dgettext(TEXT_DOMAIN,
899	    "RECEIVED"));
900	cbp->cb_colwidths[GET_COL_SOURCE] = strlen(dgettext(TEXT_DOMAIN,
901	    "SOURCE"));
902
903	/* first property is always NAME */
904	assert(cbp->cb_proplist->pl_prop ==
905	    ((type == ZFS_TYPE_POOL) ?  ZPOOL_PROP_NAME : ZFS_PROP_NAME));
906
907	/*
908	 * Go through and calculate the widths for each column.  For the
909	 * 'source' column, we kludge it up by taking the worst-case scenario of
910	 * inheriting from the longest name.  This is acceptable because in the
911	 * majority of cases 'SOURCE' is the last column displayed, and we don't
912	 * use the width anyway.  Note that the 'VALUE' column can be oversized,
913	 * if the name of the property is much longer than any values we find.
914	 */
915	for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) {
916		/*
917		 * 'PROPERTY' column
918		 */
919		if (pl->pl_prop != ZPROP_INVAL) {
920			const char *propname = (type == ZFS_TYPE_POOL) ?
921			    zpool_prop_to_name(pl->pl_prop) :
922			    zfs_prop_to_name(pl->pl_prop);
923
924			len = strlen(propname);
925			if (len > cbp->cb_colwidths[GET_COL_PROPERTY])
926				cbp->cb_colwidths[GET_COL_PROPERTY] = len;
927		} else {
928			len = strlen(pl->pl_user_prop);
929			if (len > cbp->cb_colwidths[GET_COL_PROPERTY])
930				cbp->cb_colwidths[GET_COL_PROPERTY] = len;
931		}
932
933		/*
934		 * 'VALUE' column.  The first property is always the 'name'
935		 * property that was tacked on either by /sbin/zfs's
936		 * zfs_do_get() or when calling zprop_expand_list(), so we
937		 * ignore its width.  If the user specified the name property
938		 * to display, then it will be later in the list in any case.
939		 */
940		if (pl != cbp->cb_proplist &&
941		    pl->pl_width > cbp->cb_colwidths[GET_COL_VALUE])
942			cbp->cb_colwidths[GET_COL_VALUE] = pl->pl_width;
943
944		/* 'RECEIVED' column. */
945		if (pl != cbp->cb_proplist &&
946		    pl->pl_recvd_width > cbp->cb_colwidths[GET_COL_RECVD])
947			cbp->cb_colwidths[GET_COL_RECVD] = pl->pl_recvd_width;
948
949		/*
950		 * 'NAME' and 'SOURCE' columns
951		 */
952		if (pl->pl_prop == (type == ZFS_TYPE_POOL ? ZPOOL_PROP_NAME :
953		    ZFS_PROP_NAME) &&
954		    pl->pl_width > cbp->cb_colwidths[GET_COL_NAME]) {
955			cbp->cb_colwidths[GET_COL_NAME] = pl->pl_width;
956			cbp->cb_colwidths[GET_COL_SOURCE] = pl->pl_width +
957			    strlen(dgettext(TEXT_DOMAIN, "inherited from"));
958		}
959	}
960
961	/*
962	 * Now go through and print the headers.
963	 */
964	for (i = 0; i < ZFS_GET_NCOLS; i++) {
965		switch (cbp->cb_columns[i]) {
966		case GET_COL_NAME:
967			title = dgettext(TEXT_DOMAIN, "NAME");
968			break;
969		case GET_COL_PROPERTY:
970			title = dgettext(TEXT_DOMAIN, "PROPERTY");
971			break;
972		case GET_COL_VALUE:
973			title = dgettext(TEXT_DOMAIN, "VALUE");
974			break;
975		case GET_COL_RECVD:
976			title = dgettext(TEXT_DOMAIN, "RECEIVED");
977			break;
978		case GET_COL_SOURCE:
979			title = dgettext(TEXT_DOMAIN, "SOURCE");
980			break;
981		default:
982			title = NULL;
983		}
984
985		if (title != NULL) {
986			if (i == (ZFS_GET_NCOLS - 1) ||
987			    cbp->cb_columns[i + 1] == GET_COL_NONE)
988				(void) printf("%s", title);
989			else
990				(void) printf("%-*s  ",
991				    cbp->cb_colwidths[cbp->cb_columns[i]],
992				    title);
993		}
994	}
995	(void) printf("\n");
996}
997
998/*
999 * Display a single line of output, according to the settings in the callback
1000 * structure.
1001 */
1002void
1003zprop_print_one_property(const char *name, zprop_get_cbdata_t *cbp,
1004    const char *propname, const char *value, zprop_source_t sourcetype,
1005    const char *source, const char *recvd_value)
1006{
1007	int i;
1008	const char *str;
1009	char buf[128];
1010
1011	/*
1012	 * Ignore those source types that the user has chosen to ignore.
1013	 */
1014	if ((sourcetype & cbp->cb_sources) == 0)
1015		return;
1016
1017	if (cbp->cb_first)
1018		zprop_print_headers(cbp, cbp->cb_type);
1019
1020	for (i = 0; i < ZFS_GET_NCOLS; i++) {
1021		switch (cbp->cb_columns[i]) {
1022		case GET_COL_NAME:
1023			str = name;
1024			break;
1025
1026		case GET_COL_PROPERTY:
1027			str = propname;
1028			break;
1029
1030		case GET_COL_VALUE:
1031			str = value;
1032			break;
1033
1034		case GET_COL_SOURCE:
1035			switch (sourcetype) {
1036			case ZPROP_SRC_NONE:
1037				str = "-";
1038				break;
1039
1040			case ZPROP_SRC_DEFAULT:
1041				str = "default";
1042				break;
1043
1044			case ZPROP_SRC_LOCAL:
1045				str = "local";
1046				break;
1047
1048			case ZPROP_SRC_TEMPORARY:
1049				str = "temporary";
1050				break;
1051
1052			case ZPROP_SRC_INHERITED:
1053				(void) snprintf(buf, sizeof (buf),
1054				    "inherited from %s", source);
1055				str = buf;
1056				break;
1057			case ZPROP_SRC_RECEIVED:
1058				str = "received";
1059				break;
1060			}
1061			break;
1062
1063		case GET_COL_RECVD:
1064			str = (recvd_value == NULL ? "-" : recvd_value);
1065			break;
1066
1067		default:
1068			continue;
1069		}
1070
1071		if (cbp->cb_columns[i + 1] == GET_COL_NONE)
1072			(void) printf("%s", str);
1073		else if (cbp->cb_scripted)
1074			(void) printf("%s\t", str);
1075		else
1076			(void) printf("%-*s  ",
1077			    cbp->cb_colwidths[cbp->cb_columns[i]],
1078			    str);
1079	}
1080
1081	(void) printf("\n");
1082}
1083
1084/*
1085 * Given a numeric suffix, convert the value into a number of bits that the
1086 * resulting value must be shifted.
1087 */
1088static int
1089str2shift(libzfs_handle_t *hdl, const char *buf)
1090{
1091	const char *ends = "BKMGTPEZ";
1092	int i;
1093
1094	if (buf[0] == '\0')
1095		return (0);
1096	for (i = 0; i < strlen(ends); i++) {
1097		if (toupper(buf[0]) == ends[i])
1098			break;
1099	}
1100	if (i == strlen(ends)) {
1101		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1102		    "invalid numeric suffix '%s'"), buf);
1103		return (-1);
1104	}
1105
1106	/*
1107	 * We want to allow trailing 'b' characters for 'GB' or 'Mb'.  But don't
1108	 * allow 'BB' - that's just weird.
1109	 */
1110	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' &&
1111	    toupper(buf[0]) != 'B'))
1112		return (10*i);
1113
1114	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1115	    "invalid numeric suffix '%s'"), buf);
1116	return (-1);
1117}
1118
1119/*
1120 * Convert a string of the form '100G' into a real number.  Used when setting
1121 * properties or creating a volume.  'buf' is used to place an extended error
1122 * message for the caller to use.
1123 */
1124int
1125zfs_nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num)
1126{
1127	char *end;
1128	int shift;
1129
1130	*num = 0;
1131
1132	/* Check to see if this looks like a number.  */
1133	if ((value[0] < '0' || value[0] > '9') && value[0] != '.') {
1134		if (hdl)
1135			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1136			    "bad numeric value '%s'"), value);
1137		return (-1);
1138	}
1139
1140	/* Rely on strtoull() to process the numeric portion.  */
1141	errno = 0;
1142	*num = strtoull(value, &end, 10);
1143
1144	/*
1145	 * Check for ERANGE, which indicates that the value is too large to fit
1146	 * in a 64-bit value.
1147	 */
1148	if (errno == ERANGE) {
1149		if (hdl)
1150			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1151			    "numeric value is too large"));
1152		return (-1);
1153	}
1154
1155	/*
1156	 * If we have a decimal value, then do the computation with floating
1157	 * point arithmetic.  Otherwise, use standard arithmetic.
1158	 */
1159	if (*end == '.') {
1160		double fval = strtod(value, &end);
1161
1162		if ((shift = str2shift(hdl, end)) == -1)
1163			return (-1);
1164
1165		fval *= pow(2, shift);
1166
1167		if (fval > UINT64_MAX) {
1168			if (hdl)
1169				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1170				    "numeric value is too large"));
1171			return (-1);
1172		}
1173
1174		*num = (uint64_t)fval;
1175	} else {
1176		if ((shift = str2shift(hdl, end)) == -1)
1177			return (-1);
1178
1179		/* Check for overflow */
1180		if (shift >= 64 || (*num << shift) >> shift != *num) {
1181			if (hdl)
1182				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1183				    "numeric value is too large"));
1184			return (-1);
1185		}
1186
1187		*num <<= shift;
1188	}
1189
1190	return (0);
1191}
1192
1193/*
1194 * Given a propname=value nvpair to set, parse any numeric properties
1195 * (index, boolean, etc) if they are specified as strings and add the
1196 * resulting nvpair to the returned nvlist.
1197 *
1198 * At the DSL layer, all properties are either 64-bit numbers or strings.
1199 * We want the user to be able to ignore this fact and specify properties
1200 * as native values (numbers, for example) or as strings (to simplify
1201 * command line utilities).  This also handles converting index types
1202 * (compression, checksum, etc) from strings to their on-disk index.
1203 */
1204int
1205zprop_parse_value(libzfs_handle_t *hdl, nvpair_t *elem, int prop,
1206    zfs_type_t type, nvlist_t *ret, char **svalp, uint64_t *ivalp,
1207    const char *errbuf)
1208{
1209	data_type_t datatype = nvpair_type(elem);
1210	zprop_type_t proptype;
1211	const char *propname;
1212	char *value;
1213	boolean_t isnone = B_FALSE;
1214
1215	if (type == ZFS_TYPE_POOL) {
1216		proptype = zpool_prop_get_type(prop);
1217		propname = zpool_prop_to_name(prop);
1218	} else {
1219		proptype = zfs_prop_get_type(prop);
1220		propname = zfs_prop_to_name(prop);
1221	}
1222
1223	/*
1224	 * Convert any properties to the internal DSL value types.
1225	 */
1226	*svalp = NULL;
1227	*ivalp = 0;
1228
1229	switch (proptype) {
1230	case PROP_TYPE_STRING:
1231		if (datatype != DATA_TYPE_STRING) {
1232			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1233			    "'%s' must be a string"), nvpair_name(elem));
1234			goto error;
1235		}
1236		(void) nvpair_value_string(elem, svalp);
1237		if (strlen(*svalp) >= ZFS_MAXPROPLEN) {
1238			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1239			    "'%s' is too long"), nvpair_name(elem));
1240			goto error;
1241		}
1242		break;
1243
1244	case PROP_TYPE_NUMBER:
1245		if (datatype == DATA_TYPE_STRING) {
1246			(void) nvpair_value_string(elem, &value);
1247			if (strcmp(value, "none") == 0) {
1248				isnone = B_TRUE;
1249			} else if (zfs_nicestrtonum(hdl, value, ivalp)
1250			    != 0) {
1251				goto error;
1252			}
1253		} else if (datatype == DATA_TYPE_UINT64) {
1254			(void) nvpair_value_uint64(elem, ivalp);
1255		} else {
1256			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1257			    "'%s' must be a number"), nvpair_name(elem));
1258			goto error;
1259		}
1260
1261		/*
1262		 * Quota special: force 'none' and don't allow 0.
1263		 */
1264		if ((type & ZFS_TYPE_DATASET) && *ivalp == 0 && !isnone &&
1265		    (prop == ZFS_PROP_QUOTA || prop == ZFS_PROP_REFQUOTA)) {
1266			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1267			    "use 'none' to disable quota/refquota"));
1268			goto error;
1269		}
1270
1271		/*
1272		 * Special handling for "*_limit=none". In this case it's not
1273		 * 0 but UINT64_MAX.
1274		 */
1275		if ((type & ZFS_TYPE_DATASET) && isnone &&
1276		    (prop == ZFS_PROP_FILESYSTEM_LIMIT ||
1277		    prop == ZFS_PROP_SNAPSHOT_LIMIT)) {
1278			*ivalp = UINT64_MAX;
1279		}
1280		break;
1281
1282	case PROP_TYPE_INDEX:
1283		if (datatype != DATA_TYPE_STRING) {
1284			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1285			    "'%s' must be a string"), nvpair_name(elem));
1286			goto error;
1287		}
1288
1289		(void) nvpair_value_string(elem, &value);
1290
1291		if (zprop_string_to_index(prop, value, ivalp, type) != 0) {
1292			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1293			    "'%s' must be one of '%s'"), propname,
1294			    zprop_values(prop, type));
1295			goto error;
1296		}
1297		break;
1298
1299	default:
1300		abort();
1301	}
1302
1303	/*
1304	 * Add the result to our return set of properties.
1305	 */
1306	if (*svalp != NULL) {
1307		if (nvlist_add_string(ret, propname, *svalp) != 0) {
1308			(void) no_memory(hdl);
1309			return (-1);
1310		}
1311	} else {
1312		if (nvlist_add_uint64(ret, propname, *ivalp) != 0) {
1313			(void) no_memory(hdl);
1314			return (-1);
1315		}
1316	}
1317
1318	return (0);
1319error:
1320	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1321	return (-1);
1322}
1323
1324static int
1325addlist(libzfs_handle_t *hdl, char *propname, zprop_list_t **listp,
1326    zfs_type_t type)
1327{
1328	int prop;
1329	zprop_list_t *entry;
1330
1331	prop = zprop_name_to_prop(propname, type);
1332
1333	if (prop != ZPROP_INVAL && !zprop_valid_for_type(prop, type))
1334		prop = ZPROP_INVAL;
1335
1336	/*
1337	 * When no property table entry can be found, return failure if
1338	 * this is a pool property or if this isn't a user-defined
1339	 * dataset property,
1340	 */
1341	if (prop == ZPROP_INVAL && ((type == ZFS_TYPE_POOL &&
1342	    !zpool_prop_feature(propname) &&
1343	    !zpool_prop_unsupported(propname)) ||
1344	    (type == ZFS_TYPE_DATASET && !zfs_prop_user(propname) &&
1345	    !zfs_prop_userquota(propname) && !zfs_prop_written(propname)))) {
1346		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1347		    "invalid property '%s'"), propname);
1348		return (zfs_error(hdl, EZFS_BADPROP,
1349		    dgettext(TEXT_DOMAIN, "bad property list")));
1350	}
1351
1352	if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL)
1353		return (-1);
1354
1355	entry->pl_prop = prop;
1356	if (prop == ZPROP_INVAL) {
1357		if ((entry->pl_user_prop = zfs_strdup(hdl, propname)) ==
1358		    NULL) {
1359			free(entry);
1360			return (-1);
1361		}
1362		entry->pl_width = strlen(propname);
1363	} else {
1364		entry->pl_width = zprop_width(prop, &entry->pl_fixed,
1365		    type);
1366	}
1367
1368	*listp = entry;
1369
1370	return (0);
1371}
1372
1373/*
1374 * Given a comma-separated list of properties, construct a property list
1375 * containing both user-defined and native properties.  This function will
1376 * return a NULL list if 'all' is specified, which can later be expanded
1377 * by zprop_expand_list().
1378 */
1379int
1380zprop_get_list(libzfs_handle_t *hdl, char *props, zprop_list_t **listp,
1381    zfs_type_t type)
1382{
1383	*listp = NULL;
1384
1385	/*
1386	 * If 'all' is specified, return a NULL list.
1387	 */
1388	if (strcmp(props, "all") == 0)
1389		return (0);
1390
1391	/*
1392	 * If no props were specified, return an error.
1393	 */
1394	if (props[0] == '\0') {
1395		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1396		    "no properties specified"));
1397		return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN,
1398		    "bad property list")));
1399	}
1400
1401	/*
1402	 * It would be nice to use getsubopt() here, but the inclusion of column
1403	 * aliases makes this more effort than it's worth.
1404	 */
1405	while (*props != '\0') {
1406		size_t len;
1407		char *p;
1408		char c;
1409
1410		if ((p = strchr(props, ',')) == NULL) {
1411			len = strlen(props);
1412			p = props + len;
1413		} else {
1414			len = p - props;
1415		}
1416
1417		/*
1418		 * Check for empty options.
1419		 */
1420		if (len == 0) {
1421			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1422			    "empty property name"));
1423			return (zfs_error(hdl, EZFS_BADPROP,
1424			    dgettext(TEXT_DOMAIN, "bad property list")));
1425		}
1426
1427		/*
1428		 * Check all regular property names.
1429		 */
1430		c = props[len];
1431		props[len] = '\0';
1432
1433		if (strcmp(props, "space") == 0) {
1434			static char *spaceprops[] = {
1435				"name", "avail", "used", "usedbysnapshots",
1436				"usedbydataset", "usedbyrefreservation",
1437				"usedbychildren", NULL
1438			};
1439			int i;
1440
1441			for (i = 0; spaceprops[i]; i++) {
1442				if (addlist(hdl, spaceprops[i], listp, type))
1443					return (-1);
1444				listp = &(*listp)->pl_next;
1445			}
1446		} else {
1447			if (addlist(hdl, props, listp, type))
1448				return (-1);
1449			listp = &(*listp)->pl_next;
1450		}
1451
1452		props = p;
1453		if (c == ',')
1454			props++;
1455	}
1456
1457	return (0);
1458}
1459
1460void
1461zprop_free_list(zprop_list_t *pl)
1462{
1463	zprop_list_t *next;
1464
1465	while (pl != NULL) {
1466		next = pl->pl_next;
1467		free(pl->pl_user_prop);
1468		free(pl);
1469		pl = next;
1470	}
1471}
1472
1473typedef struct expand_data {
1474	zprop_list_t	**last;
1475	libzfs_handle_t	*hdl;
1476	zfs_type_t type;
1477} expand_data_t;
1478
1479int
1480zprop_expand_list_cb(int prop, void *cb)
1481{
1482	zprop_list_t *entry;
1483	expand_data_t *edp = cb;
1484
1485	if ((entry = zfs_alloc(edp->hdl, sizeof (zprop_list_t))) == NULL)
1486		return (ZPROP_INVAL);
1487
1488	entry->pl_prop = prop;
1489	entry->pl_width = zprop_width(prop, &entry->pl_fixed, edp->type);
1490	entry->pl_all = B_TRUE;
1491
1492	*(edp->last) = entry;
1493	edp->last = &entry->pl_next;
1494
1495	return (ZPROP_CONT);
1496}
1497
1498int
1499zprop_expand_list(libzfs_handle_t *hdl, zprop_list_t **plp, zfs_type_t type)
1500{
1501	zprop_list_t *entry;
1502	zprop_list_t **last;
1503	expand_data_t exp;
1504
1505	if (*plp == NULL) {
1506		/*
1507		 * If this is the very first time we've been called for an 'all'
1508		 * specification, expand the list to include all native
1509		 * properties.
1510		 */
1511		last = plp;
1512
1513		exp.last = last;
1514		exp.hdl = hdl;
1515		exp.type = type;
1516
1517		if (zprop_iter_common(zprop_expand_list_cb, &exp, B_FALSE,
1518		    B_FALSE, type) == ZPROP_INVAL)
1519			return (-1);
1520
1521		/*
1522		 * Add 'name' to the beginning of the list, which is handled
1523		 * specially.
1524		 */
1525		if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL)
1526			return (-1);
1527
1528		entry->pl_prop = (type == ZFS_TYPE_POOL) ?  ZPOOL_PROP_NAME :
1529		    ZFS_PROP_NAME;
1530		entry->pl_width = zprop_width(entry->pl_prop,
1531		    &entry->pl_fixed, type);
1532		entry->pl_all = B_TRUE;
1533		entry->pl_next = *plp;
1534		*plp = entry;
1535	}
1536	return (0);
1537}
1538
1539int
1540zprop_iter(zprop_func func, void *cb, boolean_t show_all, boolean_t ordered,
1541    zfs_type_t type)
1542{
1543	return (zprop_iter_common(func, cb, show_all, ordered, type));
1544}
1545