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