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