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