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