]> git.proxmox.com Git - mirror_zfs.git/blob - lib/libzfs/libzfs_dataset.c
projects / mirror_zfs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
OpenZFS 8898 - creating fs with checksum=skein on the boot pools fails ungracefully
[mirror_zfs.git] / lib / libzfs / libzfs_dataset.c
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, 2016 by Delphix. All rights reserved.
26 * Copyright (c) 2012 DEY Storage Systems, Inc. All rights reserved.
27 * Copyright (c) 2012 Pawel Jakub Dawidek <pawel@dawidek.net>.
28 * Copyright (c) 2013 Martin Matuska. All rights reserved.
29 * Copyright (c) 2013 Steven Hartland. All rights reserved.
30 * Copyright 2017 Nexenta Systems, Inc.
31 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
32 * Copyright 2017 RackTop Systems.
33 */
34
35 #include <ctype.h>
36 #include <errno.h>
37 #include <libintl.h>
38 #include <math.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <strings.h>
42 #include <unistd.h>
43 #include <stddef.h>
44 #include <zone.h>
45 #include <fcntl.h>
46 #include <sys/mntent.h>
47 #include <sys/mount.h>
48 #include <pwd.h>
49 #include <grp.h>
50 #include <stddef.h>
51 #include <ucred.h>
52 #ifdef HAVE_IDMAP
53 #include <idmap.h>
54 #include <aclutils.h>
55 #include <directory.h>
56 #endif /* HAVE_IDMAP */
57
58 #include <sys/dnode.h>
59 #include <sys/spa.h>
60 #include <sys/zap.h>
61 #include <sys/dsl_crypt.h>
62 #include <libzfs.h>
63
64 #include "zfs_namecheck.h"
65 #include "zfs_prop.h"
66 #include "libzfs_impl.h"
67 #include "libzfs.h"
68 #include "zfs_deleg.h"
69
70 static int userquota_propname_decode(const char *propname, boolean_t zoned,
71 zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp);
72
73 /*
74 * Given a single type (not a mask of types), return the type in a human
75 * readable form.
76 */
77 const char *
78 zfs_type_to_name(zfs_type_t type)
79 {
80 switch (type) {
81 case ZFS_TYPE_FILESYSTEM:
82 return (dgettext(TEXT_DOMAIN, "filesystem"));
83 case ZFS_TYPE_SNAPSHOT:
84 return (dgettext(TEXT_DOMAIN, "snapshot"));
85 case ZFS_TYPE_VOLUME:
86 return (dgettext(TEXT_DOMAIN, "volume"));
87 case ZFS_TYPE_POOL:
88 return (dgettext(TEXT_DOMAIN, "pool"));
89 case ZFS_TYPE_BOOKMARK:
90 return (dgettext(TEXT_DOMAIN, "bookmark"));
91 default:
92 assert(!"unhandled zfs_type_t");
93 }
94
95 return (NULL);
96 }
97
98 /*
99 * Validate a ZFS path. This is used even before trying to open the dataset, to
100 * provide a more meaningful error message. We call zfs_error_aux() to
101 * explain exactly why the name was not valid.
102 */
103 int
104 zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type,
105 boolean_t modifying)
106 {
107 namecheck_err_t why;
108 char what;
109
110 if (entity_namecheck(path, &why, &what) != 0) {
111 if (hdl != NULL) {
112 switch (why) {
113 case NAME_ERR_TOOLONG:
114 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
115 "name is too long"));
116 break;
117
118 case NAME_ERR_LEADING_SLASH:
119 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
120 "leading slash in name"));
121 break;
122
123 case NAME_ERR_EMPTY_COMPONENT:
124 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
125 "empty component in name"));
126 break;
127
128 case NAME_ERR_TRAILING_SLASH:
129 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
130 "trailing slash in name"));
131 break;
132
133 case NAME_ERR_INVALCHAR:
134 zfs_error_aux(hdl,
135 dgettext(TEXT_DOMAIN, "invalid character "
136 "'%c' in name"), what);
137 break;
138
139 case NAME_ERR_MULTIPLE_DELIMITERS:
140 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
141 "multiple '@' and/or '#' delimiters in "
142 "name"));
143 break;
144
145 case NAME_ERR_NOLETTER:
146 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
147 "pool doesn't begin with a letter"));
148 break;
149
150 case NAME_ERR_RESERVED:
151 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
152 "name is reserved"));
153 break;
154
155 case NAME_ERR_DISKLIKE:
156 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
157 "reserved disk name"));
158 break;
159
160 default:
161 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
162 "(%d) not defined"), why);
163 break;
164 }
165 }
166
167 return (0);
168 }
169
170 if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) {
171 if (hdl != NULL)
172 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
173 "snapshot delimiter '@' is not expected here"));
174 return (0);
175 }
176
177 if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) {
178 if (hdl != NULL)
179 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
180 "missing '@' delimiter in snapshot name"));
181 return (0);
182 }
183
184 if (!(type & ZFS_TYPE_BOOKMARK) && strchr(path, '#') != NULL) {
185 if (hdl != NULL)
186 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
187 "bookmark delimiter '#' is not expected here"));
188 return (0);
189 }
190
191 if (type == ZFS_TYPE_BOOKMARK && strchr(path, '#') == NULL) {
192 if (hdl != NULL)
193 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
194 "missing '#' delimiter in bookmark name"));
195 return (0);
196 }
197
198 if (modifying && strchr(path, '%') != NULL) {
199 if (hdl != NULL)
200 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
201 "invalid character %c in name"), '%');
202 return (0);
203 }
204
205 return (-1);
206 }
207
208 int
209 zfs_name_valid(const char *name, zfs_type_t type)
210 {
211 if (type == ZFS_TYPE_POOL)
212 return (zpool_name_valid(NULL, B_FALSE, name));
213 return (zfs_validate_name(NULL, name, type, B_FALSE));
214 }
215
216 /*
217 * This function takes the raw DSL properties, and filters out the user-defined
218 * properties into a separate nvlist.
219 */
220 static nvlist_t *
221 process_user_props(zfs_handle_t *zhp, nvlist_t *props)
222 {
223 libzfs_handle_t *hdl = zhp->zfs_hdl;
224 nvpair_t *elem;
225 nvlist_t *propval;
226 nvlist_t *nvl;
227
228 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
229 (void) no_memory(hdl);
230 return (NULL);
231 }
232
233 elem = NULL;
234 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
235 if (!zfs_prop_user(nvpair_name(elem)))
236 continue;
237
238 verify(nvpair_value_nvlist(elem, &propval) == 0);
239 if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) {
240 nvlist_free(nvl);
241 (void) no_memory(hdl);
242 return (NULL);
243 }
244 }
245
246 return (nvl);
247 }
248
249 static zpool_handle_t *
250 zpool_add_handle(zfs_handle_t *zhp, const char *pool_name)
251 {
252 libzfs_handle_t *hdl = zhp->zfs_hdl;
253 zpool_handle_t *zph;
254
255 if ((zph = zpool_open_canfail(hdl, pool_name)) != NULL) {
256 if (hdl->libzfs_pool_handles != NULL)
257 zph->zpool_next = hdl->libzfs_pool_handles;
258 hdl->libzfs_pool_handles = zph;
259 }
260 return (zph);
261 }
262
263 static zpool_handle_t *
264 zpool_find_handle(zfs_handle_t *zhp, const char *pool_name, int len)
265 {
266 libzfs_handle_t *hdl = zhp->zfs_hdl;
267 zpool_handle_t *zph = hdl->libzfs_pool_handles;
268
269 while ((zph != NULL) &&
270 (strncmp(pool_name, zpool_get_name(zph), len) != 0))
271 zph = zph->zpool_next;
272 return (zph);
273 }
274
275 /*
276 * Returns a handle to the pool that contains the provided dataset.
277 * If a handle to that pool already exists then that handle is returned.
278 * Otherwise, a new handle is created and added to the list of handles.
279 */
280 static zpool_handle_t *
281 zpool_handle(zfs_handle_t *zhp)
282 {
283 char *pool_name;
284 int len;
285 zpool_handle_t *zph;
286
287 len = strcspn(zhp->zfs_name, "/@#") + 1;
288 pool_name = zfs_alloc(zhp->zfs_hdl, len);
289 (void) strlcpy(pool_name, zhp->zfs_name, len);
290
291 zph = zpool_find_handle(zhp, pool_name, len);
292 if (zph == NULL)
293 zph = zpool_add_handle(zhp, pool_name);
294
295 free(pool_name);
296 return (zph);
297 }
298
299 void
300 zpool_free_handles(libzfs_handle_t *hdl)
301 {
302 zpool_handle_t *next, *zph = hdl->libzfs_pool_handles;
303
304 while (zph != NULL) {
305 next = zph->zpool_next;
306 zpool_close(zph);
307 zph = next;
308 }
309 hdl->libzfs_pool_handles = NULL;
310 }
311
312 /*
313 * Utility function to gather stats (objset and zpl) for the given object.
314 */
315 static int
316 get_stats_ioctl(zfs_handle_t *zhp, zfs_cmd_t *zc)
317 {
318 libzfs_handle_t *hdl = zhp->zfs_hdl;
319
320 (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
321
322 while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, zc) != 0) {
323 if (errno == ENOMEM) {
324 if (zcmd_expand_dst_nvlist(hdl, zc) != 0) {
325 return (-1);
326 }
327 } else {
328 return (-1);
329 }
330 }
331 return (0);
332 }
333
334 /*
335 * Utility function to get the received properties of the given object.
336 */
337 static int
338 get_recvd_props_ioctl(zfs_handle_t *zhp)
339 {
340 libzfs_handle_t *hdl = zhp->zfs_hdl;
341 nvlist_t *recvdprops;
342 zfs_cmd_t zc = {"\0"};
343 int err;
344
345 if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
346 return (-1);
347
348 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
349
350 while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_RECVD_PROPS, &zc) != 0) {
351 if (errno == ENOMEM) {
352 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
353 return (-1);
354 }
355 } else {
356 zcmd_free_nvlists(&zc);
357 return (-1);
358 }
359 }
360
361 err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops);
362 zcmd_free_nvlists(&zc);
363 if (err != 0)
364 return (-1);
365
366 nvlist_free(zhp->zfs_recvd_props);
367 zhp->zfs_recvd_props = recvdprops;
368
369 return (0);
370 }
371
372 static int
373 put_stats_zhdl(zfs_handle_t *zhp, zfs_cmd_t *zc)
374 {
375 nvlist_t *allprops, *userprops;
376
377 zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */
378
379 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) {
380 return (-1);
381 }
382
383 /*
384 * XXX Why do we store the user props separately, in addition to
385 * storing them in zfs_props?
386 */
387 if ((userprops = process_user_props(zhp, allprops)) == NULL) {
388 nvlist_free(allprops);
389 return (-1);
390 }
391
392 nvlist_free(zhp->zfs_props);
393 nvlist_free(zhp->zfs_user_props);
394
395 zhp->zfs_props = allprops;
396 zhp->zfs_user_props = userprops;
397
398 return (0);
399 }
400
401 static int
402 get_stats(zfs_handle_t *zhp)
403 {
404 int rc = 0;
405 zfs_cmd_t zc = {"\0"};
406
407 if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
408 return (-1);
409 if (get_stats_ioctl(zhp, &zc) != 0)
410 rc = -1;
411 else if (put_stats_zhdl(zhp, &zc) != 0)
412 rc = -1;
413 zcmd_free_nvlists(&zc);
414 return (rc);
415 }
416
417 /*
418 * Refresh the properties currently stored in the handle.
419 */
420 void
421 zfs_refresh_properties(zfs_handle_t *zhp)
422 {
423 (void) get_stats(zhp);
424 }
425
426 /*
427 * Makes a handle from the given dataset name. Used by zfs_open() and
428 * zfs_iter_* to create child handles on the fly.
429 */
430 static int
431 make_dataset_handle_common(zfs_handle_t *zhp, zfs_cmd_t *zc)
432 {
433 if (put_stats_zhdl(zhp, zc) != 0)
434 return (-1);
435
436 /*
437 * We've managed to open the dataset and gather statistics. Determine
438 * the high-level type.
439 */
440 if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
441 zhp->zfs_head_type = ZFS_TYPE_VOLUME;
442 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
443 zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM;
444 else if (zhp->zfs_dmustats.dds_type == DMU_OST_OTHER)
445 return (-1);
446 else
447 abort();
448
449 if (zhp->zfs_dmustats.dds_is_snapshot)
450 zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
451 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
452 zhp->zfs_type = ZFS_TYPE_VOLUME;
453 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
454 zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
455 else
456 abort(); /* we should never see any other types */
457
458 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL)
459 return (-1);
460
461 return (0);
462 }
463
464 zfs_handle_t *
465 make_dataset_handle(libzfs_handle_t *hdl, const char *path)
466 {
467 zfs_cmd_t zc = {"\0"};
468
469 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
470
471 if (zhp == NULL)
472 return (NULL);
473
474 zhp->zfs_hdl = hdl;
475 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
476 if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) {
477 free(zhp);
478 return (NULL);
479 }
480 if (get_stats_ioctl(zhp, &zc) == -1) {
481 zcmd_free_nvlists(&zc);
482 free(zhp);
483 return (NULL);
484 }
485 if (make_dataset_handle_common(zhp, &zc) == -1) {
486 free(zhp);
487 zhp = NULL;
488 }
489 zcmd_free_nvlists(&zc);
490 return (zhp);
491 }
492
493 zfs_handle_t *
494 make_dataset_handle_zc(libzfs_handle_t *hdl, zfs_cmd_t *zc)
495 {
496 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
497
498 if (zhp == NULL)
499 return (NULL);
500
501 zhp->zfs_hdl = hdl;
502 (void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
503 if (make_dataset_handle_common(zhp, zc) == -1) {
504 free(zhp);
505 return (NULL);
506 }
507 return (zhp);
508 }
509
510 zfs_handle_t *
511 make_dataset_simple_handle_zc(zfs_handle_t *pzhp, zfs_cmd_t *zc)
512 {
513 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
514
515 if (zhp == NULL)
516 return (NULL);
517
518 zhp->zfs_hdl = pzhp->zfs_hdl;
519 (void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
520 zhp->zfs_head_type = pzhp->zfs_type;
521 zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
522 zhp->zpool_hdl = zpool_handle(zhp);
523
524 return (zhp);
525 }
526
527 zfs_handle_t *
528 zfs_handle_dup(zfs_handle_t *zhp_orig)
529 {
530 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
531
532 if (zhp == NULL)
533 return (NULL);
534
535 zhp->zfs_hdl = zhp_orig->zfs_hdl;
536 zhp->zpool_hdl = zhp_orig->zpool_hdl;
537 (void) strlcpy(zhp->zfs_name, zhp_orig->zfs_name,
538 sizeof (zhp->zfs_name));
539 zhp->zfs_type = zhp_orig->zfs_type;
540 zhp->zfs_head_type = zhp_orig->zfs_head_type;
541 zhp->zfs_dmustats = zhp_orig->zfs_dmustats;
542 if (zhp_orig->zfs_props != NULL) {
543 if (nvlist_dup(zhp_orig->zfs_props, &zhp->zfs_props, 0) != 0) {
544 (void) no_memory(zhp->zfs_hdl);
545 zfs_close(zhp);
546 return (NULL);
547 }
548 }
549 if (zhp_orig->zfs_user_props != NULL) {
550 if (nvlist_dup(zhp_orig->zfs_user_props,
551 &zhp->zfs_user_props, 0) != 0) {
552 (void) no_memory(zhp->zfs_hdl);
553 zfs_close(zhp);
554 return (NULL);
555 }
556 }
557 if (zhp_orig->zfs_recvd_props != NULL) {
558 if (nvlist_dup(zhp_orig->zfs_recvd_props,
559 &zhp->zfs_recvd_props, 0)) {
560 (void) no_memory(zhp->zfs_hdl);
561 zfs_close(zhp);
562 return (NULL);
563 }
564 }
565 zhp->zfs_mntcheck = zhp_orig->zfs_mntcheck;
566 if (zhp_orig->zfs_mntopts != NULL) {
567 zhp->zfs_mntopts = zfs_strdup(zhp_orig->zfs_hdl,
568 zhp_orig->zfs_mntopts);
569 }
570 zhp->zfs_props_table = zhp_orig->zfs_props_table;
571 return (zhp);
572 }
573
574 boolean_t
575 zfs_bookmark_exists(const char *path)
576 {
577 nvlist_t *bmarks;
578 nvlist_t *props;
579 char fsname[ZFS_MAX_DATASET_NAME_LEN];
580 char *bmark_name;
581 char *pound;
582 int err;
583 boolean_t rv;
584
585
586 (void) strlcpy(fsname, path, sizeof (fsname));
587 pound = strchr(fsname, '#');
588 if (pound == NULL)
589 return (B_FALSE);
590
591 *pound = '\0';
592 bmark_name = pound + 1;
593 props = fnvlist_alloc();
594 err = lzc_get_bookmarks(fsname, props, &bmarks);
595 nvlist_free(props);
596 if (err != 0) {
597 nvlist_free(bmarks);
598 return (B_FALSE);
599 }
600
601 rv = nvlist_exists(bmarks, bmark_name);
602 nvlist_free(bmarks);
603 return (rv);
604 }
605
606 zfs_handle_t *
607 make_bookmark_handle(zfs_handle_t *parent, const char *path,
608 nvlist_t *bmark_props)
609 {
610 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
611
612 if (zhp == NULL)
613 return (NULL);
614
615 /* Fill in the name. */
616 zhp->zfs_hdl = parent->zfs_hdl;
617 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
618
619 /* Set the property lists. */
620 if (nvlist_dup(bmark_props, &zhp->zfs_props, 0) != 0) {
621 free(zhp);
622 return (NULL);
623 }
624
625 /* Set the types. */
626 zhp->zfs_head_type = parent->zfs_head_type;
627 zhp->zfs_type = ZFS_TYPE_BOOKMARK;
628
629 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) {
630 nvlist_free(zhp->zfs_props);
631 free(zhp);
632 return (NULL);
633 }
634
635 return (zhp);
636 }
637
638 struct zfs_open_bookmarks_cb_data {
639 const char *path;
640 zfs_handle_t *zhp;
641 };
642
643 static int
644 zfs_open_bookmarks_cb(zfs_handle_t *zhp, void *data)
645 {
646 struct zfs_open_bookmarks_cb_data *dp = data;
647
648 /*
649 * Is it the one we are looking for?
650 */
651 if (strcmp(dp->path, zfs_get_name(zhp)) == 0) {
652 /*
653 * We found it. Save it and let the caller know we are done.
654 */
655 dp->zhp = zhp;
656 return (EEXIST);
657 }
658
659 /*
660 * Not found. Close the handle and ask for another one.
661 */
662 zfs_close(zhp);
663 return (0);
664 }
665
666 /*
667 * Opens the given snapshot, bookmark, filesystem, or volume. The 'types'
668 * argument is a mask of acceptable types. The function will print an
669 * appropriate error message and return NULL if it can't be opened.
670 */
671 zfs_handle_t *
672 zfs_open(libzfs_handle_t *hdl, const char *path, int types)
673 {
674 zfs_handle_t *zhp;
675 char errbuf[1024];
676 char *bookp;
677
678 (void) snprintf(errbuf, sizeof (errbuf),
679 dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);
680
681 /*
682 * Validate the name before we even try to open it.
683 */
684 if (!zfs_validate_name(hdl, path, types, B_FALSE)) {
685 (void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
686 return (NULL);
687 }
688
689 /*
690 * Bookmarks needs to be handled separately.
691 */
692 bookp = strchr(path, '#');
693 if (bookp == NULL) {
694 /*
695 * Try to get stats for the dataset, which will tell us if it
696 * exists.
697 */
698 errno = 0;
699 if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
700 (void) zfs_standard_error(hdl, errno, errbuf);
701 return (NULL);
702 }
703 } else {
704 char dsname[ZFS_MAX_DATASET_NAME_LEN];
705 zfs_handle_t *pzhp;
706 struct zfs_open_bookmarks_cb_data cb_data = {path, NULL};
707
708 /*
709 * We need to cut out '#' and everything after '#'
710 * to get the parent dataset name only.
711 */
712 assert(bookp - path < sizeof (dsname));
713 (void) strncpy(dsname, path, bookp - path);
714 dsname[bookp - path] = '\0';
715
716 /*
717 * Create handle for the parent dataset.
718 */
719 errno = 0;
720 if ((pzhp = make_dataset_handle(hdl, dsname)) == NULL) {
721 (void) zfs_standard_error(hdl, errno, errbuf);
722 return (NULL);
723 }
724
725 /*
726 * Iterate bookmarks to find the right one.
727 */
728 errno = 0;
729 if ((zfs_iter_bookmarks(pzhp, zfs_open_bookmarks_cb,
730 &cb_data) == 0) && (cb_data.zhp == NULL)) {
731 (void) zfs_error(hdl, EZFS_NOENT, errbuf);
732 zfs_close(pzhp);
733 return (NULL);
734 }
735 if (cb_data.zhp == NULL) {
736 (void) zfs_standard_error(hdl, errno, errbuf);
737 zfs_close(pzhp);
738 return (NULL);
739 }
740 zhp = cb_data.zhp;
741
742 /*
743 * Cleanup.
744 */
745 zfs_close(pzhp);
746 }
747
748 if (!(types & zhp->zfs_type)) {
749 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
750 zfs_close(zhp);
751 return (NULL);
752 }
753
754 return (zhp);
755 }
756
757 /*
758 * Release a ZFS handle. Nothing to do but free the associated memory.
759 */
760 void
761 zfs_close(zfs_handle_t *zhp)
762 {
763 if (zhp->zfs_mntopts)
764 free(zhp->zfs_mntopts);
765 nvlist_free(zhp->zfs_props);
766 nvlist_free(zhp->zfs_user_props);
767 nvlist_free(zhp->zfs_recvd_props);
768 free(zhp);
769 }
770
771 typedef struct mnttab_node {
772 struct mnttab mtn_mt;
773 avl_node_t mtn_node;
774 } mnttab_node_t;
775
776 static int
777 libzfs_mnttab_cache_compare(const void *arg1, const void *arg2)
778 {
779 const mnttab_node_t *mtn1 = (const mnttab_node_t *)arg1;
780 const mnttab_node_t *mtn2 = (const mnttab_node_t *)arg2;
781 int rv;
782
783 rv = strcmp(mtn1->mtn_mt.mnt_special, mtn2->mtn_mt.mnt_special);
784
785 return (AVL_ISIGN(rv));
786 }
787
788 void
789 libzfs_mnttab_init(libzfs_handle_t *hdl)
790 {
791 assert(avl_numnodes(&hdl->libzfs_mnttab_cache) == 0);
792 avl_create(&hdl->libzfs_mnttab_cache, libzfs_mnttab_cache_compare,
793 sizeof (mnttab_node_t), offsetof(mnttab_node_t, mtn_node));
794 }
795
796 int
797 libzfs_mnttab_update(libzfs_handle_t *hdl)
798 {
799 struct mnttab entry;
800
801 /* Reopen MNTTAB to prevent reading stale data from open file */
802 if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
803 return (ENOENT);
804
805 while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
806 mnttab_node_t *mtn;
807 avl_index_t where;
808
809 if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
810 continue;
811
812 mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
813 mtn->mtn_mt.mnt_special = zfs_strdup(hdl, entry.mnt_special);
814 mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, entry.mnt_mountp);
815 mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, entry.mnt_fstype);
816 mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, entry.mnt_mntopts);
817
818 /* Exclude duplicate mounts */
819 if (avl_find(&hdl->libzfs_mnttab_cache, mtn, &where) != NULL) {
820 free(mtn->mtn_mt.mnt_special);
821 free(mtn->mtn_mt.mnt_mountp);
822 free(mtn->mtn_mt.mnt_fstype);
823 free(mtn->mtn_mt.mnt_mntopts);
824 free(mtn);
825 continue;
826 }
827
828 avl_add(&hdl->libzfs_mnttab_cache, mtn);
829 }
830
831 return (0);
832 }
833
834 void
835 libzfs_mnttab_fini(libzfs_handle_t *hdl)
836 {
837 void *cookie = NULL;
838 mnttab_node_t *mtn;
839
840 while ((mtn = avl_destroy_nodes(&hdl->libzfs_mnttab_cache, &cookie))
841 != NULL) {
842 free(mtn->mtn_mt.mnt_special);
843 free(mtn->mtn_mt.mnt_mountp);
844 free(mtn->mtn_mt.mnt_fstype);
845 free(mtn->mtn_mt.mnt_mntopts);
846 free(mtn);
847 }
848 avl_destroy(&hdl->libzfs_mnttab_cache);
849 }
850
851 void
852 libzfs_mnttab_cache(libzfs_handle_t *hdl, boolean_t enable)
853 {
854 hdl->libzfs_mnttab_enable = enable;
855 }
856
857 int
858 libzfs_mnttab_find(libzfs_handle_t *hdl, const char *fsname,
859 struct mnttab *entry)
860 {
861 mnttab_node_t find;
862 mnttab_node_t *mtn;
863 int error;
864
865 if (!hdl->libzfs_mnttab_enable) {
866 struct mnttab srch = { 0 };
867
868 if (avl_numnodes(&hdl->libzfs_mnttab_cache))
869 libzfs_mnttab_fini(hdl);
870
871 /* Reopen MNTTAB to prevent reading stale data from open file */
872 if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
873 return (ENOENT);
874
875 srch.mnt_special = (char *)fsname;
876 srch.mnt_fstype = MNTTYPE_ZFS;
877 if (getmntany(hdl->libzfs_mnttab, entry, &srch) == 0)
878 return (0);
879 else
880 return (ENOENT);
881 }
882
883 if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0)
884 if ((error = libzfs_mnttab_update(hdl)) != 0)
885 return (error);
886
887 find.mtn_mt.mnt_special = (char *)fsname;
888 mtn = avl_find(&hdl->libzfs_mnttab_cache, &find, NULL);
889 if (mtn) {
890 *entry = mtn->mtn_mt;
891 return (0);
892 }
893 return (ENOENT);
894 }
895
896 void
897 libzfs_mnttab_add(libzfs_handle_t *hdl, const char *special,
898 const char *mountp, const char *mntopts)
899 {
900 mnttab_node_t *mtn;
901
902 if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0)
903 return;
904 mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
905 mtn->mtn_mt.mnt_special = zfs_strdup(hdl, special);
906 mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, mountp);
907 mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, MNTTYPE_ZFS);
908 mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, mntopts);
909 avl_add(&hdl->libzfs_mnttab_cache, mtn);
910 }
911
912 void
913 libzfs_mnttab_remove(libzfs_handle_t *hdl, const char *fsname)
914 {
915 mnttab_node_t find;
916 mnttab_node_t *ret;
917
918 find.mtn_mt.mnt_special = (char *)fsname;
919 if ((ret = avl_find(&hdl->libzfs_mnttab_cache, (void *)&find, NULL))
920 != NULL) {
921 avl_remove(&hdl->libzfs_mnttab_cache, ret);
922 free(ret->mtn_mt.mnt_special);
923 free(ret->mtn_mt.mnt_mountp);
924 free(ret->mtn_mt.mnt_fstype);
925 free(ret->mtn_mt.mnt_mntopts);
926 free(ret);
927 }
928 }
929
930 int
931 zfs_spa_version(zfs_handle_t *zhp, int *spa_version)
932 {
933 zpool_handle_t *zpool_handle = zhp->zpool_hdl;
934
935 if (zpool_handle == NULL)
936 return (-1);
937
938 *spa_version = zpool_get_prop_int(zpool_handle,
939 ZPOOL_PROP_VERSION, NULL);
940 return (0);
941 }
942
943 /*
944 * The choice of reservation property depends on the SPA version.
945 */
946 static int
947 zfs_which_resv_prop(zfs_handle_t *zhp, zfs_prop_t *resv_prop)
948 {
949 int spa_version;
950
951 if (zfs_spa_version(zhp, &spa_version) < 0)
952 return (-1);
953
954 if (spa_version >= SPA_VERSION_REFRESERVATION)
955 *resv_prop = ZFS_PROP_REFRESERVATION;
956 else
957 *resv_prop = ZFS_PROP_RESERVATION;
958
959 return (0);
960 }
961
962 /*
963 * Given an nvlist of properties to set, validates that they are correct, and
964 * parses any numeric properties (index, boolean, etc) if they are specified as
965 * strings.
966 */
967 nvlist_t *
968 zfs_valid_proplist(libzfs_handle_t *hdl, zfs_type_t type, nvlist_t *nvl,
969 uint64_t zoned, zfs_handle_t *zhp, zpool_handle_t *zpool_hdl,
970 boolean_t key_params_ok, const char *errbuf)
971 {
972 nvpair_t *elem;
973 uint64_t intval;
974 char *strval;
975 zfs_prop_t prop;
976 nvlist_t *ret;
977 int chosen_normal = -1;
978 int chosen_utf = -1;
979
980 if (nvlist_alloc(&ret, NV_UNIQUE_NAME, 0) != 0) {
981 (void) no_memory(hdl);
982 return (NULL);
983 }
984
985 /*
986 * Make sure this property is valid and applies to this type.
987 */
988
989 elem = NULL;
990 while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
991 const char *propname = nvpair_name(elem);
992
993 prop = zfs_name_to_prop(propname);
994 if (prop == ZPROP_INVAL && zfs_prop_user(propname)) {
995 /*
996 * This is a user property: make sure it's a
997 * string, and that it's less than ZAP_MAXNAMELEN.
998 */
999 if (nvpair_type(elem) != DATA_TYPE_STRING) {
1000 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1001 "'%s' must be a string"), propname);
1002 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1003 goto error;
1004 }
1005
1006 if (strlen(nvpair_name(elem)) >= ZAP_MAXNAMELEN) {
1007 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1008 "property name '%s' is too long"),
1009 propname);
1010 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1011 goto error;
1012 }
1013
1014 (void) nvpair_value_string(elem, &strval);
1015 if (nvlist_add_string(ret, propname, strval) != 0) {
1016 (void) no_memory(hdl);
1017 goto error;
1018 }
1019 continue;
1020 }
1021
1022 /*
1023 * Currently, only user properties can be modified on
1024 * snapshots.
1025 */
1026 if (type == ZFS_TYPE_SNAPSHOT) {
1027 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1028 "this property can not be modified for snapshots"));
1029 (void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
1030 goto error;
1031 }
1032
1033 if (prop == ZPROP_INVAL && zfs_prop_userquota(propname)) {
1034 zfs_userquota_prop_t uqtype;
1035 char newpropname[128];
1036 char domain[128];
1037 uint64_t rid;
1038 uint64_t valary[3];
1039
1040 if (userquota_propname_decode(propname, zoned,
1041 &uqtype, domain, sizeof (domain), &rid) != 0) {
1042 zfs_error_aux(hdl,
1043 dgettext(TEXT_DOMAIN,
1044 "'%s' has an invalid user/group name"),
1045 propname);
1046 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1047 goto error;
1048 }
1049
1050 if (uqtype != ZFS_PROP_USERQUOTA &&
1051 uqtype != ZFS_PROP_GROUPQUOTA &&
1052 uqtype != ZFS_PROP_USEROBJQUOTA &&
1053 uqtype != ZFS_PROP_GROUPOBJQUOTA) {
1054 zfs_error_aux(hdl,
1055 dgettext(TEXT_DOMAIN, "'%s' is readonly"),
1056 propname);
1057 (void) zfs_error(hdl, EZFS_PROPREADONLY,
1058 errbuf);
1059 goto error;
1060 }
1061
1062 if (nvpair_type(elem) == DATA_TYPE_STRING) {
1063 (void) nvpair_value_string(elem, &strval);
1064 if (strcmp(strval, "none") == 0) {
1065 intval = 0;
1066 } else if (zfs_nicestrtonum(hdl,
1067 strval, &intval) != 0) {
1068 (void) zfs_error(hdl,
1069 EZFS_BADPROP, errbuf);
1070 goto error;
1071 }
1072 } else if (nvpair_type(elem) ==
1073 DATA_TYPE_UINT64) {
1074 (void) nvpair_value_uint64(elem, &intval);
1075 if (intval == 0) {
1076 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1077 "use 'none' to disable "
1078 "userquota/groupquota"));
1079 goto error;
1080 }
1081 } else {
1082 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1083 "'%s' must be a number"), propname);
1084 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1085 goto error;
1086 }
1087
1088 /*
1089 * Encode the prop name as
1090 * userquota@<hex-rid>-domain, to make it easy
1091 * for the kernel to decode.
1092 */
1093 (void) snprintf(newpropname, sizeof (newpropname),
1094 "%s%llx-%s", zfs_userquota_prop_prefixes[uqtype],
1095 (longlong_t)rid, domain);
1096 valary[0] = uqtype;
1097 valary[1] = rid;
1098 valary[2] = intval;
1099 if (nvlist_add_uint64_array(ret, newpropname,
1100 valary, 3) != 0) {
1101 (void) no_memory(hdl);
1102 goto error;
1103 }
1104 continue;
1105 } else if (prop == ZPROP_INVAL && zfs_prop_written(propname)) {
1106 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1107 "'%s' is readonly"),
1108 propname);
1109 (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
1110 goto error;
1111 }
1112
1113 if (prop == ZPROP_INVAL) {
1114 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1115 "invalid property '%s'"), propname);
1116 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1117 goto error;
1118 }
1119
1120 if (!zfs_prop_valid_for_type(prop, type, B_FALSE)) {
1121 zfs_error_aux(hdl,
1122 dgettext(TEXT_DOMAIN, "'%s' does not "
1123 "apply to datasets of this type"), propname);
1124 (void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
1125 goto error;
1126 }
1127
1128 if (zfs_prop_readonly(prop) &&
1129 !(zfs_prop_setonce(prop) && zhp == NULL) &&
1130 !(zfs_prop_encryption_key_param(prop) && key_params_ok)) {
1131 zfs_error_aux(hdl,
1132 dgettext(TEXT_DOMAIN, "'%s' is readonly"),
1133 propname);
1134 (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
1135 goto error;
1136 }
1137
1138 if (zprop_parse_value(hdl, elem, prop, type, ret,
1139 &strval, &intval, errbuf) != 0)
1140 goto error;
1141
1142 /*
1143 * Perform some additional checks for specific properties.
1144 */
1145 switch (prop) {
1146 case ZFS_PROP_VERSION:
1147 {
1148 int version;
1149
1150 if (zhp == NULL)
1151 break;
1152 version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1153 if (intval < version) {
1154 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1155 "Can not downgrade; already at version %u"),
1156 version);
1157 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1158 goto error;
1159 }
1160 break;
1161 }
1162
1163 case ZFS_PROP_VOLBLOCKSIZE:
1164 case ZFS_PROP_RECORDSIZE:
1165 {
1166 int maxbs = SPA_MAXBLOCKSIZE;
1167 char buf[64];
1168
1169 if (zpool_hdl != NULL) {
1170 maxbs = zpool_get_prop_int(zpool_hdl,
1171 ZPOOL_PROP_MAXBLOCKSIZE, NULL);
1172 }
1173 /*
1174 * The value must be a power of two between
1175 * SPA_MINBLOCKSIZE and maxbs.
1176 */
1177 if (intval < SPA_MINBLOCKSIZE ||
1178 intval > maxbs || !ISP2(intval)) {
1179 zfs_nicebytes(maxbs, buf, sizeof (buf));
1180 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1181 "'%s' must be power of 2 from 512B "
1182 "to %s"), propname, buf);
1183 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1184 goto error;
1185 }
1186 break;
1187 }
1188 case ZFS_PROP_MLSLABEL:
1189 {
1190 #ifdef HAVE_MLSLABEL
1191 /*
1192 * Verify the mlslabel string and convert to
1193 * internal hex label string.
1194 */
1195
1196 m_label_t *new_sl;
1197 char *hex = NULL; /* internal label string */
1198
1199 /* Default value is already OK. */
1200 if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
1201 break;
1202
1203 /* Verify the label can be converted to binary form */
1204 if (((new_sl = m_label_alloc(MAC_LABEL)) == NULL) ||
1205 (str_to_label(strval, &new_sl, MAC_LABEL,
1206 L_NO_CORRECTION, NULL) == -1)) {
1207 goto badlabel;
1208 }
1209
1210 /* Now translate to hex internal label string */
1211 if (label_to_str(new_sl, &hex, M_INTERNAL,
1212 DEF_NAMES) != 0) {
1213 if (hex)
1214 free(hex);
1215 goto badlabel;
1216 }
1217 m_label_free(new_sl);
1218
1219 /* If string is already in internal form, we're done. */
1220 if (strcmp(strval, hex) == 0) {
1221 free(hex);
1222 break;
1223 }
1224
1225 /* Replace the label string with the internal form. */
1226 (void) nvlist_remove(ret, zfs_prop_to_name(prop),
1227 DATA_TYPE_STRING);
1228 verify(nvlist_add_string(ret, zfs_prop_to_name(prop),
1229 hex) == 0);
1230 free(hex);
1231
1232 break;
1233
1234 badlabel:
1235 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1236 "invalid mlslabel '%s'"), strval);
1237 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1238 m_label_free(new_sl); /* OK if null */
1239 goto error;
1240 #else
1241 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1242 "mlslabels are unsupported"));
1243 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1244 goto error;
1245 #endif /* HAVE_MLSLABEL */
1246 }
1247
1248 case ZFS_PROP_MOUNTPOINT:
1249 {
1250 namecheck_err_t why;
1251
1252 if (strcmp(strval, ZFS_MOUNTPOINT_NONE) == 0 ||
1253 strcmp(strval, ZFS_MOUNTPOINT_LEGACY) == 0)
1254 break;
1255
1256 if (mountpoint_namecheck(strval, &why)) {
1257 switch (why) {
1258 case NAME_ERR_LEADING_SLASH:
1259 zfs_error_aux(hdl,
1260 dgettext(TEXT_DOMAIN,
1261 "'%s' must be an absolute path, "
1262 "'none', or 'legacy'"), propname);
1263 break;
1264 case NAME_ERR_TOOLONG:
1265 zfs_error_aux(hdl,
1266 dgettext(TEXT_DOMAIN,
1267 "component of '%s' is too long"),
1268 propname);
1269 break;
1270
1271 default:
1272 zfs_error_aux(hdl,
1273 dgettext(TEXT_DOMAIN,
1274 "(%d) not defined"),
1275 why);
1276 break;
1277 }
1278 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1279 goto error;
1280 }
1281 }
1282
1283 /*FALLTHRU*/
1284
1285 case ZFS_PROP_SHARESMB:
1286 case ZFS_PROP_SHARENFS:
1287 /*
1288 * For the mountpoint and sharenfs or sharesmb
1289 * properties, check if it can be set in a
1290 * global/non-global zone based on
1291 * the zoned property value:
1292 *
1293 * global zone non-global zone
1294 * --------------------------------------------------
1295 * zoned=on mountpoint (no) mountpoint (yes)
1296 * sharenfs (no) sharenfs (no)
1297 * sharesmb (no) sharesmb (no)
1298 *
1299 * zoned=off mountpoint (yes) N/A
1300 * sharenfs (yes)
1301 * sharesmb (yes)
1302 */
1303 if (zoned) {
1304 if (getzoneid() == GLOBAL_ZONEID) {
1305 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1306 "'%s' cannot be set on "
1307 "dataset in a non-global zone"),
1308 propname);
1309 (void) zfs_error(hdl, EZFS_ZONED,
1310 errbuf);
1311 goto error;
1312 } else if (prop == ZFS_PROP_SHARENFS ||
1313 prop == ZFS_PROP_SHARESMB) {
1314 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1315 "'%s' cannot be set in "
1316 "a non-global zone"), propname);
1317 (void) zfs_error(hdl, EZFS_ZONED,
1318 errbuf);
1319 goto error;
1320 }
1321 } else if (getzoneid() != GLOBAL_ZONEID) {
1322 /*
1323 * If zoned property is 'off', this must be in
1324 * a global zone. If not, something is wrong.
1325 */
1326 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1327 "'%s' cannot be set while dataset "
1328 "'zoned' property is set"), propname);
1329 (void) zfs_error(hdl, EZFS_ZONED, errbuf);
1330 goto error;
1331 }
1332
1333 /*
1334 * At this point, it is legitimate to set the
1335 * property. Now we want to make sure that the
1336 * property value is valid if it is sharenfs.
1337 */
1338 if ((prop == ZFS_PROP_SHARENFS ||
1339 prop == ZFS_PROP_SHARESMB) &&
1340 strcmp(strval, "on") != 0 &&
1341 strcmp(strval, "off") != 0) {
1342 zfs_share_proto_t proto;
1343
1344 if (prop == ZFS_PROP_SHARESMB)
1345 proto = PROTO_SMB;
1346 else
1347 proto = PROTO_NFS;
1348
1349 /*
1350 * Must be an valid sharing protocol
1351 * option string so init the libshare
1352 * in order to enable the parser and
1353 * then parse the options. We use the
1354 * control API since we don't care about
1355 * the current configuration and don't
1356 * want the overhead of loading it
1357 * until we actually do something.
1358 */
1359
1360 if (zfs_init_libshare(hdl,
1361 SA_INIT_CONTROL_API) != SA_OK) {
1362 /*
1363 * An error occurred so we can't do
1364 * anything
1365 */
1366 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1367 "'%s' cannot be set: problem "
1368 "in share initialization"),
1369 propname);
1370 (void) zfs_error(hdl, EZFS_BADPROP,
1371 errbuf);
1372 goto error;
1373 }
1374
1375 if (zfs_parse_options(strval, proto) != SA_OK) {
1376 /*
1377 * There was an error in parsing so
1378 * deal with it by issuing an error
1379 * message and leaving after
1380 * uninitializing the the libshare
1381 * interface.
1382 */
1383 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1384 "'%s' cannot be set to invalid "
1385 "options"), propname);
1386 (void) zfs_error(hdl, EZFS_BADPROP,
1387 errbuf);
1388 zfs_uninit_libshare(hdl);
1389 goto error;
1390 }
1391 zfs_uninit_libshare(hdl);
1392 }
1393
1394 break;
1395
1396 case ZFS_PROP_KEYLOCATION:
1397 if (!zfs_prop_valid_keylocation(strval, B_FALSE)) {
1398 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1399 "invalid keylocation"));
1400 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1401 goto error;
1402 }
1403
1404 if (zhp != NULL) {
1405 uint64_t crypt =
1406 zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);
1407
1408 if (crypt == ZIO_CRYPT_OFF &&
1409 strcmp(strval, "none") != 0) {
1410 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1411 "keylocation must not be 'none' "
1412 "for encrypted datasets"));
1413 (void) zfs_error(hdl, EZFS_BADPROP,
1414 errbuf);
1415 goto error;
1416 } else if (crypt != ZIO_CRYPT_OFF &&
1417 strcmp(strval, "none") == 0) {
1418 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1419 "keylocation must be 'none' "
1420 "for unencrypted datasets"));
1421 (void) zfs_error(hdl, EZFS_BADPROP,
1422 errbuf);
1423 goto error;
1424 }
1425 }
1426 break;
1427
1428 case ZFS_PROP_PBKDF2_ITERS:
1429 if (intval < MIN_PBKDF2_ITERATIONS) {
1430 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1431 "minimum pbkdf2 iterations is %u"),
1432 MIN_PBKDF2_ITERATIONS);
1433 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1434 goto error;
1435 }
1436 break;
1437
1438 case ZFS_PROP_UTF8ONLY:
1439 chosen_utf = (int)intval;
1440 break;
1441
1442 case ZFS_PROP_NORMALIZE:
1443 chosen_normal = (int)intval;
1444 break;
1445
1446 default:
1447 break;
1448 }
1449
1450 /*
1451 * For changes to existing volumes, we have some additional
1452 * checks to enforce.
1453 */
1454 if (type == ZFS_TYPE_VOLUME && zhp != NULL) {
1455 uint64_t blocksize = zfs_prop_get_int(zhp,
1456 ZFS_PROP_VOLBLOCKSIZE);
1457 char buf[64];
1458
1459 switch (prop) {
1460 case ZFS_PROP_VOLSIZE:
1461 if (intval % blocksize != 0) {
1462 zfs_nicebytes(blocksize, buf,
1463 sizeof (buf));
1464 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1465 "'%s' must be a multiple of "
1466 "volume block size (%s)"),
1467 propname, buf);
1468 (void) zfs_error(hdl, EZFS_BADPROP,
1469 errbuf);
1470 goto error;
1471 }
1472
1473 if (intval == 0) {
1474 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1475 "'%s' cannot be zero"),
1476 propname);
1477 (void) zfs_error(hdl, EZFS_BADPROP,
1478 errbuf);
1479 goto error;
1480 }
1481 break;
1482
1483 default:
1484 break;
1485 }
1486 }
1487
1488 /* check encryption properties */
1489 if (zhp != NULL) {
1490 int64_t crypt = zfs_prop_get_int(zhp,
1491 ZFS_PROP_ENCRYPTION);
1492
1493 switch (prop) {
1494 case ZFS_PROP_COPIES:
1495 if (crypt != ZIO_CRYPT_OFF && intval > 2) {
1496 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1497 "encrypted datasets cannot have "
1498 "3 copies"));
1499 (void) zfs_error(hdl, EZFS_BADPROP,
1500 errbuf);
1501 goto error;
1502 }
1503 break;
1504 default:
1505 break;
1506 }
1507 }
1508 }
1509
1510 /*
1511 * If normalization was chosen, but no UTF8 choice was made,
1512 * enforce rejection of non-UTF8 names.
1513 *
1514 * If normalization was chosen, but rejecting non-UTF8 names
1515 * was explicitly not chosen, it is an error.
1516 */
1517 if (chosen_normal > 0 && chosen_utf < 0) {
1518 if (nvlist_add_uint64(ret,
1519 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), 1) != 0) {
1520 (void) no_memory(hdl);
1521 goto error;
1522 }
1523 } else if (chosen_normal > 0 && chosen_utf == 0) {
1524 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1525 "'%s' must be set 'on' if normalization chosen"),
1526 zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
1527 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1528 goto error;
1529 }
1530 return (ret);
1531
1532 error:
1533 nvlist_free(ret);
1534 return (NULL);
1535 }
1536
1537 int
1538 zfs_add_synthetic_resv(zfs_handle_t *zhp, nvlist_t *nvl)
1539 {
1540 uint64_t old_volsize;
1541 uint64_t new_volsize;
1542 uint64_t old_reservation;
1543 uint64_t new_reservation;
1544 zfs_prop_t resv_prop;
1545 nvlist_t *props;
1546
1547 /*
1548 * If this is an existing volume, and someone is setting the volsize,
1549 * make sure that it matches the reservation, or add it if necessary.
1550 */
1551 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1552 if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
1553 return (-1);
1554 old_reservation = zfs_prop_get_int(zhp, resv_prop);
1555
1556 props = fnvlist_alloc();
1557 fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
1558 zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));
1559
1560 if ((zvol_volsize_to_reservation(old_volsize, props) !=
1561 old_reservation) || nvlist_exists(nvl,
1562 zfs_prop_to_name(resv_prop))) {
1563 fnvlist_free(props);
1564 return (0);
1565 }
1566 if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1567 &new_volsize) != 0) {
1568 fnvlist_free(props);
1569 return (-1);
1570 }
1571 new_reservation = zvol_volsize_to_reservation(new_volsize, props);
1572 fnvlist_free(props);
1573
1574 if (nvlist_add_uint64(nvl, zfs_prop_to_name(resv_prop),
1575 new_reservation) != 0) {
1576 (void) no_memory(zhp->zfs_hdl);
1577 return (-1);
1578 }
1579 return (1);
1580 }
1581
1582 void
1583 zfs_setprop_error(libzfs_handle_t *hdl, zfs_prop_t prop, int err,
1584 char *errbuf)
1585 {
1586 switch (err) {
1587
1588 case ENOSPC:
1589 /*
1590 * For quotas and reservations, ENOSPC indicates
1591 * something different; setting a quota or reservation
1592 * doesn't use any disk space.
1593 */
1594 switch (prop) {
1595 case ZFS_PROP_QUOTA:
1596 case ZFS_PROP_REFQUOTA:
1597 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1598 "size is less than current used or "
1599 "reserved space"));
1600 (void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
1601 break;
1602
1603 case ZFS_PROP_RESERVATION:
1604 case ZFS_PROP_REFRESERVATION:
1605 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1606 "size is greater than available space"));
1607 (void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
1608 break;
1609
1610 default:
1611 (void) zfs_standard_error(hdl, err, errbuf);
1612 break;
1613 }
1614 break;
1615
1616 case EBUSY:
1617 (void) zfs_standard_error(hdl, EBUSY, errbuf);
1618 break;
1619
1620 case EROFS:
1621 (void) zfs_error(hdl, EZFS_DSREADONLY, errbuf);
1622 break;
1623
1624 case E2BIG:
1625 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1626 "property value too long"));
1627 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1628 break;
1629
1630 case ENOTSUP:
1631 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1632 "pool and or dataset must be upgraded to set this "
1633 "property or value"));
1634 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
1635 break;
1636
1637 case ERANGE:
1638 if (prop == ZFS_PROP_COMPRESSION ||
1639 prop == ZFS_PROP_DNODESIZE ||
1640 prop == ZFS_PROP_RECORDSIZE) {
1641 (void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1642 "property setting is not allowed on "
1643 "bootable datasets"));
1644 (void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
1645 } else if (prop == ZFS_PROP_CHECKSUM ||
1646 prop == ZFS_PROP_DEDUP) {
1647 (void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1648 "property setting is not allowed on "
1649 "root pools"));
1650 (void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
1651 } else {
1652 (void) zfs_standard_error(hdl, err, errbuf);
1653 }
1654 break;
1655
1656 case EINVAL:
1657 if (prop == ZPROP_INVAL) {
1658 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1659 } else {
1660 (void) zfs_standard_error(hdl, err, errbuf);
1661 }
1662 break;
1663
1664 case EACCES:
1665 if (prop == ZFS_PROP_KEYLOCATION) {
1666 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1667 "keylocation may only be set on encryption roots"));
1668 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1669 } else {
1670 (void) zfs_standard_error(hdl, err, errbuf);
1671 }
1672 break;
1673
1674 case EOVERFLOW:
1675 /*
1676 * This platform can't address a volume this big.
1677 */
1678 #ifdef _ILP32
1679 if (prop == ZFS_PROP_VOLSIZE) {
1680 (void) zfs_error(hdl, EZFS_VOLTOOBIG, errbuf);
1681 break;
1682 }
1683 #endif
1684 /* FALLTHROUGH */
1685 default:
1686 (void) zfs_standard_error(hdl, err, errbuf);
1687 }
1688 }
1689
1690 static boolean_t
1691 zfs_is_namespace_prop(zfs_prop_t prop)
1692 {
1693 switch (prop) {
1694
1695 case ZFS_PROP_ATIME:
1696 case ZFS_PROP_RELATIME:
1697 case ZFS_PROP_DEVICES:
1698 case ZFS_PROP_EXEC:
1699 case ZFS_PROP_SETUID:
1700 case ZFS_PROP_READONLY:
1701 case ZFS_PROP_XATTR:
1702 case ZFS_PROP_NBMAND:
1703 return (B_TRUE);
1704
1705 default:
1706 return (B_FALSE);
1707 }
1708 }
1709
1710 /*
1711 * Given a property name and value, set the property for the given dataset.
1712 */
1713 int
1714 zfs_prop_set(zfs_handle_t *zhp, const char *propname, const char *propval)
1715 {
1716 int ret = -1;
1717 char errbuf[1024];
1718 libzfs_handle_t *hdl = zhp->zfs_hdl;
1719 nvlist_t *nvl = NULL;
1720
1721 (void) snprintf(errbuf, sizeof (errbuf),
1722 dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
1723 zhp->zfs_name);
1724
1725 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0 ||
1726 nvlist_add_string(nvl, propname, propval) != 0) {
1727 (void) no_memory(hdl);
1728 goto error;
1729 }
1730
1731 ret = zfs_prop_set_list(zhp, nvl);
1732
1733 error:
1734 nvlist_free(nvl);
1735 return (ret);
1736 }
1737
1738
1739
1740 /*
1741 * Given an nvlist of property names and values, set the properties for the
1742 * given dataset.
1743 */
1744 int
1745 zfs_prop_set_list(zfs_handle_t *zhp, nvlist_t *props)
1746 {
1747 zfs_cmd_t zc = {"\0"};
1748 int ret = -1;
1749 prop_changelist_t **cls = NULL;
1750 int cl_idx;
1751 char errbuf[1024];
1752 libzfs_handle_t *hdl = zhp->zfs_hdl;
1753 nvlist_t *nvl;
1754 int nvl_len = 0;
1755 int added_resv = 0;
1756 zfs_prop_t prop = 0;
1757 nvpair_t *elem;
1758
1759 (void) snprintf(errbuf, sizeof (errbuf),
1760 dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
1761 zhp->zfs_name);
1762
1763 if ((nvl = zfs_valid_proplist(hdl, zhp->zfs_type, props,
1764 zfs_prop_get_int(zhp, ZFS_PROP_ZONED), zhp, zhp->zpool_hdl,
1765 B_FALSE, errbuf)) == NULL)
1766 goto error;
1767
1768 /*
1769 * We have to check for any extra properties which need to be added
1770 * before computing the length of the nvlist.
1771 */
1772 for (elem = nvlist_next_nvpair(nvl, NULL);
1773 elem != NULL;
1774 elem = nvlist_next_nvpair(nvl, elem)) {
1775 if (zfs_name_to_prop(nvpair_name(elem)) == ZFS_PROP_VOLSIZE &&
1776 (added_resv = zfs_add_synthetic_resv(zhp, nvl)) == -1) {
1777 goto error;
1778 }
1779 }
1780 /*
1781 * Check how many properties we're setting and allocate an array to
1782 * store changelist pointers for postfix().
1783 */
1784 for (elem = nvlist_next_nvpair(nvl, NULL);
1785 elem != NULL;
1786 elem = nvlist_next_nvpair(nvl, elem))
1787 nvl_len++;
1788 if ((cls = calloc(nvl_len, sizeof (prop_changelist_t *))) == NULL)
1789 goto error;
1790
1791 cl_idx = 0;
1792 for (elem = nvlist_next_nvpair(nvl, NULL);
1793 elem != NULL;
1794 elem = nvlist_next_nvpair(nvl, elem)) {
1795
1796 prop = zfs_name_to_prop(nvpair_name(elem));
1797
1798 assert(cl_idx < nvl_len);
1799 /*
1800 * We don't want to unmount & remount the dataset when changing
1801 * its canmount property to 'on' or 'noauto'. We only use
1802 * the changelist logic to unmount when setting canmount=off.
1803 */
1804 if (prop != ZFS_PROP_CANMOUNT ||
1805 (fnvpair_value_uint64(elem) == ZFS_CANMOUNT_OFF &&
1806 zfs_is_mounted(zhp, NULL))) {
1807 cls[cl_idx] = changelist_gather(zhp, prop, 0, 0);
1808 if (cls[cl_idx] == NULL)
1809 goto error;
1810 }
1811
1812 if (prop == ZFS_PROP_MOUNTPOINT &&
1813 changelist_haszonedchild(cls[cl_idx])) {
1814 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1815 "child dataset with inherited mountpoint is used "
1816 "in a non-global zone"));
1817 ret = zfs_error(hdl, EZFS_ZONED, errbuf);
1818 goto error;
1819 }
1820
1821 if (cls[cl_idx] != NULL &&
1822 (ret = changelist_prefix(cls[cl_idx])) != 0)
1823 goto error;
1824
1825 cl_idx++;
1826 }
1827 assert(cl_idx == nvl_len);
1828
1829 /*
1830 * Execute the corresponding ioctl() to set this list of properties.
1831 */
1832 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1833
1834 if ((ret = zcmd_write_src_nvlist(hdl, &zc, nvl)) != 0 ||
1835 (ret = zcmd_alloc_dst_nvlist(hdl, &zc, 0)) != 0)
1836 goto error;
1837
1838 ret = zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
1839
1840 if (ret != 0) {
1841 /* Get the list of unset properties back and report them. */
1842 nvlist_t *errorprops = NULL;
1843 if (zcmd_read_dst_nvlist(hdl, &zc, &errorprops) != 0)
1844 goto error;
1845 for (elem = nvlist_next_nvpair(nvl, NULL);
1846 elem != NULL;
1847 elem = nvlist_next_nvpair(nvl, elem)) {
1848 prop = zfs_name_to_prop(nvpair_name(elem));
1849 zfs_setprop_error(hdl, prop, errno, errbuf);
1850 }
1851 nvlist_free(errorprops);
1852
1853 if (added_resv && errno == ENOSPC) {
1854 /* clean up the volsize property we tried to set */
1855 uint64_t old_volsize = zfs_prop_get_int(zhp,
1856 ZFS_PROP_VOLSIZE);
1857 nvlist_free(nvl);
1858 nvl = NULL;
1859 zcmd_free_nvlists(&zc);
1860
1861 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
1862 goto error;
1863 if (nvlist_add_uint64(nvl,
1864 zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1865 old_volsize) != 0)
1866 goto error;
1867 if (zcmd_write_src_nvlist(hdl, &zc, nvl) != 0)
1868 goto error;
1869 (void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
1870 }
1871 } else {
1872 for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
1873 if (cls[cl_idx] != NULL) {
1874 int clp_err = changelist_postfix(cls[cl_idx]);
1875 if (clp_err != 0)
1876 ret = clp_err;
1877 }
1878 }
1879
1880 if (ret == 0) {
1881 /*
1882 * Refresh the statistics so the new property
1883 * value is reflected.
1884 */
1885 (void) get_stats(zhp);
1886
1887 /*
1888 * Remount the filesystem to propagate the change
1889 * if one of the options handled by the generic
1890 * Linux namespace layer has been modified.
1891 */
1892 if (zfs_is_namespace_prop(prop) &&
1893 zfs_is_mounted(zhp, NULL))
1894 ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0);
1895 }
1896 }
1897
1898 error:
1899 nvlist_free(nvl);
1900 zcmd_free_nvlists(&zc);
1901 if (cls != NULL) {
1902 for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
1903 if (cls[cl_idx] != NULL)
1904 changelist_free(cls[cl_idx]);
1905 }
1906 free(cls);
1907 }
1908 return (ret);
1909 }
1910
1911 /*
1912 * Given a property, inherit the value from the parent dataset, or if received
1913 * is TRUE, revert to the received value, if any.
1914 */
1915 int
1916 zfs_prop_inherit(zfs_handle_t *zhp, const char *propname, boolean_t received)
1917 {
1918 zfs_cmd_t zc = {"\0"};
1919 int ret;
1920 prop_changelist_t *cl;
1921 libzfs_handle_t *hdl = zhp->zfs_hdl;
1922 char errbuf[1024];
1923 zfs_prop_t prop;
1924
1925 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
1926 "cannot inherit %s for '%s'"), propname, zhp->zfs_name);
1927
1928 zc.zc_cookie = received;
1929 if ((prop = zfs_name_to_prop(propname)) == ZPROP_INVAL) {
1930 /*
1931 * For user properties, the amount of work we have to do is very
1932 * small, so just do it here.
1933 */
1934 if (!zfs_prop_user(propname)) {
1935 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1936 "invalid property"));
1937 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
1938 }
1939
1940 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1941 (void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));
1942
1943 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc) != 0)
1944 return (zfs_standard_error(hdl, errno, errbuf));
1945
1946 return (0);
1947 }
1948
1949 /*
1950 * Verify that this property is inheritable.
1951 */
1952 if (zfs_prop_readonly(prop))
1953 return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf));
1954
1955 if (!zfs_prop_inheritable(prop) && !received)
1956 return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf));
1957
1958 /*
1959 * Check to see if the value applies to this type
1960 */
1961 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE))
1962 return (zfs_error(hdl, EZFS_PROPTYPE, errbuf));
1963
1964 /*
1965 * Normalize the name, to get rid of shorthand abbreviations.
1966 */
1967 propname = zfs_prop_to_name(prop);
1968 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1969 (void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));
1970
1971 if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID &&
1972 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
1973 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1974 "dataset is used in a non-global zone"));
1975 return (zfs_error(hdl, EZFS_ZONED, errbuf));
1976 }
1977
1978 /*
1979 * Determine datasets which will be affected by this change, if any.
1980 */
1981 if ((cl = changelist_gather(zhp, prop, 0, 0)) == NULL)
1982 return (-1);
1983
1984 if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) {
1985 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1986 "child dataset with inherited mountpoint is used "
1987 "in a non-global zone"));
1988 ret = zfs_error(hdl, EZFS_ZONED, errbuf);
1989 goto error;
1990 }
1991
1992 if ((ret = changelist_prefix(cl)) != 0)
1993 goto error;
1994
1995 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc)) != 0) {
1996 return (zfs_standard_error(hdl, errno, errbuf));
1997 } else {
1998
1999 if ((ret = changelist_postfix(cl)) != 0)
2000 goto error;
2001
2002 /*
2003 * Refresh the statistics so the new property is reflected.
2004 */
2005 (void) get_stats(zhp);
2006
2007 /*
2008 * Remount the filesystem to propagate the change
2009 * if one of the options handled by the generic
2010 * Linux namespace layer has been modified.
2011 */
2012 if (zfs_is_namespace_prop(prop) &&
2013 zfs_is_mounted(zhp, NULL))
2014 ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0);
2015 }
2016
2017 error:
2018 changelist_free(cl);
2019 return (ret);
2020 }
2021
2022 /*
2023 * True DSL properties are stored in an nvlist. The following two functions
2024 * extract them appropriately.
2025 */
2026 uint64_t
2027 getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
2028 {
2029 nvlist_t *nv;
2030 uint64_t value;
2031
2032 *source = NULL;
2033 if (nvlist_lookup_nvlist(zhp->zfs_props,
2034 zfs_prop_to_name(prop), &nv) == 0) {
2035 verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);
2036 (void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
2037 } else {
2038 verify(!zhp->zfs_props_table ||
2039 zhp->zfs_props_table[prop] == B_TRUE);
2040 value = zfs_prop_default_numeric(prop);
2041 *source = "";
2042 }
2043
2044 return (value);
2045 }
2046
2047 static const char *
2048 getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
2049 {
2050 nvlist_t *nv;
2051 const char *value;
2052
2053 *source = NULL;
2054 if (nvlist_lookup_nvlist(zhp->zfs_props,
2055 zfs_prop_to_name(prop), &nv) == 0) {
2056 value = fnvlist_lookup_string(nv, ZPROP_VALUE);
2057 (void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
2058 } else {
2059 verify(!zhp->zfs_props_table ||
2060 zhp->zfs_props_table[prop] == B_TRUE);
2061 value = zfs_prop_default_string(prop);
2062 *source = "";
2063 }
2064
2065 return (value);
2066 }
2067
2068 static boolean_t
2069 zfs_is_recvd_props_mode(zfs_handle_t *zhp)
2070 {
2071 return (zhp->zfs_props == zhp->zfs_recvd_props);
2072 }
2073
2074 static void
2075 zfs_set_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
2076 {
2077 *cookie = (uint64_t)(uintptr_t)zhp->zfs_props;
2078 zhp->zfs_props = zhp->zfs_recvd_props;
2079 }
2080
2081 static void
2082 zfs_unset_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
2083 {
2084 zhp->zfs_props = (nvlist_t *)(uintptr_t)*cookie;
2085 *cookie = 0;
2086 }
2087
2088 /*
2089 * Internal function for getting a numeric property. Both zfs_prop_get() and
2090 * zfs_prop_get_int() are built using this interface.
2091 *
2092 * Certain properties can be overridden using 'mount -o'. In this case, scan
2093 * the contents of the /proc/self/mounts entry, searching for the
2094 * appropriate options. If they differ from the on-disk values, report the
2095 * current values and mark the source "temporary".
2096 */
2097 static int
2098 get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zprop_source_t *src,
2099 char **source, uint64_t *val)
2100 {
2101 zfs_cmd_t zc = {"\0"};
2102 nvlist_t *zplprops = NULL;
2103 struct mnttab mnt;
2104 char *mntopt_on = NULL;
2105 char *mntopt_off = NULL;
2106 boolean_t received = zfs_is_recvd_props_mode(zhp);
2107
2108 *source = NULL;
2109
2110 /*
2111 * If the property is being fetched for a snapshot, check whether
2112 * the property is valid for the snapshot's head dataset type.
2113 */
2114 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT &&
2115 !zfs_prop_valid_for_type(prop, zhp->zfs_head_type, B_TRUE)) {
2116 *val = zfs_prop_default_numeric(prop);
2117 return (-1);
2118 }
2119
2120 switch (prop) {
2121 case ZFS_PROP_ATIME:
2122 mntopt_on = MNTOPT_ATIME;
2123 mntopt_off = MNTOPT_NOATIME;
2124 break;
2125
2126 case ZFS_PROP_RELATIME:
2127 mntopt_on = MNTOPT_RELATIME;
2128 mntopt_off = MNTOPT_NORELATIME;
2129 break;
2130
2131 case ZFS_PROP_DEVICES:
2132 mntopt_on = MNTOPT_DEVICES;
2133 mntopt_off = MNTOPT_NODEVICES;
2134 break;
2135
2136 case ZFS_PROP_EXEC:
2137 mntopt_on = MNTOPT_EXEC;
2138 mntopt_off = MNTOPT_NOEXEC;
2139 break;
2140
2141 case ZFS_PROP_READONLY:
2142 mntopt_on = MNTOPT_RO;
2143 mntopt_off = MNTOPT_RW;
2144 break;
2145
2146 case ZFS_PROP_SETUID:
2147 mntopt_on = MNTOPT_SETUID;
2148 mntopt_off = MNTOPT_NOSETUID;
2149 break;
2150
2151 case ZFS_PROP_XATTR:
2152 mntopt_on = MNTOPT_XATTR;
2153 mntopt_off = MNTOPT_NOXATTR;
2154 break;
2155
2156 case ZFS_PROP_NBMAND:
2157 mntopt_on = MNTOPT_NBMAND;
2158 mntopt_off = MNTOPT_NONBMAND;
2159 break;
2160
2161 default:
2162 break;
2163 }
2164
2165 /*
2166 * Because looking up the mount options is potentially expensive
2167 * (iterating over all of /proc/self/mounts), we defer its
2168 * calculation until we're looking up a property which requires
2169 * its presence.
2170 */
2171 if (!zhp->zfs_mntcheck &&
2172 (mntopt_on != NULL || prop == ZFS_PROP_MOUNTED)) {
2173 libzfs_handle_t *hdl = zhp->zfs_hdl;
2174 struct mnttab entry;
2175
2176 if (libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0) {
2177 zhp->zfs_mntopts = zfs_strdup(hdl,
2178 entry.mnt_mntopts);
2179 if (zhp->zfs_mntopts == NULL)
2180 return (-1);
2181 }
2182
2183 zhp->zfs_mntcheck = B_TRUE;
2184 }
2185
2186 if (zhp->zfs_mntopts == NULL)
2187 mnt.mnt_mntopts = "";
2188 else
2189 mnt.mnt_mntopts = zhp->zfs_mntopts;
2190
2191 switch (prop) {
2192 case ZFS_PROP_ATIME:
2193 case ZFS_PROP_RELATIME:
2194 case ZFS_PROP_DEVICES:
2195 case ZFS_PROP_EXEC:
2196 case ZFS_PROP_READONLY:
2197 case ZFS_PROP_SETUID:
2198 case ZFS_PROP_XATTR:
2199 case ZFS_PROP_NBMAND:
2200 *val = getprop_uint64(zhp, prop, source);
2201
2202 if (received)
2203 break;
2204
2205 if (hasmntopt(&mnt, mntopt_on) && !*val) {
2206 *val = B_TRUE;
2207 if (src)
2208 *src = ZPROP_SRC_TEMPORARY;
2209 } else if (hasmntopt(&mnt, mntopt_off) && *val) {
2210 *val = B_FALSE;
2211 if (src)
2212 *src = ZPROP_SRC_TEMPORARY;
2213 }
2214 break;
2215
2216 case ZFS_PROP_CANMOUNT:
2217 case ZFS_PROP_VOLSIZE:
2218 case ZFS_PROP_QUOTA:
2219 case ZFS_PROP_REFQUOTA:
2220 case ZFS_PROP_RESERVATION:
2221 case ZFS_PROP_REFRESERVATION:
2222 case ZFS_PROP_FILESYSTEM_LIMIT:
2223 case ZFS_PROP_SNAPSHOT_LIMIT:
2224 case ZFS_PROP_FILESYSTEM_COUNT:
2225 case ZFS_PROP_SNAPSHOT_COUNT:
2226 *val = getprop_uint64(zhp, prop, source);
2227
2228 if (*source == NULL) {
2229 /* not default, must be local */
2230 *source = zhp->zfs_name;
2231 }
2232 break;
2233
2234 case ZFS_PROP_MOUNTED:
2235 *val = (zhp->zfs_mntopts != NULL);
2236 break;
2237
2238 case ZFS_PROP_NUMCLONES:
2239 *val = zhp->zfs_dmustats.dds_num_clones;
2240 break;
2241
2242 case ZFS_PROP_VERSION:
2243 case ZFS_PROP_NORMALIZE:
2244 case ZFS_PROP_UTF8ONLY:
2245 case ZFS_PROP_CASE:
2246 if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
2247 return (-1);
2248 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2249 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_ZPLPROPS, &zc)) {
2250 zcmd_free_nvlists(&zc);
2251 if (prop == ZFS_PROP_VERSION &&
2252 zhp->zfs_type == ZFS_TYPE_VOLUME)
2253 *val = zfs_prop_default_numeric(prop);
2254 return (-1);
2255 }
2256 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &zplprops) != 0 ||
2257 nvlist_lookup_uint64(zplprops, zfs_prop_to_name(prop),
2258 val) != 0) {
2259 zcmd_free_nvlists(&zc);
2260 return (-1);
2261 }
2262 nvlist_free(zplprops);
2263 zcmd_free_nvlists(&zc);
2264 break;
2265
2266 case ZFS_PROP_INCONSISTENT:
2267 *val = zhp->zfs_dmustats.dds_inconsistent;
2268 break;
2269
2270 default:
2271 switch (zfs_prop_get_type(prop)) {
2272 case PROP_TYPE_NUMBER:
2273 case PROP_TYPE_INDEX:
2274 *val = getprop_uint64(zhp, prop, source);
2275 /*
2276 * If we tried to use a default value for a
2277 * readonly property, it means that it was not
2278 * present. Note this only applies to "truly"
2279 * readonly properties, not set-once properties
2280 * like volblocksize.
2281 */
2282 if (zfs_prop_readonly(prop) &&
2283 !zfs_prop_setonce(prop) &&
2284 *source != NULL && (*source)[0] == '\0') {
2285 *source = NULL;
2286 return (-1);
2287 }
2288 break;
2289
2290 case PROP_TYPE_STRING:
2291 default:
2292 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
2293 "cannot get non-numeric property"));
2294 return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP,
2295 dgettext(TEXT_DOMAIN, "internal error")));
2296 }
2297 }
2298
2299 return (0);
2300 }
2301
2302 /*
2303 * Calculate the source type, given the raw source string.
2304 */
2305 static void
2306 get_source(zfs_handle_t *zhp, zprop_source_t *srctype, char *source,
2307 char *statbuf, size_t statlen)
2308 {
2309 if (statbuf == NULL ||
2310 srctype == NULL || *srctype == ZPROP_SRC_TEMPORARY) {
2311 return;
2312 }
2313
2314 if (source == NULL) {
2315 *srctype = ZPROP_SRC_NONE;
2316 } else if (source[0] == '\0') {
2317 *srctype = ZPROP_SRC_DEFAULT;
2318 } else if (strstr(source, ZPROP_SOURCE_VAL_RECVD) != NULL) {
2319 *srctype = ZPROP_SRC_RECEIVED;
2320 } else {
2321 if (strcmp(source, zhp->zfs_name) == 0) {
2322 *srctype = ZPROP_SRC_LOCAL;
2323 } else {
2324 (void) strlcpy(statbuf, source, statlen);
2325 *srctype = ZPROP_SRC_INHERITED;
2326 }
2327 }
2328
2329 }
2330
2331 int
2332 zfs_prop_get_recvd(zfs_handle_t *zhp, const char *propname, char *propbuf,
2333 size_t proplen, boolean_t literal)
2334 {
2335 zfs_prop_t prop;
2336 int err = 0;
2337
2338 if (zhp->zfs_recvd_props == NULL)
2339 if (get_recvd_props_ioctl(zhp) != 0)
2340 return (-1);
2341
2342 prop = zfs_name_to_prop(propname);
2343
2344 if (prop != ZPROP_INVAL) {
2345 uint64_t cookie;
2346 if (!nvlist_exists(zhp->zfs_recvd_props, propname))
2347 return (-1);
2348 zfs_set_recvd_props_mode(zhp, &cookie);
2349 err = zfs_prop_get(zhp, prop, propbuf, proplen,
2350 NULL, NULL, 0, literal);
2351 zfs_unset_recvd_props_mode(zhp, &cookie);
2352 } else {
2353 nvlist_t *propval;
2354 char *recvdval;
2355 if (nvlist_lookup_nvlist(zhp->zfs_recvd_props,
2356 propname, &propval) != 0)
2357 return (-1);
2358 verify(nvlist_lookup_string(propval, ZPROP_VALUE,
2359 &recvdval) == 0);
2360 (void) strlcpy(propbuf, recvdval, proplen);
2361 }
2362
2363 return (err == 0 ? 0 : -1);
2364 }
2365
2366 static int
2367 get_clones_string(zfs_handle_t *zhp, char *propbuf, size_t proplen)
2368 {
2369 nvlist_t *value;
2370 nvpair_t *pair;
2371
2372 value = zfs_get_clones_nvl(zhp);
2373 if (value == NULL)
2374 return (-1);
2375
2376 propbuf[0] = '\0';
2377 for (pair = nvlist_next_nvpair(value, NULL); pair != NULL;
2378 pair = nvlist_next_nvpair(value, pair)) {
2379 if (propbuf[0] != '\0')
2380 (void) strlcat(propbuf, ",", proplen);
2381 (void) strlcat(propbuf, nvpair_name(pair), proplen);
2382 }
2383
2384 return (0);
2385 }
2386
2387 struct get_clones_arg {
2388 uint64_t numclones;
2389 nvlist_t *value;
2390 const char *origin;
2391 char buf[ZFS_MAX_DATASET_NAME_LEN];
2392 };
2393
2394 int
2395 get_clones_cb(zfs_handle_t *zhp, void *arg)
2396 {
2397 struct get_clones_arg *gca = arg;
2398
2399 if (gca->numclones == 0) {
2400 zfs_close(zhp);
2401 return (0);
2402 }
2403
2404 if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, gca->buf, sizeof (gca->buf),
2405 NULL, NULL, 0, B_TRUE) != 0)
2406 goto out;
2407 if (strcmp(gca->buf, gca->origin) == 0) {
2408 fnvlist_add_boolean(gca->value, zfs_get_name(zhp));
2409 gca->numclones--;
2410 }
2411
2412 out:
2413 (void) zfs_iter_children(zhp, get_clones_cb, gca);
2414 zfs_close(zhp);
2415 return (0);
2416 }
2417
2418 nvlist_t *
2419 zfs_get_clones_nvl(zfs_handle_t *zhp)
2420 {
2421 nvlist_t *nv, *value;
2422
2423 if (nvlist_lookup_nvlist(zhp->zfs_props,
2424 zfs_prop_to_name(ZFS_PROP_CLONES), &nv) != 0) {
2425 struct get_clones_arg gca;
2426
2427 /*
2428 * if this is a snapshot, then the kernel wasn't able
2429 * to get the clones. Do it by slowly iterating.
2430 */
2431 if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT)
2432 return (NULL);
2433 if (nvlist_alloc(&nv, NV_UNIQUE_NAME, 0) != 0)
2434 return (NULL);
2435 if (nvlist_alloc(&value, NV_UNIQUE_NAME, 0) != 0) {
2436 nvlist_free(nv);
2437 return (NULL);
2438 }
2439
2440 gca.numclones = zfs_prop_get_int(zhp, ZFS_PROP_NUMCLONES);
2441 gca.value = value;
2442 gca.origin = zhp->zfs_name;
2443
2444 if (gca.numclones != 0) {
2445 zfs_handle_t *root;
2446 char pool[ZFS_MAX_DATASET_NAME_LEN];
2447 char *cp = pool;
2448
2449 /* get the pool name */
2450 (void) strlcpy(pool, zhp->zfs_name, sizeof (pool));
2451 (void) strsep(&cp, "/@");
2452 root = zfs_open(zhp->zfs_hdl, pool,
2453 ZFS_TYPE_FILESYSTEM);
2454 if (root == NULL) {
2455 nvlist_free(nv);
2456 nvlist_free(value);
2457 return (NULL);
2458 }
2459
2460 (void) get_clones_cb(root, &gca);
2461 }
2462
2463 if (gca.numclones != 0 ||
2464 nvlist_add_nvlist(nv, ZPROP_VALUE, value) != 0 ||
2465 nvlist_add_nvlist(zhp->zfs_props,
2466 zfs_prop_to_name(ZFS_PROP_CLONES), nv) != 0) {
2467 nvlist_free(nv);
2468 nvlist_free(value);
2469 return (NULL);
2470 }
2471 nvlist_free(nv);
2472 nvlist_free(value);
2473 verify(0 == nvlist_lookup_nvlist(zhp->zfs_props,
2474 zfs_prop_to_name(ZFS_PROP_CLONES), &nv));
2475 }
2476
2477 verify(nvlist_lookup_nvlist(nv, ZPROP_VALUE, &value) == 0);
2478
2479 return (value);
2480 }
2481
2482 /*
2483 * Retrieve a property from the given object. If 'literal' is specified, then
2484 * numbers are left as exact values. Otherwise, numbers are converted to a
2485 * human-readable form.
2486 *
2487 * Returns 0 on success, or -1 on error.
2488 */
2489 int
2490 zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen,
2491 zprop_source_t *src, char *statbuf, size_t statlen, boolean_t literal)
2492 {
2493 char *source = NULL;
2494 uint64_t val;
2495 const char *str;
2496 const char *strval;
2497 boolean_t received = zfs_is_recvd_props_mode(zhp);
2498
2499 /*
2500 * Check to see if this property applies to our object
2501 */
2502 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE))
2503 return (-1);
2504
2505 if (received && zfs_prop_readonly(prop))
2506 return (-1);
2507
2508 if (src)
2509 *src = ZPROP_SRC_NONE;
2510
2511 switch (prop) {
2512 case ZFS_PROP_CREATION:
2513 /*
2514 * 'creation' is a time_t stored in the statistics. We convert
2515 * this into a string unless 'literal' is specified.
2516 */
2517 {
2518 val = getprop_uint64(zhp, prop, &source);
2519 time_t time = (time_t)val;
2520 struct tm t;
2521
2522 if (literal ||
2523 localtime_r(&time, &t) == NULL ||
2524 strftime(propbuf, proplen, "%a %b %e %k:%M %Y",
2525 &t) == 0)
2526 (void) snprintf(propbuf, proplen, "%llu",
2527 (u_longlong_t)val);
2528 }
2529 break;
2530
2531 case ZFS_PROP_MOUNTPOINT:
2532 /*
2533 * Getting the precise mountpoint can be tricky.
2534 *
2535 * - for 'none' or 'legacy', return those values.
2536 * - for inherited mountpoints, we want to take everything
2537 * after our ancestor and append it to the inherited value.
2538 *
2539 * If the pool has an alternate root, we want to prepend that
2540 * root to any values we return.
2541 */
2542
2543 str = getprop_string(zhp, prop, &source);
2544
2545 if (str[0] == '/') {
2546 char buf[MAXPATHLEN];
2547 char *root = buf;
2548 const char *relpath;
2549
2550 /*
2551 * If we inherit the mountpoint, even from a dataset
2552 * with a received value, the source will be the path of
2553 * the dataset we inherit from. If source is
2554 * ZPROP_SOURCE_VAL_RECVD, the received value is not
2555 * inherited.
2556 */
2557 if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) {
2558 relpath = "";
2559 } else {
2560 relpath = zhp->zfs_name + strlen(source);
2561 if (relpath[0] == '/')
2562 relpath++;
2563 }
2564
2565 if ((zpool_get_prop(zhp->zpool_hdl,
2566 ZPOOL_PROP_ALTROOT, buf, MAXPATHLEN, NULL,
2567 B_FALSE)) || (strcmp(root, "-") == 0))
2568 root[0] = '\0';
2569 /*
2570 * Special case an alternate root of '/'. This will
2571 * avoid having multiple leading slashes in the
2572 * mountpoint path.
2573 */
2574 if (strcmp(root, "/") == 0)
2575 root++;
2576
2577 /*
2578 * If the mountpoint is '/' then skip over this
2579 * if we are obtaining either an alternate root or
2580 * an inherited mountpoint.
2581 */
2582 if (str[1] == '\0' && (root[0] != '\0' ||
2583 relpath[0] != '\0'))
2584 str++;
2585
2586 if (relpath[0] == '\0')
2587 (void) snprintf(propbuf, proplen, "%s%s",
2588 root, str);
2589 else
2590 (void) snprintf(propbuf, proplen, "%s%s%s%s",
2591 root, str, relpath[0] == '@' ? "" : "/",
2592 relpath);
2593 } else {
2594 /* 'legacy' or 'none' */
2595 (void) strlcpy(propbuf, str, proplen);
2596 }
2597
2598 break;
2599
2600 case ZFS_PROP_ORIGIN:
2601 str = getprop_string(zhp, prop, &source);
2602 if (str == NULL)
2603 return (-1);
2604 (void) strlcpy(propbuf, str, proplen);
2605 break;
2606
2607 case ZFS_PROP_CLONES:
2608 if (get_clones_string(zhp, propbuf, proplen) != 0)
2609 return (-1);
2610 break;
2611
2612 case ZFS_PROP_QUOTA:
2613 case ZFS_PROP_REFQUOTA:
2614 case ZFS_PROP_RESERVATION:
2615 case ZFS_PROP_REFRESERVATION:
2616
2617 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2618 return (-1);
2619
2620 /*
2621 * If quota or reservation is 0, we translate this into 'none'
2622 * (unless literal is set), and indicate that it's the default
2623 * value. Otherwise, we print the number nicely and indicate
2624 * that its set locally.
2625 */
2626 if (val == 0) {
2627 if (literal)
2628 (void) strlcpy(propbuf, "0", proplen);
2629 else
2630 (void) strlcpy(propbuf, "none", proplen);
2631 } else {
2632 if (literal)
2633 (void) snprintf(propbuf, proplen, "%llu",
2634 (u_longlong_t)val);
2635 else
2636 zfs_nicebytes(val, propbuf, proplen);
2637 }
2638 break;
2639
2640 case ZFS_PROP_FILESYSTEM_LIMIT:
2641 case ZFS_PROP_SNAPSHOT_LIMIT:
2642 case ZFS_PROP_FILESYSTEM_COUNT:
2643 case ZFS_PROP_SNAPSHOT_COUNT:
2644
2645 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2646 return (-1);
2647
2648 /*
2649 * If limit is UINT64_MAX, we translate this into 'none' (unless
2650 * literal is set), and indicate that it's the default value.
2651 * Otherwise, we print the number nicely and indicate that it's
2652 * set locally.
2653 */
2654 if (literal) {
2655 (void) snprintf(propbuf, proplen, "%llu",
2656 (u_longlong_t)val);
2657 } else if (val == UINT64_MAX) {
2658 (void) strlcpy(propbuf, "none", proplen);
2659 } else {
2660 zfs_nicenum(val, propbuf, proplen);
2661 }
2662 break;
2663
2664 case ZFS_PROP_REFRATIO:
2665 case ZFS_PROP_COMPRESSRATIO:
2666 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2667 return (-1);
2668 if (literal)
2669 (void) snprintf(propbuf, proplen, "%llu.%02llu",
2670 (u_longlong_t)(val / 100),
2671 (u_longlong_t)(val % 100));
2672 else
2673 (void) snprintf(propbuf, proplen, "%llu.%02llux",
2674 (u_longlong_t)(val / 100),
2675 (u_longlong_t)(val % 100));
2676 break;
2677
2678 case ZFS_PROP_TYPE:
2679 switch (zhp->zfs_type) {
2680 case ZFS_TYPE_FILESYSTEM:
2681 str = "filesystem";
2682 break;
2683 case ZFS_TYPE_VOLUME:
2684 str = "volume";
2685 break;
2686 case ZFS_TYPE_SNAPSHOT:
2687 str = "snapshot";
2688 break;
2689 case ZFS_TYPE_BOOKMARK:
2690 str = "bookmark";
2691 break;
2692 default:
2693 abort();
2694 }
2695 (void) snprintf(propbuf, proplen, "%s", str);
2696 break;
2697
2698 case ZFS_PROP_MOUNTED:
2699 /*
2700 * The 'mounted' property is a pseudo-property that described
2701 * whether the filesystem is currently mounted. Even though
2702 * it's a boolean value, the typical values of "on" and "off"
2703 * don't make sense, so we translate to "yes" and "no".
2704 */
2705 if (get_numeric_property(zhp, ZFS_PROP_MOUNTED,
2706 src, &source, &val) != 0)
2707 return (-1);
2708 if (val)
2709 (void) strlcpy(propbuf, "yes", proplen);
2710 else
2711 (void) strlcpy(propbuf, "no", proplen);
2712 break;
2713
2714 case ZFS_PROP_NAME:
2715 /*
2716 * The 'name' property is a pseudo-property derived from the
2717 * dataset name. It is presented as a real property to simplify
2718 * consumers.
2719 */
2720 (void) strlcpy(propbuf, zhp->zfs_name, proplen);
2721 break;
2722
2723 case ZFS_PROP_MLSLABEL:
2724 {
2725 #ifdef HAVE_MLSLABEL
2726 m_label_t *new_sl = NULL;
2727 char *ascii = NULL; /* human readable label */
2728
2729 (void) strlcpy(propbuf,
2730 getprop_string(zhp, prop, &source), proplen);
2731
2732 if (literal || (strcasecmp(propbuf,
2733 ZFS_MLSLABEL_DEFAULT) == 0))
2734 break;
2735
2736 /*
2737 * Try to translate the internal hex string to
2738 * human-readable output. If there are any
2739 * problems just use the hex string.
2740 */
2741
2742 if (str_to_label(propbuf, &new_sl, MAC_LABEL,
2743 L_NO_CORRECTION, NULL) == -1) {
2744 m_label_free(new_sl);
2745 break;
2746 }
2747
2748 if (label_to_str(new_sl, &ascii, M_LABEL,
2749 DEF_NAMES) != 0) {
2750 if (ascii)
2751 free(ascii);
2752 m_label_free(new_sl);
2753 break;
2754 }
2755 m_label_free(new_sl);
2756
2757 (void) strlcpy(propbuf, ascii, proplen);
2758 free(ascii);
2759 #else
2760 (void) strlcpy(propbuf,
2761 getprop_string(zhp, prop, &source), proplen);
2762 #endif /* HAVE_MLSLABEL */
2763 }
2764 break;
2765
2766 case ZFS_PROP_GUID:
2767 case ZFS_PROP_CREATETXG:
2768 /*
2769 * GUIDs are stored as numbers, but they are identifiers.
2770 * We don't want them to be pretty printed, because pretty
2771 * printing mangles the ID into a truncated and useless value.
2772 */
2773 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2774 return (-1);
2775 (void) snprintf(propbuf, proplen, "%llu", (u_longlong_t)val);
2776 break;
2777
2778 case ZFS_PROP_REFERENCED:
2779 case ZFS_PROP_AVAILABLE:
2780 case ZFS_PROP_USED:
2781 case ZFS_PROP_USEDSNAP:
2782 case ZFS_PROP_USEDDS:
2783 case ZFS_PROP_USEDREFRESERV:
2784 case ZFS_PROP_USEDCHILD:
2785 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2786 return (-1);
2787 if (literal)
2788 (void) snprintf(propbuf, proplen, "%llu",
2789 (u_longlong_t)val);
2790 else
2791 zfs_nicebytes(val, propbuf, proplen);
2792 break;
2793
2794 default:
2795 switch (zfs_prop_get_type(prop)) {
2796 case PROP_TYPE_NUMBER:
2797 if (get_numeric_property(zhp, prop, src,
2798 &source, &val) != 0)
2799 return (-1);
2800 if (literal)
2801 (void) snprintf(propbuf, proplen, "%llu",
2802 (u_longlong_t)val);
2803 else
2804 zfs_nicenum(val, propbuf, proplen);
2805 break;
2806
2807 case PROP_TYPE_STRING:
2808 str = getprop_string(zhp, prop, &source);
2809 if (str == NULL)
2810 return (-1);
2811 (void) strlcpy(propbuf, str, proplen);
2812 break;
2813
2814 case PROP_TYPE_INDEX:
2815 if (get_numeric_property(zhp, prop, src,
2816 &source, &val) != 0)
2817 return (-1);
2818 if (zfs_prop_index_to_string(prop, val, &strval) != 0)
2819 return (-1);
2820 (void) strlcpy(propbuf, strval, proplen);
2821 break;
2822
2823 default:
2824 abort();
2825 }
2826 }
2827
2828 get_source(zhp, src, source, statbuf, statlen);
2829
2830 return (0);
2831 }
2832
2833 /*
2834 * Utility function to get the given numeric property. Does no validation that
2835 * the given property is the appropriate type; should only be used with
2836 * hard-coded property types.
2837 */
2838 uint64_t
2839 zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop)
2840 {
2841 char *source;
2842 uint64_t val = 0;
2843
2844 (void) get_numeric_property(zhp, prop, NULL, &source, &val);
2845
2846 return (val);
2847 }
2848
2849 int
2850 zfs_prop_set_int(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t val)
2851 {
2852 char buf[64];
2853
2854 (void) snprintf(buf, sizeof (buf), "%llu", (longlong_t)val);
2855 return (zfs_prop_set(zhp, zfs_prop_to_name(prop), buf));
2856 }
2857
2858 /*
2859 * Similar to zfs_prop_get(), but returns the value as an integer.
2860 */
2861 int
2862 zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value,
2863 zprop_source_t *src, char *statbuf, size_t statlen)
2864 {
2865 char *source;
2866
2867 /*
2868 * Check to see if this property applies to our object
2869 */
2870 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE)) {
2871 return (zfs_error_fmt(zhp->zfs_hdl, EZFS_PROPTYPE,
2872 dgettext(TEXT_DOMAIN, "cannot get property '%s'"),
2873 zfs_prop_to_name(prop)));
2874 }
2875
2876 if (src)
2877 *src = ZPROP_SRC_NONE;
2878
2879 if (get_numeric_property(zhp, prop, src, &source, value) != 0)
2880 return (-1);
2881
2882 get_source(zhp, src, source, statbuf, statlen);
2883
2884 return (0);
2885 }
2886
2887 #ifdef HAVE_IDMAP
2888 static int
2889 idmap_id_to_numeric_domain_rid(uid_t id, boolean_t isuser,
2890 char **domainp, idmap_rid_t *ridp)
2891 {
2892 idmap_get_handle_t *get_hdl = NULL;
2893 idmap_stat status;
2894 int err = EINVAL;
2895
2896 if (idmap_get_create(&get_hdl) != IDMAP_SUCCESS)
2897 goto out;
2898
2899 if (isuser) {
2900 err = idmap_get_sidbyuid(get_hdl, id,
2901 IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
2902 } else {
2903 err = idmap_get_sidbygid(get_hdl, id,
2904 IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
2905 }
2906 if (err == IDMAP_SUCCESS &&
2907 idmap_get_mappings(get_hdl) == IDMAP_SUCCESS &&
2908 status == IDMAP_SUCCESS)
2909 err = 0;
2910 else
2911 err = EINVAL;
2912 out:
2913 if (get_hdl)
2914 idmap_get_destroy(get_hdl);
2915 return (err);
2916 }
2917 #endif /* HAVE_IDMAP */
2918
2919 /*
2920 * convert the propname into parameters needed by kernel
2921 * Eg: userquota@ahrens -> ZFS_PROP_USERQUOTA, "", 126829
2922 * Eg: userused@matt@domain -> ZFS_PROP_USERUSED, "S-1-123-456", 789
2923 * Eg: groupquota@staff -> ZFS_PROP_GROUPQUOTA, "", 1234
2924 * Eg: groupused@staff -> ZFS_PROP_GROUPUSED, "", 1234
2925 */
2926 static int
2927 userquota_propname_decode(const char *propname, boolean_t zoned,
2928 zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp)
2929 {
2930 zfs_userquota_prop_t type;
2931 char *cp;
2932 boolean_t isuser;
2933 boolean_t isgroup;
2934 struct passwd *pw;
2935 struct group *gr;
2936
2937 domain[0] = '\0';
2938
2939 /* Figure out the property type ({user|group}{quota|space}) */
2940 for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++) {
2941 if (strncmp(propname, zfs_userquota_prop_prefixes[type],
2942 strlen(zfs_userquota_prop_prefixes[type])) == 0)
2943 break;
2944 }
2945 if (type == ZFS_NUM_USERQUOTA_PROPS)
2946 return (EINVAL);
2947 *typep = type;
2948
2949 isuser = (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_USERUSED ||
2950 type == ZFS_PROP_USEROBJQUOTA ||
2951 type == ZFS_PROP_USEROBJUSED);
2952 isgroup = (type == ZFS_PROP_GROUPQUOTA || type == ZFS_PROP_GROUPUSED ||
2953 type == ZFS_PROP_GROUPOBJQUOTA ||
2954 type == ZFS_PROP_GROUPOBJUSED);
2955
2956 cp = strchr(propname, '@') + 1;
2957
2958 if (isuser && (pw = getpwnam(cp)) != NULL) {
2959 if (zoned && getzoneid() == GLOBAL_ZONEID)
2960 return (ENOENT);
2961 *ridp = pw->pw_uid;
2962 } else if (isgroup && (gr = getgrnam(cp)) != NULL) {
2963 if (zoned && getzoneid() == GLOBAL_ZONEID)
2964 return (ENOENT);
2965 *ridp = gr->gr_gid;
2966 } else if (strchr(cp, '@')) {
2967 #ifdef HAVE_IDMAP
2968 /*
2969 * It's a SID name (eg "user@domain") that needs to be
2970 * turned into S-1-domainID-RID.
2971 */
2972 directory_error_t e;
2973 char *numericsid = NULL;
2974 char *end;
2975
2976 if (zoned && getzoneid() == GLOBAL_ZONEID)
2977 return (ENOENT);
2978 if (isuser) {
2979 e = directory_sid_from_user_name(NULL,
2980 cp, &numericsid);
2981 } else {
2982 e = directory_sid_from_group_name(NULL,
2983 cp, &numericsid);
2984 }
2985 if (e != NULL) {
2986 directory_error_free(e);
2987 return (ENOENT);
2988 }
2989 if (numericsid == NULL)
2990 return (ENOENT);
2991 cp = numericsid;
2992 (void) strlcpy(domain, cp, domainlen);
2993 cp = strrchr(domain, '-');
2994 *cp = '\0';
2995 cp++;
2996
2997 errno = 0;
2998 *ridp = strtoull(cp, &end, 10);
2999 free(numericsid);
3000
3001 if (errno != 0 || *end != '\0')
3002 return (EINVAL);
3003 #else
3004 return (ENOSYS);
3005 #endif /* HAVE_IDMAP */
3006 } else {
3007 /* It's a user/group ID (eg "12345"). */
3008 uid_t id;
3009 char *end;
3010 id = strtoul(cp, &end, 10);
3011 if (*end != '\0')
3012 return (EINVAL);
3013 if (id > MAXUID) {
3014 #ifdef HAVE_IDMAP
3015 /* It's an ephemeral ID. */
3016 idmap_rid_t rid;
3017 char *mapdomain;
3018
3019 if (idmap_id_to_numeric_domain_rid(id, isuser,
3020 &mapdomain, &rid) != 0)
3021 return (ENOENT);
3022 (void) strlcpy(domain, mapdomain, domainlen);
3023 *ridp = rid;
3024 #else
3025 return (ENOSYS);
3026 #endif /* HAVE_IDMAP */
3027 } else {
3028 *ridp = id;
3029 }
3030 }
3031
3032 return (0);
3033 }
3034
3035 static int
3036 zfs_prop_get_userquota_common(zfs_handle_t *zhp, const char *propname,
3037 uint64_t *propvalue, zfs_userquota_prop_t *typep)
3038 {
3039 int err;
3040 zfs_cmd_t zc = {"\0"};
3041
3042 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3043
3044 err = userquota_propname_decode(propname,
3045 zfs_prop_get_int(zhp, ZFS_PROP_ZONED),
3046 typep, zc.zc_value, sizeof (zc.zc_value), &zc.zc_guid);
3047 zc.zc_objset_type = *typep;
3048 if (err)
3049 return (err);
3050
3051 err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_USERSPACE_ONE, &zc);
3052 if (err)
3053 return (err);
3054
3055 *propvalue = zc.zc_cookie;
3056 return (0);
3057 }
3058
3059 int
3060 zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname,
3061 uint64_t *propvalue)
3062 {
3063 zfs_userquota_prop_t type;
3064
3065 return (zfs_prop_get_userquota_common(zhp, propname, propvalue,
3066 &type));
3067 }
3068
3069 int
3070 zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname,
3071 char *propbuf, int proplen, boolean_t literal)
3072 {
3073 int err;
3074 uint64_t propvalue;
3075 zfs_userquota_prop_t type;
3076
3077 err = zfs_prop_get_userquota_common(zhp, propname, &propvalue,
3078 &type);
3079
3080 if (err)
3081 return (err);
3082
3083 if (literal) {
3084 (void) snprintf(propbuf, proplen, "%llu",
3085 (u_longlong_t)propvalue);
3086 } else if (propvalue == 0 &&
3087 (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_GROUPQUOTA ||
3088 type == ZFS_PROP_USEROBJQUOTA || type == ZFS_PROP_GROUPOBJQUOTA)) {
3089 (void) strlcpy(propbuf, "none", proplen);
3090 } else if (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_GROUPQUOTA ||
3091 type == ZFS_PROP_USERUSED || type == ZFS_PROP_GROUPUSED) {
3092 zfs_nicebytes(propvalue, propbuf, proplen);
3093 } else {
3094 zfs_nicenum(propvalue, propbuf, proplen);
3095 }
3096 return (0);
3097 }
3098
3099 int
3100 zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname,
3101 uint64_t *propvalue)
3102 {
3103 int err;
3104 zfs_cmd_t zc = {"\0"};
3105 const char *snapname;
3106
3107 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3108
3109 snapname = strchr(propname, '@') + 1;
3110 if (strchr(snapname, '@')) {
3111 (void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value));
3112 } else {
3113 /* snapname is the short name, append it to zhp's fsname */
3114 char *cp;
3115
3116 (void) strlcpy(zc.zc_value, zhp->zfs_name,
3117 sizeof (zc.zc_value));
3118 cp = strchr(zc.zc_value, '@');
3119 if (cp != NULL)
3120 *cp = '\0';
3121 (void) strlcat(zc.zc_value, "@", sizeof (zc.zc_value));
3122 (void) strlcat(zc.zc_value, snapname, sizeof (zc.zc_value));
3123 }
3124
3125 err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SPACE_WRITTEN, &zc);
3126 if (err)
3127 return (err);
3128
3129 *propvalue = zc.zc_cookie;
3130 return (0);
3131 }
3132
3133 int
3134 zfs_prop_get_written(zfs_handle_t *zhp, const char *propname,
3135 char *propbuf, int proplen, boolean_t literal)
3136 {
3137 int err;
3138 uint64_t propvalue;
3139
3140 err = zfs_prop_get_written_int(zhp, propname, &propvalue);
3141
3142 if (err)
3143 return (err);
3144
3145 if (literal) {
3146 (void) snprintf(propbuf, proplen, "%llu",
3147 (u_longlong_t)propvalue);
3148 } else {
3149 zfs_nicebytes(propvalue, propbuf, proplen);
3150 }
3151
3152 return (0);
3153 }
3154
3155 /*
3156 * Returns the name of the given zfs handle.
3157 */
3158 const char *
3159 zfs_get_name(const zfs_handle_t *zhp)
3160 {
3161 return (zhp->zfs_name);
3162 }
3163
3164 /*
3165 * Returns the name of the parent pool for the given zfs handle.
3166 */
3167 const char *
3168 zfs_get_pool_name(const zfs_handle_t *zhp)
3169 {
3170 return (zhp->zpool_hdl->zpool_name);
3171 }
3172
3173 /*
3174 * Returns the type of the given zfs handle.
3175 */
3176 zfs_type_t
3177 zfs_get_type(const zfs_handle_t *zhp)
3178 {
3179 return (zhp->zfs_type);
3180 }
3181
3182 /*
3183 * Is one dataset name a child dataset of another?
3184 *
3185 * Needs to handle these cases:
3186 * Dataset 1 "a/foo" "a/foo" "a/foo" "a/foo"
3187 * Dataset 2 "a/fo" "a/foobar" "a/bar/baz" "a/foo/bar"
3188 * Descendant? No. No. No. Yes.
3189 */
3190 static boolean_t
3191 is_descendant(const char *ds1, const char *ds2)
3192 {
3193 size_t d1len = strlen(ds1);
3194
3195 /* ds2 can't be a descendant if it's smaller */
3196 if (strlen(ds2) < d1len)
3197 return (B_FALSE);
3198
3199 /* otherwise, compare strings and verify that there's a '/' char */
3200 return (ds2[d1len] == '/' && (strncmp(ds1, ds2, d1len) == 0));
3201 }
3202
3203 /*
3204 * Given a complete name, return just the portion that refers to the parent.
3205 * Will return -1 if there is no parent (path is just the name of the
3206 * pool).
3207 */
3208 static int
3209 parent_name(const char *path, char *buf, size_t buflen)
3210 {
3211 char *slashp;
3212
3213 (void) strlcpy(buf, path, buflen);
3214
3215 if ((slashp = strrchr(buf, '/')) == NULL)
3216 return (-1);
3217 *slashp = '\0';
3218
3219 return (0);
3220 }
3221
3222 int
3223 zfs_parent_name(zfs_handle_t *zhp, char *buf, size_t buflen)
3224 {
3225 return (parent_name(zfs_get_name(zhp), buf, buflen));
3226 }
3227
3228 /*
3229 * If accept_ancestor is false, then check to make sure that the given path has
3230 * a parent, and that it exists. If accept_ancestor is true, then find the
3231 * closest existing ancestor for the given path. In prefixlen return the
3232 * length of already existing prefix of the given path. We also fetch the
3233 * 'zoned' property, which is used to validate property settings when creating
3234 * new datasets.
3235 */
3236 static int
3237 check_parents(libzfs_handle_t *hdl, const char *path, uint64_t *zoned,
3238 boolean_t accept_ancestor, int *prefixlen)
3239 {
3240 zfs_cmd_t zc = {"\0"};
3241 char parent[ZFS_MAX_DATASET_NAME_LEN];
3242 char *slash;
3243 zfs_handle_t *zhp;
3244 char errbuf[1024];
3245 uint64_t is_zoned;
3246
3247 (void) snprintf(errbuf, sizeof (errbuf),
3248 dgettext(TEXT_DOMAIN, "cannot create '%s'"), path);
3249
3250 /* get parent, and check to see if this is just a pool */
3251 if (parent_name(path, parent, sizeof (parent)) != 0) {
3252 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3253 "missing dataset name"));
3254 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3255 }
3256
3257 /* check to see if the pool exists */
3258 if ((slash = strchr(parent, '/')) == NULL)
3259 slash = parent + strlen(parent);
3260 (void) strncpy(zc.zc_name, parent, slash - parent);
3261 zc.zc_name[slash - parent] = '\0';
3262 if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 &&
3263 errno == ENOENT) {
3264 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3265 "no such pool '%s'"), zc.zc_name);
3266 return (zfs_error(hdl, EZFS_NOENT, errbuf));
3267 }
3268
3269 /* check to see if the parent dataset exists */
3270 while ((zhp = make_dataset_handle(hdl, parent)) == NULL) {
3271 if (errno == ENOENT && accept_ancestor) {
3272 /*
3273 * Go deeper to find an ancestor, give up on top level.
3274 */
3275 if (parent_name(parent, parent, sizeof (parent)) != 0) {
3276 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3277 "no such pool '%s'"), zc.zc_name);
3278 return (zfs_error(hdl, EZFS_NOENT, errbuf));
3279 }
3280 } else if (errno == ENOENT) {
3281 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3282 "parent does not exist"));
3283 return (zfs_error(hdl, EZFS_NOENT, errbuf));
3284 } else
3285 return (zfs_standard_error(hdl, errno, errbuf));
3286 }
3287
3288 is_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
3289 if (zoned != NULL)
3290 *zoned = is_zoned;
3291
3292 /* we are in a non-global zone, but parent is in the global zone */
3293 if (getzoneid() != GLOBAL_ZONEID && !is_zoned) {
3294 (void) zfs_standard_error(hdl, EPERM, errbuf);
3295 zfs_close(zhp);
3296 return (-1);
3297 }
3298
3299 /* make sure parent is a filesystem */
3300 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
3301 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3302 "parent is not a filesystem"));
3303 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
3304 zfs_close(zhp);
3305 return (-1);
3306 }
3307
3308 zfs_close(zhp);
3309 if (prefixlen != NULL)
3310 *prefixlen = strlen(parent);
3311 return (0);
3312 }
3313
3314 /*
3315 * Finds whether the dataset of the given type(s) exists.
3316 */
3317 boolean_t
3318 zfs_dataset_exists(libzfs_handle_t *hdl, const char *path, zfs_type_t types)
3319 {
3320 zfs_handle_t *zhp;
3321
3322 if (!zfs_validate_name(hdl, path, types, B_FALSE))
3323 return (B_FALSE);
3324
3325 /*
3326 * Try to get stats for the dataset, which will tell us if it exists.
3327 */
3328 if ((zhp = make_dataset_handle(hdl, path)) != NULL) {
3329 int ds_type = zhp->zfs_type;
3330
3331 zfs_close(zhp);
3332 if (types & ds_type)
3333 return (B_TRUE);
3334 }
3335 return (B_FALSE);
3336 }
3337
3338 /*
3339 * Given a path to 'target', create all the ancestors between
3340 * the prefixlen portion of the path, and the target itself.
3341 * Fail if the initial prefixlen-ancestor does not already exist.
3342 */
3343 int
3344 create_parents(libzfs_handle_t *hdl, char *target, int prefixlen)
3345 {
3346 zfs_handle_t *h;
3347 char *cp;
3348 const char *opname;
3349
3350 /* make sure prefix exists */
3351 cp = target + prefixlen;
3352 if (*cp != '/') {
3353 assert(strchr(cp, '/') == NULL);
3354 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3355 } else {
3356 *cp = '\0';
3357 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3358 *cp = '/';
3359 }
3360 if (h == NULL)
3361 return (-1);
3362 zfs_close(h);
3363
3364 /*
3365 * Attempt to create, mount, and share any ancestor filesystems,
3366 * up to the prefixlen-long one.
3367 */
3368 for (cp = target + prefixlen + 1;
3369 (cp = strchr(cp, '/')) != NULL; *cp = '/', cp++) {
3370
3371 *cp = '\0';
3372
3373 h = make_dataset_handle(hdl, target);
3374 if (h) {
3375 /* it already exists, nothing to do here */
3376 zfs_close(h);
3377 continue;
3378 }
3379
3380 if (zfs_create(hdl, target, ZFS_TYPE_FILESYSTEM,
3381 NULL) != 0) {
3382 opname = dgettext(TEXT_DOMAIN, "create");
3383 goto ancestorerr;
3384 }
3385
3386 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3387 if (h == NULL) {
3388 opname = dgettext(TEXT_DOMAIN, "open");
3389 goto ancestorerr;
3390 }
3391
3392 if (zfs_mount(h, NULL, 0) != 0) {
3393 opname = dgettext(TEXT_DOMAIN, "mount");
3394 goto ancestorerr;
3395 }
3396
3397 if (zfs_share(h) != 0) {
3398 opname = dgettext(TEXT_DOMAIN, "share");
3399 goto ancestorerr;
3400 }
3401
3402 zfs_close(h);
3403 }
3404
3405 return (0);
3406
3407 ancestorerr:
3408 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3409 "failed to %s ancestor '%s'"), opname, target);
3410 return (-1);
3411 }
3412
3413 /*
3414 * Creates non-existing ancestors of the given path.
3415 */
3416 int
3417 zfs_create_ancestors(libzfs_handle_t *hdl, const char *path)
3418 {
3419 int prefix;
3420 char *path_copy;
3421 int rc = 0;
3422
3423 if (check_parents(hdl, path, NULL, B_TRUE, &prefix) != 0)
3424 return (-1);
3425
3426 if ((path_copy = strdup(path)) != NULL) {
3427 rc = create_parents(hdl, path_copy, prefix);
3428 free(path_copy);
3429 }
3430 if (path_copy == NULL || rc != 0)
3431 return (-1);
3432
3433 return (0);
3434 }
3435
3436 /*
3437 * Create a new filesystem or volume.
3438 */
3439 int
3440 zfs_create(libzfs_handle_t *hdl, const char *path, zfs_type_t type,
3441 nvlist_t *props)
3442 {
3443 int ret;
3444 uint64_t size = 0;
3445 uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
3446 uint64_t zoned;
3447 enum lzc_dataset_type ost;
3448 zpool_handle_t *zpool_handle;
3449 uint8_t *wkeydata = NULL;
3450 uint_t wkeylen = 0;
3451 char errbuf[1024];
3452 char parent[ZFS_MAX_DATASET_NAME_LEN];
3453
3454 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3455 "cannot create '%s'"), path);
3456
3457 /* validate the path, taking care to note the extended error message */
3458 if (!zfs_validate_name(hdl, path, type, B_TRUE))
3459 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3460
3461 /* validate parents exist */
3462 if (check_parents(hdl, path, &zoned, B_FALSE, NULL) != 0)
3463 return (-1);
3464
3465 /*
3466 * The failure modes when creating a dataset of a different type over
3467 * one that already exists is a little strange. In particular, if you
3468 * try to create a dataset on top of an existing dataset, the ioctl()
3469 * will return ENOENT, not EEXIST. To prevent this from happening, we
3470 * first try to see if the dataset exists.
3471 */
3472 if (zfs_dataset_exists(hdl, path, ZFS_TYPE_DATASET)) {
3473 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3474 "dataset already exists"));
3475 return (zfs_error(hdl, EZFS_EXISTS, errbuf));
3476 }
3477
3478 if (type == ZFS_TYPE_VOLUME)
3479 ost = LZC_DATSET_TYPE_ZVOL;
3480 else
3481 ost = LZC_DATSET_TYPE_ZFS;
3482
3483 /* open zpool handle for prop validation */
3484 char pool_path[ZFS_MAX_DATASET_NAME_LEN];
3485 (void) strlcpy(pool_path, path, sizeof (pool_path));
3486
3487 /* truncate pool_path at first slash */
3488 char *p = strchr(pool_path, '/');
3489 if (p != NULL)
3490 *p = '\0';
3491
3492 if ((zpool_handle = zpool_open(hdl, pool_path)) == NULL)
3493 return (-1);
3494
3495 if (props && (props = zfs_valid_proplist(hdl, type, props,
3496 zoned, NULL, zpool_handle, B_TRUE, errbuf)) == 0) {
3497 zpool_close(zpool_handle);
3498 return (-1);
3499 }
3500 zpool_close(zpool_handle);
3501
3502 if (type == ZFS_TYPE_VOLUME) {
3503 /*
3504 * If we are creating a volume, the size and block size must
3505 * satisfy a few restraints. First, the blocksize must be a
3506 * valid block size between SPA_{MIN,MAX}BLOCKSIZE. Second, the
3507 * volsize must be a multiple of the block size, and cannot be
3508 * zero.
3509 */
3510 if (props == NULL || nvlist_lookup_uint64(props,
3511 zfs_prop_to_name(ZFS_PROP_VOLSIZE), &size) != 0) {
3512 nvlist_free(props);
3513 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3514 "missing volume size"));
3515 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3516 }
3517
3518 if ((ret = nvlist_lookup_uint64(props,
3519 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
3520 &blocksize)) != 0) {
3521 if (ret == ENOENT) {
3522 blocksize = zfs_prop_default_numeric(
3523 ZFS_PROP_VOLBLOCKSIZE);
3524 } else {
3525 nvlist_free(props);
3526 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3527 "missing volume block size"));
3528 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3529 }
3530 }
3531
3532 if (size == 0) {
3533 nvlist_free(props);
3534 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3535 "volume size cannot be zero"));
3536 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3537 }
3538
3539 if (size % blocksize != 0) {
3540 nvlist_free(props);
3541 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3542 "volume size must be a multiple of volume block "
3543 "size"));
3544 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3545 }
3546 }
3547
3548 (void) parent_name(path, parent, sizeof (parent));
3549 if (zfs_crypto_create(hdl, parent, props, NULL, &wkeydata,
3550 &wkeylen) != 0) {
3551 nvlist_free(props);
3552 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
3553 }
3554
3555 /* create the dataset */
3556 ret = lzc_create(path, ost, props, wkeydata, wkeylen);
3557 nvlist_free(props);
3558 if (wkeydata != NULL)
3559 free(wkeydata);
3560
3561 /* check for failure */
3562 if (ret != 0) {
3563 switch (errno) {
3564 case ENOENT:
3565 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3566 "no such parent '%s'"), parent);
3567 return (zfs_error(hdl, EZFS_NOENT, errbuf));
3568
3569 case EINVAL:
3570 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3571 "parent '%s' is not a filesystem"), parent);
3572 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
3573
3574 case ENOTSUP:
3575 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3576 "pool must be upgraded to set this "
3577 "property or value"));
3578 return (zfs_error(hdl, EZFS_BADVERSION, errbuf));
3579
3580 case EACCES:
3581 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3582 "encryption root's key is not loaded "
3583 "or provided"));
3584 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
3585
3586 case ERANGE:
3587 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3588 "invalid property value(s) specified"));
3589 return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3590 #ifdef _ILP32
3591 case EOVERFLOW:
3592 /*
3593 * This platform can't address a volume this big.
3594 */
3595 if (type == ZFS_TYPE_VOLUME)
3596 return (zfs_error(hdl, EZFS_VOLTOOBIG,
3597 errbuf));
3598 #endif
3599 /* FALLTHROUGH */
3600 default:
3601 return (zfs_standard_error(hdl, errno, errbuf));
3602 }
3603 }
3604
3605 return (0);
3606 }
3607
3608 /*
3609 * Destroys the given dataset. The caller must make sure that the filesystem
3610 * isn't mounted, and that there are no active dependents. If the file system
3611 * does not exist this function does nothing.
3612 */
3613 int
3614 zfs_destroy(zfs_handle_t *zhp, boolean_t defer)
3615 {
3616 zfs_cmd_t zc = {"\0"};
3617
3618 if (zhp->zfs_type == ZFS_TYPE_BOOKMARK) {
3619 nvlist_t *nv = fnvlist_alloc();
3620 fnvlist_add_boolean(nv, zhp->zfs_name);
3621 int error = lzc_destroy_bookmarks(nv, NULL);
3622 fnvlist_free(nv);
3623 if (error != 0) {
3624 return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3625 dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
3626 zhp->zfs_name));
3627 }
3628 return (0);
3629 }
3630
3631 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3632
3633 if (ZFS_IS_VOLUME(zhp)) {
3634 zc.zc_objset_type = DMU_OST_ZVOL;
3635 } else {
3636 zc.zc_objset_type = DMU_OST_ZFS;
3637 }
3638
3639 zc.zc_defer_destroy = defer;
3640 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_DESTROY, &zc) != 0 &&
3641 errno != ENOENT) {
3642 return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3643 dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
3644 zhp->zfs_name));
3645 }
3646
3647 remove_mountpoint(zhp);
3648
3649 return (0);
3650 }
3651
3652 struct destroydata {
3653 nvlist_t *nvl;
3654 const char *snapname;
3655 };
3656
3657 static int
3658 zfs_check_snap_cb(zfs_handle_t *zhp, void *arg)
3659 {
3660 struct destroydata *dd = arg;
3661 char name[ZFS_MAX_DATASET_NAME_LEN];
3662 int rv = 0;
3663
3664 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
3665 dd->snapname) >= sizeof (name))
3666 return (EINVAL);
3667
3668 if (lzc_exists(name))
3669 verify(nvlist_add_boolean(dd->nvl, name) == 0);
3670
3671 rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd);
3672 zfs_close(zhp);
3673 return (rv);
3674 }
3675
3676 /*
3677 * Destroys all snapshots with the given name in zhp & descendants.
3678 */
3679 int
3680 zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer)
3681 {
3682 int ret;
3683 struct destroydata dd = { 0 };
3684
3685 dd.snapname = snapname;
3686 verify(nvlist_alloc(&dd.nvl, NV_UNIQUE_NAME, 0) == 0);
3687 (void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd);
3688
3689 if (nvlist_empty(dd.nvl)) {
3690 ret = zfs_standard_error_fmt(zhp->zfs_hdl, ENOENT,
3691 dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"),
3692 zhp->zfs_name, snapname);
3693 } else {
3694 ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer);
3695 }
3696 nvlist_free(dd.nvl);
3697 return (ret);
3698 }
3699
3700 /*
3701 * Destroys all the snapshots named in the nvlist.
3702 */
3703 int
3704 zfs_destroy_snaps_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, boolean_t defer)
3705 {
3706 int ret;
3707 nvlist_t *errlist = NULL;
3708 nvpair_t *pair;
3709
3710 ret = lzc_destroy_snaps(snaps, defer, &errlist);
3711
3712 if (ret == 0) {
3713 nvlist_free(errlist);
3714 return (0);
3715 }
3716
3717 if (nvlist_empty(errlist)) {
3718 char errbuf[1024];
3719 (void) snprintf(errbuf, sizeof (errbuf),
3720 dgettext(TEXT_DOMAIN, "cannot destroy snapshots"));
3721
3722 ret = zfs_standard_error(hdl, ret, errbuf);
3723 }
3724 for (pair = nvlist_next_nvpair(errlist, NULL);
3725 pair != NULL; pair = nvlist_next_nvpair(errlist, pair)) {
3726 char errbuf[1024];
3727 (void) snprintf(errbuf, sizeof (errbuf),
3728 dgettext(TEXT_DOMAIN, "cannot destroy snapshot %s"),
3729 nvpair_name(pair));
3730
3731 switch (fnvpair_value_int32(pair)) {
3732 case EEXIST:
3733 zfs_error_aux(hdl,
3734 dgettext(TEXT_DOMAIN, "snapshot is cloned"));
3735 ret = zfs_error(hdl, EZFS_EXISTS, errbuf);
3736 break;
3737 default:
3738 ret = zfs_standard_error(hdl, errno, errbuf);
3739 break;
3740 }
3741 }
3742
3743 nvlist_free(errlist);
3744 return (ret);
3745 }
3746
3747 /*
3748 * Clones the given dataset. The target must be of the same type as the source.
3749 */
3750 int
3751 zfs_clone(zfs_handle_t *zhp, const char *target, nvlist_t *props)
3752 {
3753 char parent[ZFS_MAX_DATASET_NAME_LEN];
3754 int ret;
3755 char errbuf[1024];
3756 libzfs_handle_t *hdl = zhp->zfs_hdl;
3757 uint64_t zoned;
3758
3759 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);
3760
3761 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3762 "cannot create '%s'"), target);
3763
3764 /* validate the target/clone name */
3765 if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM, B_TRUE))
3766 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3767
3768 /* validate parents exist */
3769 if (check_parents(hdl, target, &zoned, B_FALSE, NULL) != 0)
3770 return (-1);
3771
3772 (void) parent_name(target, parent, sizeof (parent));
3773
3774 /* do the clone */
3775
3776 if (props) {
3777 zfs_type_t type;
3778 if (ZFS_IS_VOLUME(zhp)) {
3779 type = ZFS_TYPE_VOLUME;
3780 } else {
3781 type = ZFS_TYPE_FILESYSTEM;
3782 }
3783 if ((props = zfs_valid_proplist(hdl, type, props, zoned,
3784 zhp, zhp->zpool_hdl, B_TRUE, errbuf)) == NULL)
3785 return (-1);
3786 }
3787
3788 if (zfs_crypto_clone_check(hdl, zhp, parent, props) != 0) {
3789 nvlist_free(props);
3790 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
3791 }
3792
3793 ret = lzc_clone(target, zhp->zfs_name, props);
3794 nvlist_free(props);
3795
3796 if (ret != 0) {
3797 switch (errno) {
3798
3799 case ENOENT:
3800 /*
3801 * The parent doesn't exist. We should have caught this
3802 * above, but there may a race condition that has since
3803 * destroyed the parent.
3804 *
3805 * At this point, we don't know whether it's the source
3806 * that doesn't exist anymore, or whether the target
3807 * dataset doesn't exist.
3808 */
3809 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3810 "no such parent '%s'"), parent);
3811 return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));
3812
3813 case EXDEV:
3814 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3815 "source and target pools differ"));
3816 return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET,
3817 errbuf));
3818
3819 default:
3820 return (zfs_standard_error(zhp->zfs_hdl, errno,
3821 errbuf));
3822 }
3823 }
3824
3825 return (ret);
3826 }
3827
3828 /*
3829 * Promotes the given clone fs to be the clone parent.
3830 */
3831 int
3832 zfs_promote(zfs_handle_t *zhp)
3833 {
3834 libzfs_handle_t *hdl = zhp->zfs_hdl;
3835 char snapname[ZFS_MAX_DATASET_NAME_LEN];
3836 int ret;
3837 char errbuf[1024];
3838
3839 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3840 "cannot promote '%s'"), zhp->zfs_name);
3841
3842 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
3843 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3844 "snapshots can not be promoted"));
3845 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
3846 }
3847
3848 if (zhp->zfs_dmustats.dds_origin[0] == '\0') {
3849 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3850 "not a cloned filesystem"));
3851 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
3852 }
3853
3854 if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
3855 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3856
3857 ret = lzc_promote(zhp->zfs_name, snapname, sizeof (snapname));
3858
3859 if (ret != 0) {
3860 switch (ret) {
3861 case EEXIST:
3862 /* There is a conflicting snapshot name. */
3863 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3864 "conflicting snapshot '%s' from parent '%s'"),
3865 snapname, zhp->zfs_dmustats.dds_origin);
3866 return (zfs_error(hdl, EZFS_EXISTS, errbuf));
3867
3868 default:
3869 return (zfs_standard_error(hdl, ret, errbuf));
3870 }
3871 }
3872 return (ret);
3873 }
3874
3875 typedef struct snapdata {
3876 nvlist_t *sd_nvl;
3877 const char *sd_snapname;
3878 } snapdata_t;
3879
3880 static int
3881 zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
3882 {
3883 snapdata_t *sd = arg;
3884 char name[ZFS_MAX_DATASET_NAME_LEN];
3885 int rv = 0;
3886
3887 if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) == 0) {
3888 if (snprintf(name, sizeof (name), "%s@%s", zfs_get_name(zhp),
3889 sd->sd_snapname) >= sizeof (name))
3890 return (EINVAL);
3891
3892 fnvlist_add_boolean(sd->sd_nvl, name);
3893
3894 rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
3895 }
3896 zfs_close(zhp);
3897
3898 return (rv);
3899 }
3900
3901 /*
3902 * Creates snapshots. The keys in the snaps nvlist are the snapshots to be
3903 * created.
3904 */
3905 int
3906 zfs_snapshot_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, nvlist_t *props)
3907 {
3908 int ret;
3909 char errbuf[1024];
3910 nvpair_t *elem;
3911 nvlist_t *errors;
3912 zpool_handle_t *zpool_hdl;
3913 char pool[ZFS_MAX_DATASET_NAME_LEN];
3914
3915 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3916 "cannot create snapshots "));
3917
3918 elem = NULL;
3919 while ((elem = nvlist_next_nvpair(snaps, elem)) != NULL) {
3920 const char *snapname = nvpair_name(elem);
3921
3922 /* validate the target name */
3923 if (!zfs_validate_name(hdl, snapname, ZFS_TYPE_SNAPSHOT,
3924 B_TRUE)) {
3925 (void) snprintf(errbuf, sizeof (errbuf),
3926 dgettext(TEXT_DOMAIN,
3927 "cannot create snapshot '%s'"), snapname);
3928 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3929 }
3930 }
3931
3932 /*
3933 * get pool handle for prop validation. assumes all snaps are in the
3934 * same pool, as does lzc_snapshot (below).
3935 */
3936 elem = nvlist_next_nvpair(snaps, NULL);
3937 (void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
3938 pool[strcspn(pool, "/@")] = '\0';
3939 zpool_hdl = zpool_open(hdl, pool);
3940 if (zpool_hdl == NULL)
3941 return (-1);
3942
3943 if (props != NULL &&
3944 (props = zfs_valid_proplist(hdl, ZFS_TYPE_SNAPSHOT,
3945 props, B_FALSE, NULL, zpool_hdl, B_FALSE, errbuf)) == NULL) {
3946 zpool_close(zpool_hdl);
3947 return (-1);
3948 }
3949 zpool_close(zpool_hdl);
3950
3951 ret = lzc_snapshot(snaps, props, &errors);
3952
3953 if (ret != 0) {
3954 boolean_t printed = B_FALSE;
3955 for (elem = nvlist_next_nvpair(errors, NULL);
3956 elem != NULL;
3957 elem = nvlist_next_nvpair(errors, elem)) {
3958 (void) snprintf(errbuf, sizeof (errbuf),
3959 dgettext(TEXT_DOMAIN,
3960 "cannot create snapshot '%s'"), nvpair_name(elem));
3961 (void) zfs_standard_error(hdl,
3962 fnvpair_value_int32(elem), errbuf);
3963 printed = B_TRUE;
3964 }
3965 if (!printed) {
3966 switch (ret) {
3967 case EXDEV:
3968 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3969 "multiple snapshots of same "
3970 "fs not allowed"));
3971 (void) zfs_error(hdl, EZFS_EXISTS, errbuf);
3972
3973 break;
3974 default:
3975 (void) zfs_standard_error(hdl, ret, errbuf);
3976 }
3977 }
3978 }
3979
3980 nvlist_free(props);
3981 nvlist_free(errors);
3982 return (ret);
3983 }
3984
3985 int
3986 zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive,
3987 nvlist_t *props)
3988 {
3989 int ret;
3990 snapdata_t sd = { 0 };
3991 char fsname[ZFS_MAX_DATASET_NAME_LEN];
3992 char *cp;
3993 zfs_handle_t *zhp;
3994 char errbuf[1024];
3995
3996 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3997 "cannot snapshot %s"), path);
3998
3999 if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT, B_TRUE))
4000 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4001
4002 (void) strlcpy(fsname, path, sizeof (fsname));
4003 cp = strchr(fsname, '@');
4004 *cp = '\0';
4005 sd.sd_snapname = cp + 1;
4006
4007 if ((zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM |
4008 ZFS_TYPE_VOLUME)) == NULL) {
4009 return (-1);
4010 }
4011
4012 verify(nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) == 0);
4013 if (recursive) {
4014 (void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd);
4015 } else {
4016 fnvlist_add_boolean(sd.sd_nvl, path);
4017 }
4018
4019 ret = zfs_snapshot_nvl(hdl, sd.sd_nvl, props);
4020 nvlist_free(sd.sd_nvl);
4021 zfs_close(zhp);
4022 return (ret);
4023 }
4024
4025 /*
4026 * Destroy any more recent snapshots. We invoke this callback on any dependents
4027 * of the snapshot first. If the 'cb_dependent' member is non-zero, then this
4028 * is a dependent and we should just destroy it without checking the transaction
4029 * group.
4030 */
4031 typedef struct rollback_data {
4032 const char *cb_target; /* the snapshot */
4033 uint64_t cb_create; /* creation time reference */
4034 boolean_t cb_error;
4035 boolean_t cb_force;
4036 } rollback_data_t;
4037
4038 static int
4039 rollback_destroy_dependent(zfs_handle_t *zhp, void *data)
4040 {
4041 rollback_data_t *cbp = data;
4042 prop_changelist_t *clp;
4043
4044 /* We must destroy this clone; first unmount it */
4045 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
4046 cbp->cb_force ? MS_FORCE: 0);
4047 if (clp == NULL || changelist_prefix(clp) != 0) {
4048 cbp->cb_error = B_TRUE;
4049 zfs_close(zhp);
4050 return (0);
4051 }
4052 if (zfs_destroy(zhp, B_FALSE) != 0)
4053 cbp->cb_error = B_TRUE;
4054 else
4055 changelist_remove(clp, zhp->zfs_name);
4056 (void) changelist_postfix(clp);
4057 changelist_free(clp);
4058
4059 zfs_close(zhp);
4060 return (0);
4061 }
4062
4063 static int
4064 rollback_destroy(zfs_handle_t *zhp, void *data)
4065 {
4066 rollback_data_t *cbp = data;
4067
4068 if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
4069 cbp->cb_error |= zfs_iter_dependents(zhp, B_FALSE,
4070 rollback_destroy_dependent, cbp);
4071
4072 cbp->cb_error |= zfs_destroy(zhp, B_FALSE);
4073 }
4074
4075 zfs_close(zhp);
4076 return (0);
4077 }
4078
4079 /*
4080 * Given a dataset, rollback to a specific snapshot, discarding any
4081 * data changes since then and making it the active dataset.
4082 *
4083 * Any snapshots and bookmarks more recent than the target are
4084 * destroyed, along with their dependents (i.e. clones).
4085 */
4086 int
4087 zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, boolean_t force)
4088 {
4089 rollback_data_t cb = { 0 };
4090 int err;
4091 boolean_t restore_resv = 0;
4092 uint64_t old_volsize = 0, new_volsize;
4093 zfs_prop_t resv_prop = { 0 };
4094
4095 assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM ||
4096 zhp->zfs_type == ZFS_TYPE_VOLUME);
4097
4098 /*
4099 * Destroy all recent snapshots and their dependents.
4100 */
4101 cb.cb_force = force;
4102 cb.cb_target = snap->zfs_name;
4103 cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
4104 (void) zfs_iter_snapshots(zhp, B_FALSE, rollback_destroy, &cb);
4105 (void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb);
4106
4107 if (cb.cb_error)
4108 return (-1);
4109
4110 /*
4111 * Now that we have verified that the snapshot is the latest,
4112 * rollback to the given snapshot.
4113 */
4114
4115 if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
4116 if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
4117 return (-1);
4118 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
4119 restore_resv =
4120 (old_volsize == zfs_prop_get_int(zhp, resv_prop));
4121 }
4122
4123 /*
4124 * Pass both the filesystem and the wanted snapshot names,
4125 * we would get an error back if the snapshot is destroyed or
4126 * a new snapshot is created before this request is processed.
4127 */
4128 err = lzc_rollback_to(zhp->zfs_name, snap->zfs_name);
4129 if (err == EXDEV) {
4130 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
4131 "'%s' is not the latest snapshot"), snap->zfs_name);
4132 (void) zfs_error_fmt(zhp->zfs_hdl, EZFS_BUSY,
4133 dgettext(TEXT_DOMAIN, "cannot rollback '%s'"),
4134 zhp->zfs_name);
4135 return (err);
4136 } else if (err != 0) {
4137 (void) zfs_standard_error_fmt(zhp->zfs_hdl, errno,
4138 dgettext(TEXT_DOMAIN, "cannot rollback '%s'"),
4139 zhp->zfs_name);
4140 return (err);
4141 }
4142
4143 /*
4144 * For volumes, if the pre-rollback volsize matched the pre-
4145 * rollback reservation and the volsize has changed then set
4146 * the reservation property to the post-rollback volsize.
4147 * Make a new handle since the rollback closed the dataset.
4148 */
4149 if ((zhp->zfs_type == ZFS_TYPE_VOLUME) &&
4150 (zhp = make_dataset_handle(zhp->zfs_hdl, zhp->zfs_name))) {
4151 if (restore_resv) {
4152 new_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
4153 if (old_volsize != new_volsize)
4154 err = zfs_prop_set_int(zhp, resv_prop,
4155 new_volsize);
4156 }
4157 zfs_close(zhp);
4158 }
4159 return (err);
4160 }
4161
4162 /*
4163 * Renames the given dataset.
4164 */
4165 int
4166 zfs_rename(zfs_handle_t *zhp, const char *target, boolean_t recursive,
4167 boolean_t force_unmount)
4168 {
4169 int ret = 0;
4170 zfs_cmd_t zc = {"\0"};
4171 char *delim;
4172 prop_changelist_t *cl = NULL;
4173 zfs_handle_t *zhrp = NULL;
4174 char *parentname = NULL;
4175 char parent[ZFS_MAX_DATASET_NAME_LEN];
4176 libzfs_handle_t *hdl = zhp->zfs_hdl;
4177 char errbuf[1024];
4178
4179 /* if we have the same exact name, just return success */
4180 if (strcmp(zhp->zfs_name, target) == 0)
4181 return (0);
4182
4183 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4184 "cannot rename to '%s'"), target);
4185
4186 /* make sure source name is valid */
4187 if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
4188 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4189
4190 /*
4191 * Make sure the target name is valid
4192 */
4193 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
4194 if ((strchr(target, '@') == NULL) ||
4195 *target == '@') {
4196 /*
4197 * Snapshot target name is abbreviated,
4198 * reconstruct full dataset name
4199 */
4200 (void) strlcpy(parent, zhp->zfs_name,
4201 sizeof (parent));
4202 delim = strchr(parent, '@');
4203 if (strchr(target, '@') == NULL)
4204 *(++delim) = '\0';
4205 else
4206 *delim = '\0';
4207 (void) strlcat(parent, target, sizeof (parent));
4208 target = parent;
4209 } else {
4210 /*
4211 * Make sure we're renaming within the same dataset.
4212 */
4213 delim = strchr(target, '@');
4214 if (strncmp(zhp->zfs_name, target, delim - target)
4215 != 0 || zhp->zfs_name[delim - target] != '@') {
4216 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4217 "snapshots must be part of same "
4218 "dataset"));
4219 return (zfs_error(hdl, EZFS_CROSSTARGET,
4220 errbuf));
4221 }
4222 }
4223 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4224 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4225 } else {
4226 if (recursive) {
4227 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4228 "recursive rename must be a snapshot"));
4229 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
4230 }
4231
4232 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4233 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4234
4235 /* validate parents */
4236 if (check_parents(hdl, target, NULL, B_FALSE, NULL) != 0)
4237 return (-1);
4238
4239 /* make sure we're in the same pool */
4240 verify((delim = strchr(target, '/')) != NULL);
4241 if (strncmp(zhp->zfs_name, target, delim - target) != 0 ||
4242 zhp->zfs_name[delim - target] != '/') {
4243 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4244 "datasets must be within same pool"));
4245 return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
4246 }
4247
4248 /* new name cannot be a child of the current dataset name */
4249 if (is_descendant(zhp->zfs_name, target)) {
4250 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4251 "New dataset name cannot be a descendant of "
4252 "current dataset name"));
4253 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4254 }
4255 }
4256
4257 (void) snprintf(errbuf, sizeof (errbuf),
4258 dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name);
4259
4260 if (getzoneid() == GLOBAL_ZONEID &&
4261 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
4262 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4263 "dataset is used in a non-global zone"));
4264 return (zfs_error(hdl, EZFS_ZONED, errbuf));
4265 }
4266
4267 if (recursive) {
4268 parentname = zfs_strdup(zhp->zfs_hdl, zhp->zfs_name);
4269 if (parentname == NULL) {
4270 ret = -1;
4271 goto error;
4272 }
4273 delim = strchr(parentname, '@');
4274 *delim = '\0';
4275 zhrp = zfs_open(zhp->zfs_hdl, parentname, ZFS_TYPE_DATASET);
4276 if (zhrp == NULL) {
4277 ret = -1;
4278 goto error;
4279 }
4280 } else if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT) {
4281 if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0,
4282 force_unmount ? MS_FORCE : 0)) == NULL)
4283 return (-1);
4284
4285 if (changelist_haszonedchild(cl)) {
4286 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4287 "child dataset with inherited mountpoint is used "
4288 "in a non-global zone"));
4289 (void) zfs_error(hdl, EZFS_ZONED, errbuf);
4290 ret = -1;
4291 goto error;
4292 }
4293
4294 if ((ret = changelist_prefix(cl)) != 0)
4295 goto error;
4296 }
4297
4298 if (ZFS_IS_VOLUME(zhp))
4299 zc.zc_objset_type = DMU_OST_ZVOL;
4300 else
4301 zc.zc_objset_type = DMU_OST_ZFS;
4302
4303 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4304 (void) strlcpy(zc.zc_value, target, sizeof (zc.zc_value));
4305
4306 zc.zc_cookie = recursive;
4307
4308 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_RENAME, &zc)) != 0) {
4309 /*
4310 * if it was recursive, the one that actually failed will
4311 * be in zc.zc_name
4312 */
4313 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4314 "cannot rename '%s'"), zc.zc_name);
4315
4316 if (recursive && errno == EEXIST) {
4317 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4318 "a child dataset already has a snapshot "
4319 "with the new name"));
4320 (void) zfs_error(hdl, EZFS_EXISTS, errbuf);
4321 } else if (errno == EACCES) {
4322 if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) ==
4323 ZIO_CRYPT_OFF) {
4324 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4325 "cannot rename an unencrypted dataset to "
4326 "be a decendent of an encrypted one"));
4327 } else {
4328 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4329 "cannot move encryption child outside of "
4330 "its encryption root"));
4331 }
4332 (void) zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf);
4333 } else {
4334 (void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf);
4335 }
4336
4337 /*
4338 * On failure, we still want to remount any filesystems that
4339 * were previously mounted, so we don't alter the system state.
4340 */
4341 if (cl != NULL)
4342 (void) changelist_postfix(cl);
4343 } else {
4344 if (cl != NULL) {
4345 changelist_rename(cl, zfs_get_name(zhp), target);
4346 ret = changelist_postfix(cl);
4347 }
4348 }
4349
4350 error:
4351 if (parentname != NULL) {
4352 free(parentname);
4353 }
4354 if (zhrp != NULL) {
4355 zfs_close(zhrp);
4356 }
4357 if (cl != NULL) {
4358 changelist_free(cl);
4359 }
4360 return (ret);
4361 }
4362
4363 nvlist_t *
4364 zfs_get_all_props(zfs_handle_t *zhp)
4365 {
4366 return (zhp->zfs_props);
4367 }
4368
4369 nvlist_t *
4370 zfs_get_recvd_props(zfs_handle_t *zhp)
4371 {
4372 if (zhp->zfs_recvd_props == NULL)
4373 if (get_recvd_props_ioctl(zhp) != 0)
4374 return (NULL);
4375 return (zhp->zfs_recvd_props);
4376 }
4377
4378 nvlist_t *
4379 zfs_get_user_props(zfs_handle_t *zhp)
4380 {
4381 return (zhp->zfs_user_props);
4382 }
4383
4384 /*
4385 * This function is used by 'zfs list' to determine the exact set of columns to
4386 * display, and their maximum widths. This does two main things:
4387 *
4388 * - If this is a list of all properties, then expand the list to include
4389 * all native properties, and set a flag so that for each dataset we look
4390 * for new unique user properties and add them to the list.
4391 *
4392 * - For non fixed-width properties, keep track of the maximum width seen
4393 * so that we can size the column appropriately. If the user has
4394 * requested received property values, we also need to compute the width
4395 * of the RECEIVED column.
4396 */
4397 int
4398 zfs_expand_proplist(zfs_handle_t *zhp, zprop_list_t **plp, boolean_t received,
4399 boolean_t literal)
4400 {
4401 libzfs_handle_t *hdl = zhp->zfs_hdl;
4402 zprop_list_t *entry;
4403 zprop_list_t **last, **start;
4404 nvlist_t *userprops, *propval;
4405 nvpair_t *elem;
4406 char *strval;
4407 char buf[ZFS_MAXPROPLEN];
4408
4409 if (zprop_expand_list(hdl, plp, ZFS_TYPE_DATASET) != 0)
4410 return (-1);
4411
4412 userprops = zfs_get_user_props(zhp);
4413
4414 entry = *plp;
4415 if (entry->pl_all && nvlist_next_nvpair(userprops, NULL) != NULL) {
4416 /*
4417 * Go through and add any user properties as necessary. We
4418 * start by incrementing our list pointer to the first
4419 * non-native property.
4420 */
4421 start = plp;
4422 while (*start != NULL) {
4423 if ((*start)->pl_prop == ZPROP_INVAL)
4424 break;
4425 start = &(*start)->pl_next;
4426 }
4427
4428 elem = NULL;
4429 while ((elem = nvlist_next_nvpair(userprops, elem)) != NULL) {
4430 /*
4431 * See if we've already found this property in our list.
4432 */
4433 for (last = start; *last != NULL;
4434 last = &(*last)->pl_next) {
4435 if (strcmp((*last)->pl_user_prop,
4436 nvpair_name(elem)) == 0)
4437 break;
4438 }
4439
4440 if (*last == NULL) {
4441 if ((entry = zfs_alloc(hdl,
4442 sizeof (zprop_list_t))) == NULL ||
4443 ((entry->pl_user_prop = zfs_strdup(hdl,
4444 nvpair_name(elem)))) == NULL) {
4445 free(entry);
4446 return (-1);
4447 }
4448
4449 entry->pl_prop = ZPROP_INVAL;
4450 entry->pl_width = strlen(nvpair_name(elem));
4451 entry->pl_all = B_TRUE;
4452 *last = entry;
4453 }
4454 }
4455 }
4456
4457 /*
4458 * Now go through and check the width of any non-fixed columns
4459 */
4460 for (entry = *plp; entry != NULL; entry = entry->pl_next) {
4461 if (entry->pl_fixed && !literal)
4462 continue;
4463
4464 if (entry->pl_prop != ZPROP_INVAL) {
4465 if (zfs_prop_get(zhp, entry->pl_prop,
4466 buf, sizeof (buf), NULL, NULL, 0, literal) == 0) {
4467 if (strlen(buf) > entry->pl_width)
4468 entry->pl_width = strlen(buf);
4469 }
4470 if (received && zfs_prop_get_recvd(zhp,
4471 zfs_prop_to_name(entry->pl_prop),
4472 buf, sizeof (buf), literal) == 0)
4473 if (strlen(buf) > entry->pl_recvd_width)
4474 entry->pl_recvd_width = strlen(buf);
4475 } else {
4476 if (nvlist_lookup_nvlist(userprops, entry->pl_user_prop,
4477 &propval) == 0) {
4478 verify(nvlist_lookup_string(propval,
4479 ZPROP_VALUE, &strval) == 0);
4480 if (strlen(strval) > entry->pl_width)
4481 entry->pl_width = strlen(strval);
4482 }
4483 if (received && zfs_prop_get_recvd(zhp,
4484 entry->pl_user_prop,
4485 buf, sizeof (buf), literal) == 0)
4486 if (strlen(buf) > entry->pl_recvd_width)
4487 entry->pl_recvd_width = strlen(buf);
4488 }
4489 }
4490
4491 return (0);
4492 }
4493
4494 void
4495 zfs_prune_proplist(zfs_handle_t *zhp, uint8_t *props)
4496 {
4497 nvpair_t *curr;
4498 nvpair_t *next;
4499
4500 /*
4501 * Keep a reference to the props-table against which we prune the
4502 * properties.
4503 */
4504 zhp->zfs_props_table = props;
4505
4506 curr = nvlist_next_nvpair(zhp->zfs_props, NULL);
4507
4508 while (curr) {
4509 zfs_prop_t zfs_prop = zfs_name_to_prop(nvpair_name(curr));
4510 next = nvlist_next_nvpair(zhp->zfs_props, curr);
4511
4512 /*
4513 * User properties will result in ZPROP_INVAL, and since we
4514 * only know how to prune standard ZFS properties, we always
4515 * leave these in the list. This can also happen if we
4516 * encounter an unknown DSL property (when running older
4517 * software, for example).
4518 */
4519 if (zfs_prop != ZPROP_INVAL && props[zfs_prop] == B_FALSE)
4520 (void) nvlist_remove(zhp->zfs_props,
4521 nvpair_name(curr), nvpair_type(curr));
4522 curr = next;
4523 }
4524 }
4525
4526 static int
4527 zfs_smb_acl_mgmt(libzfs_handle_t *hdl, char *dataset, char *path,
4528 zfs_smb_acl_op_t cmd, char *resource1, char *resource2)
4529 {
4530 zfs_cmd_t zc = {"\0"};
4531 nvlist_t *nvlist = NULL;
4532 int error;
4533
4534 (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
4535 (void) strlcpy(zc.zc_value, path, sizeof (zc.zc_value));
4536 zc.zc_cookie = (uint64_t)cmd;
4537
4538 if (cmd == ZFS_SMB_ACL_RENAME) {
4539 if (nvlist_alloc(&nvlist, NV_UNIQUE_NAME, 0) != 0) {
4540 (void) no_memory(hdl);
4541 return (0);
4542 }
4543 }
4544
4545 switch (cmd) {
4546 case ZFS_SMB_ACL_ADD:
4547 case ZFS_SMB_ACL_REMOVE:
4548 (void) strlcpy(zc.zc_string, resource1, sizeof (zc.zc_string));
4549 break;
4550 case ZFS_SMB_ACL_RENAME:
4551 if (nvlist_add_string(nvlist, ZFS_SMB_ACL_SRC,
4552 resource1) != 0) {
4553 (void) no_memory(hdl);
4554 return (-1);
4555 }
4556 if (nvlist_add_string(nvlist, ZFS_SMB_ACL_TARGET,
4557 resource2) != 0) {
4558 (void) no_memory(hdl);
4559 return (-1);
4560 }
4561 if (zcmd_write_src_nvlist(hdl, &zc, nvlist) != 0) {
4562 nvlist_free(nvlist);
4563 return (-1);
4564 }
4565 break;
4566 case ZFS_SMB_ACL_PURGE:
4567 break;
4568 default:
4569 return (-1);
4570 }
4571 error = ioctl(hdl->libzfs_fd, ZFS_IOC_SMB_ACL, &zc);
4572 nvlist_free(nvlist);
4573 return (error);
4574 }
4575
4576 int
4577 zfs_smb_acl_add(libzfs_handle_t *hdl, char *dataset,
4578 char *path, char *resource)
4579 {
4580 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_ADD,
4581 resource, NULL));
4582 }
4583
4584 int
4585 zfs_smb_acl_remove(libzfs_handle_t *hdl, char *dataset,
4586 char *path, char *resource)
4587 {
4588 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_REMOVE,
4589 resource, NULL));
4590 }
4591
4592 int
4593 zfs_smb_acl_purge(libzfs_handle_t *hdl, char *dataset, char *path)
4594 {
4595 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_PURGE,
4596 NULL, NULL));
4597 }
4598
4599 int
4600 zfs_smb_acl_rename(libzfs_handle_t *hdl, char *dataset, char *path,
4601 char *oldname, char *newname)
4602 {
4603 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_RENAME,
4604 oldname, newname));
4605 }
4606
4607 int
4608 zfs_userspace(zfs_handle_t *zhp, zfs_userquota_prop_t type,
4609 zfs_userspace_cb_t func, void *arg)
4610 {
4611 zfs_cmd_t zc = {"\0"};
4612 zfs_useracct_t buf[100];
4613 libzfs_handle_t *hdl = zhp->zfs_hdl;
4614 int ret;
4615
4616 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4617
4618 zc.zc_objset_type = type;
4619 zc.zc_nvlist_dst = (uintptr_t)buf;
4620
4621 for (;;) {
4622 zfs_useracct_t *zua = buf;
4623
4624 zc.zc_nvlist_dst_size = sizeof (buf);
4625 if (zfs_ioctl(hdl, ZFS_IOC_USERSPACE_MANY, &zc) != 0) {
4626 char errbuf[1024];
4627
4628 if ((errno == ENOTSUP &&
4629 (type == ZFS_PROP_USEROBJUSED ||
4630 type == ZFS_PROP_GROUPOBJUSED ||
4631 type == ZFS_PROP_USEROBJQUOTA ||
4632 type == ZFS_PROP_GROUPOBJQUOTA)))
4633 break;
4634
4635 (void) snprintf(errbuf, sizeof (errbuf),
4636 dgettext(TEXT_DOMAIN,
4637 "cannot get used/quota for %s"), zc.zc_name);
4638 return (zfs_standard_error_fmt(hdl, errno, errbuf));
4639 }
4640 if (zc.zc_nvlist_dst_size == 0)
4641 break;
4642
4643 while (zc.zc_nvlist_dst_size > 0) {
4644 if ((ret = func(arg, zua->zu_domain, zua->zu_rid,
4645 zua->zu_space)) != 0)
4646 return (ret);
4647 zua++;
4648 zc.zc_nvlist_dst_size -= sizeof (zfs_useracct_t);
4649 }
4650 }
4651
4652 return (0);
4653 }
4654
4655 struct holdarg {
4656 nvlist_t *nvl;
4657 const char *snapname;
4658 const char *tag;
4659 boolean_t recursive;
4660 int error;
4661 };
4662
4663 static int
4664 zfs_hold_one(zfs_handle_t *zhp, void *arg)
4665 {
4666 struct holdarg *ha = arg;
4667 char name[ZFS_MAX_DATASET_NAME_LEN];
4668 int rv = 0;
4669
4670 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
4671 ha->snapname) >= sizeof (name))
4672 return (EINVAL);
4673
4674 if (lzc_exists(name))
4675 fnvlist_add_string(ha->nvl, name, ha->tag);
4676
4677 if (ha->recursive)
4678 rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha);
4679 zfs_close(zhp);
4680 return (rv);
4681 }
4682
4683 int
4684 zfs_hold(zfs_handle_t *zhp, const char *snapname, const char *tag,
4685 boolean_t recursive, int cleanup_fd)
4686 {
4687 int ret;
4688 struct holdarg ha;
4689
4690 ha.nvl = fnvlist_alloc();
4691 ha.snapname = snapname;
4692 ha.tag = tag;
4693 ha.recursive = recursive;
4694 (void) zfs_hold_one(zfs_handle_dup(zhp), &ha);
4695
4696 if (nvlist_empty(ha.nvl)) {
4697 char errbuf[1024];
4698
4699 fnvlist_free(ha.nvl);
4700 ret = ENOENT;
4701 (void) snprintf(errbuf, sizeof (errbuf),
4702 dgettext(TEXT_DOMAIN,
4703 "cannot hold snapshot '%s@%s'"),
4704 zhp->zfs_name, snapname);
4705 (void) zfs_standard_error(zhp->zfs_hdl, ret, errbuf);
4706 return (ret);
4707 }
4708
4709 ret = zfs_hold_nvl(zhp, cleanup_fd, ha.nvl);
4710 fnvlist_free(ha.nvl);
4711
4712 return (ret);
4713 }
4714
4715 int
4716 zfs_hold_nvl(zfs_handle_t *zhp, int cleanup_fd, nvlist_t *holds)
4717 {
4718 int ret;
4719 nvlist_t *errors;
4720 libzfs_handle_t *hdl = zhp->zfs_hdl;
4721 char errbuf[1024];
4722 nvpair_t *elem;
4723
4724 errors = NULL;
4725 ret = lzc_hold(holds, cleanup_fd, &errors);
4726
4727 if (ret == 0) {
4728 /* There may be errors even in the success case. */
4729 fnvlist_free(errors);
4730 return (0);
4731 }
4732
4733 if (nvlist_empty(errors)) {
4734 /* no hold-specific errors */
4735 (void) snprintf(errbuf, sizeof (errbuf),
4736 dgettext(TEXT_DOMAIN, "cannot hold"));
4737 switch (ret) {
4738 case ENOTSUP:
4739 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4740 "pool must be upgraded"));
4741 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
4742 break;
4743 case EINVAL:
4744 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
4745 break;
4746 default:
4747 (void) zfs_standard_error(hdl, ret, errbuf);
4748 }
4749 }
4750
4751 for (elem = nvlist_next_nvpair(errors, NULL);
4752 elem != NULL;
4753 elem = nvlist_next_nvpair(errors, elem)) {
4754 (void) snprintf(errbuf, sizeof (errbuf),
4755 dgettext(TEXT_DOMAIN,
4756 "cannot hold snapshot '%s'"), nvpair_name(elem));
4757 switch (fnvpair_value_int32(elem)) {
4758 case E2BIG:
4759 /*
4760 * Temporary tags wind up having the ds object id
4761 * prepended. So even if we passed the length check
4762 * above, it's still possible for the tag to wind
4763 * up being slightly too long.
4764 */
4765 (void) zfs_error(hdl, EZFS_TAGTOOLONG, errbuf);
4766 break;
4767 case EINVAL:
4768 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
4769 break;
4770 case EEXIST:
4771 (void) zfs_error(hdl, EZFS_REFTAG_HOLD, errbuf);
4772 break;
4773 default:
4774 (void) zfs_standard_error(hdl,
4775 fnvpair_value_int32(elem), errbuf);
4776 }
4777 }
4778
4779 fnvlist_free(errors);
4780 return (ret);
4781 }
4782
4783 static int
4784 zfs_release_one(zfs_handle_t *zhp, void *arg)
4785 {
4786 struct holdarg *ha = arg;
4787 char name[ZFS_MAX_DATASET_NAME_LEN];
4788 int rv = 0;
4789 nvlist_t *existing_holds;
4790
4791 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
4792 ha->snapname) >= sizeof (name)) {
4793 ha->error = EINVAL;
4794 rv = EINVAL;
4795 }
4796
4797 if (lzc_get_holds(name, &existing_holds) != 0) {
4798 ha->error = ENOENT;
4799 } else if (!nvlist_exists(existing_holds, ha->tag)) {
4800 ha->error = ESRCH;
4801 } else {
4802 nvlist_t *torelease = fnvlist_alloc();
4803 fnvlist_add_boolean(torelease, ha->tag);
4804 fnvlist_add_nvlist(ha->nvl, name, torelease);
4805 fnvlist_free(torelease);
4806 }
4807
4808 if (ha->recursive)
4809 rv = zfs_iter_filesystems(zhp, zfs_release_one, ha);
4810 zfs_close(zhp);
4811 return (rv);
4812 }
4813
4814 int
4815 zfs_release(zfs_handle_t *zhp, const char *snapname, const char *tag,
4816 boolean_t recursive)
4817 {
4818 int ret;
4819 struct holdarg ha;
4820 nvlist_t *errors = NULL;
4821 nvpair_t *elem;
4822 libzfs_handle_t *hdl = zhp->zfs_hdl;
4823 char errbuf[1024];
4824
4825 ha.nvl = fnvlist_alloc();
4826 ha.snapname = snapname;
4827 ha.tag = tag;
4828 ha.recursive = recursive;
4829 ha.error = 0;
4830 (void) zfs_release_one(zfs_handle_dup(zhp), &ha);
4831
4832 if (nvlist_empty(ha.nvl)) {
4833 fnvlist_free(ha.nvl);
4834 ret = ha.error;
4835 (void) snprintf(errbuf, sizeof (errbuf),
4836 dgettext(TEXT_DOMAIN,
4837 "cannot release hold from snapshot '%s@%s'"),
4838 zhp->zfs_name, snapname);
4839 if (ret == ESRCH) {
4840 (void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
4841 } else {
4842 (void) zfs_standard_error(hdl, ret, errbuf);
4843 }
4844 return (ret);
4845 }
4846
4847 ret = lzc_release(ha.nvl, &errors);
4848 fnvlist_free(ha.nvl);
4849
4850 if (ret == 0) {
4851 /* There may be errors even in the success case. */
4852 fnvlist_free(errors);
4853 return (0);
4854 }
4855
4856 if (nvlist_empty(errors)) {
4857 /* no hold-specific errors */
4858 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4859 "cannot release"));
4860 switch (errno) {
4861 case ENOTSUP:
4862 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4863 "pool must be upgraded"));
4864 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
4865 break;
4866 default:
4867 (void) zfs_standard_error_fmt(hdl, errno, errbuf);
4868 }
4869 }
4870
4871 for (elem = nvlist_next_nvpair(errors, NULL);
4872 elem != NULL;
4873 elem = nvlist_next_nvpair(errors, elem)) {
4874 (void) snprintf(errbuf, sizeof (errbuf),
4875 dgettext(TEXT_DOMAIN,
4876 "cannot release hold from snapshot '%s'"),
4877 nvpair_name(elem));
4878 switch (fnvpair_value_int32(elem)) {
4879 case ESRCH:
4880 (void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
4881 break;
4882 case EINVAL:
4883 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
4884 break;
4885 default:
4886 (void) zfs_standard_error_fmt(hdl,
4887 fnvpair_value_int32(elem), errbuf);
4888 }
4889 }
4890
4891 fnvlist_free(errors);
4892 return (ret);
4893 }
4894
4895 int
4896 zfs_get_fsacl(zfs_handle_t *zhp, nvlist_t **nvl)
4897 {
4898 zfs_cmd_t zc = {"\0"};
4899 libzfs_handle_t *hdl = zhp->zfs_hdl;
4900 int nvsz = 2048;
4901 void *nvbuf;
4902 int err = 0;
4903 char errbuf[1024];
4904
4905 assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
4906 zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
4907
4908 tryagain:
4909
4910 nvbuf = malloc(nvsz);
4911 if (nvbuf == NULL) {
4912 err = (zfs_error(hdl, EZFS_NOMEM, strerror(errno)));
4913 goto out;
4914 }
4915
4916 zc.zc_nvlist_dst_size = nvsz;
4917 zc.zc_nvlist_dst = (uintptr_t)nvbuf;
4918
4919 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4920
4921 if (ioctl(hdl->libzfs_fd, ZFS_IOC_GET_FSACL, &zc) != 0) {
4922 (void) snprintf(errbuf, sizeof (errbuf),
4923 dgettext(TEXT_DOMAIN, "cannot get permissions on '%s'"),
4924 zc.zc_name);
4925 switch (errno) {
4926 case ENOMEM:
4927 free(nvbuf);
4928 nvsz = zc.zc_nvlist_dst_size;
4929 goto tryagain;
4930
4931 case ENOTSUP:
4932 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4933 "pool must be upgraded"));
4934 err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
4935 break;
4936 case EINVAL:
4937 err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
4938 break;
4939 case ENOENT:
4940 err = zfs_error(hdl, EZFS_NOENT, errbuf);
4941 break;
4942 default:
4943 err = zfs_standard_error_fmt(hdl, errno, errbuf);
4944 break;
4945 }
4946 } else {
4947 /* success */
4948 int rc = nvlist_unpack(nvbuf, zc.zc_nvlist_dst_size, nvl, 0);
4949 if (rc) {
4950 (void) snprintf(errbuf, sizeof (errbuf), dgettext(
4951 TEXT_DOMAIN, "cannot get permissions on '%s'"),
4952 zc.zc_name);
4953 err = zfs_standard_error_fmt(hdl, rc, errbuf);
4954 }
4955 }
4956
4957 free(nvbuf);
4958 out:
4959 return (err);
4960 }
4961
4962 int
4963 zfs_set_fsacl(zfs_handle_t *zhp, boolean_t un, nvlist_t *nvl)
4964 {
4965 zfs_cmd_t zc = {"\0"};
4966 libzfs_handle_t *hdl = zhp->zfs_hdl;
4967 char *nvbuf;
4968 char errbuf[1024];
4969 size_t nvsz;
4970 int err;
4971
4972 assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
4973 zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
4974
4975 err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE);
4976 assert(err == 0);
4977
4978 nvbuf = malloc(nvsz);
4979
4980 err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0);
4981 assert(err == 0);
4982
4983 zc.zc_nvlist_src_size = nvsz;
4984 zc.zc_nvlist_src = (uintptr_t)nvbuf;
4985 zc.zc_perm_action = un;
4986
4987 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4988
4989 if (zfs_ioctl(hdl, ZFS_IOC_SET_FSACL, &zc) != 0) {
4990 (void) snprintf(errbuf, sizeof (errbuf),
4991 dgettext(TEXT_DOMAIN, "cannot set permissions on '%s'"),
4992 zc.zc_name);
4993 switch (errno) {
4994 case ENOTSUP:
4995 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4996 "pool must be upgraded"));
4997 err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
4998 break;
4999 case EINVAL:
5000 err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
5001 break;
5002 case ENOENT:
5003 err = zfs_error(hdl, EZFS_NOENT, errbuf);
5004 break;
5005 default:
5006 err = zfs_standard_error_fmt(hdl, errno, errbuf);
5007 break;
5008 }
5009 }
5010
5011 free(nvbuf);
5012
5013 return (err);
5014 }
5015
5016 int
5017 zfs_get_holds(zfs_handle_t *zhp, nvlist_t **nvl)
5018 {
5019 int err;
5020 char errbuf[1024];
5021
5022 err = lzc_get_holds(zhp->zfs_name, nvl);
5023
5024 if (err != 0) {
5025 libzfs_handle_t *hdl = zhp->zfs_hdl;
5026
5027 (void) snprintf(errbuf, sizeof (errbuf),
5028 dgettext(TEXT_DOMAIN, "cannot get holds for '%s'"),
5029 zhp->zfs_name);
5030 switch (err) {
5031 case ENOTSUP:
5032 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5033 "pool must be upgraded"));
5034 err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
5035 break;
5036 case EINVAL:
5037 err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
5038 break;
5039 case ENOENT:
5040 err = zfs_error(hdl, EZFS_NOENT, errbuf);
5041 break;
5042 default:
5043 err = zfs_standard_error_fmt(hdl, errno, errbuf);
5044 break;
5045 }
5046 }
5047
5048 return (err);
5049 }
5050
5051 /*
5052 * Convert the zvol's volume size to an appropriate reservation.
5053 * Note: If this routine is updated, it is necessary to update the ZFS test
5054 * suite's shell version in reservation.kshlib.
5055 */
5056 uint64_t
5057 zvol_volsize_to_reservation(uint64_t volsize, nvlist_t *props)
5058 {
5059 uint64_t numdb;
5060 uint64_t nblocks, volblocksize;
5061 int ncopies;
5062 char *strval;
5063
5064 if (nvlist_lookup_string(props,
5065 zfs_prop_to_name(ZFS_PROP_COPIES), &strval) == 0)
5066 ncopies = atoi(strval);
5067 else
5068 ncopies = 1;
5069 if (nvlist_lookup_uint64(props,
5070 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
5071 &volblocksize) != 0)
5072 volblocksize = ZVOL_DEFAULT_BLOCKSIZE;
5073 nblocks = volsize/volblocksize;
5074 /* start with metadnode L0-L6 */
5075 numdb = 7;
5076 /* calculate number of indirects */
5077 while (nblocks > 1) {
5078 nblocks += DNODES_PER_LEVEL - 1;
5079 nblocks /= DNODES_PER_LEVEL;
5080 numdb += nblocks;
5081 }
5082 numdb *= MIN(SPA_DVAS_PER_BP, ncopies + 1);
5083 volsize *= ncopies;
5084 /*
5085 * this is exactly DN_MAX_INDBLKSHIFT when metadata isn't
5086 * compressed, but in practice they compress down to about
5087 * 1100 bytes
5088 */
5089 numdb *= 1ULL << DN_MAX_INDBLKSHIFT;
5090 volsize += numdb;
5091 return (volsize);
5092 }
ZFS On Linux mirror for PVE