Lines Matching defs:zhp
249 process_user_props(zfs_handle_t *zhp, nvlist_t *props)
251 libzfs_handle_t *hdl = zhp->zfs_hdl;
278 zpool_add_handle(zfs_handle_t *zhp, const char *pool_name)
280 libzfs_handle_t *hdl = zhp->zfs_hdl;
292 zpool_find_handle(zfs_handle_t *zhp, const char *pool_name, int len)
294 libzfs_handle_t *hdl = zhp->zfs_hdl;
309 zpool_handle(zfs_handle_t *zhp)
315 len = strcspn(zhp->zfs_name, "/@#") + 1;
316 pool_name = zfs_alloc(zhp->zfs_hdl, len);
317 (void) strlcpy(pool_name, zhp->zfs_name, len);
319 zph = zpool_find_handle(zhp, pool_name, len);
321 zph = zpool_add_handle(zhp, pool_name);
344 get_stats_ioctl(zfs_handle_t *zhp, zfs_cmd_t *zc)
346 libzfs_handle_t *hdl = zhp->zfs_hdl;
348 (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
366 get_recvd_props_ioctl(zfs_handle_t *zhp)
368 libzfs_handle_t *hdl = zhp->zfs_hdl;
376 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
389 err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops);
394 nvlist_free(zhp->zfs_recvd_props);
395 zhp->zfs_recvd_props = recvdprops;
401 put_stats_zhdl(zfs_handle_t *zhp, zfs_cmd_t *zc)
405 zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */
407 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) {
415 if ((userprops = process_user_props(zhp, allprops)) == NULL) {
420 nvlist_free(zhp->zfs_props);
421 nvlist_free(zhp->zfs_user_props);
423 zhp->zfs_props = allprops;
424 zhp->zfs_user_props = userprops;
430 get_stats(zfs_handle_t *zhp)
435 if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
437 if (get_stats_ioctl(zhp, &zc) != 0)
439 else if (put_stats_zhdl(zhp, &zc) != 0)
449 zfs_refresh_properties(zfs_handle_t *zhp)
451 (void) get_stats(zhp);
459 make_dataset_handle_common(zfs_handle_t *zhp, zfs_cmd_t *zc)
461 if (put_stats_zhdl(zhp, zc) != 0)
468 if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
469 zhp->zfs_head_type = ZFS_TYPE_VOLUME;
470 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
471 zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM;
475 if (zhp->zfs_dmustats.dds_is_snapshot)
476 zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
477 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
478 zhp->zfs_type = ZFS_TYPE_VOLUME;
479 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
480 zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
484 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL)
495 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
497 if (zhp == NULL)
500 zhp->zfs_hdl = hdl;
501 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
503 free(zhp);
506 if (get_stats_ioctl(zhp, &zc) == -1) {
508 free(zhp);
511 if (make_dataset_handle_common(zhp, &zc) == -1) {
512 free(zhp);
513 zhp = NULL;
516 return (zhp);
522 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
524 if (zhp == NULL)
527 zhp->zfs_hdl = hdl;
528 (void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
529 if (make_dataset_handle_common(zhp, zc) == -1) {
530 free(zhp);
533 return (zhp);
539 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
541 if (zhp == NULL)
544 zhp->zfs_hdl = zhp_orig->zfs_hdl;
545 zhp->zpool_hdl = zhp_orig->zpool_hdl;
546 (void) strlcpy(zhp->zfs_name, zhp_orig->zfs_name,
547 sizeof (zhp->zfs_name));
548 zhp->zfs_type = zhp_orig->zfs_type;
549 zhp->zfs_head_type = zhp_orig->zfs_head_type;
550 zhp->zfs_dmustats = zhp_orig->zfs_dmustats;
552 if (nvlist_dup(zhp_orig->zfs_props, &zhp->zfs_props, 0) != 0) {
553 (void) no_memory(zhp->zfs_hdl);
554 zfs_close(zhp);
560 &zhp->zfs_user_props, 0) != 0) {
561 (void) no_memory(zhp->zfs_hdl);
562 zfs_close(zhp);
568 &zhp->zfs_recvd_props, 0)) {
569 (void) no_memory(zhp->zfs_hdl);
570 zfs_close(zhp);
574 zhp->zfs_mntcheck = zhp_orig->zfs_mntcheck;
576 zhp->zfs_mntopts = zfs_strdup(zhp_orig->zfs_hdl,
579 zhp->zfs_props_table = zhp_orig->zfs_props_table;
580 return (zhp);
619 zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
621 if (zhp == NULL)
625 zhp->zfs_hdl = parent->zfs_hdl;
626 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
629 if (nvlist_dup(bmark_props, &zhp->zfs_props, 0) != 0) {
630 free(zhp);
635 zhp->zfs_head_type = parent->zfs_head_type;
636 zhp->zfs_type = ZFS_TYPE_BOOKMARK;
638 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) {
639 nvlist_free(zhp->zfs_props);
640 free(zhp);
644 return (zhp);
649 zfs_handle_t *zhp;
653 zfs_open_bookmarks_cb(zfs_handle_t *zhp, void *data)
660 if (strcmp(dp->path, zfs_get_name(zhp)) == 0) {
664 dp->zhp = zhp;
671 zfs_close(zhp);
683 zfs_handle_t *zhp;
708 if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
739 &cb_data) == 0) && (cb_data.zhp == NULL)) {
744 if (cb_data.zhp == NULL) {
749 zhp = cb_data.zhp;
757 if (!(types & zhp->zfs_type)) {
759 zfs_close(zhp);
763 return (zhp);
770 zfs_close(zfs_handle_t *zhp)
772 if (zhp->zfs_mntopts)
773 free(zhp->zfs_mntopts);
774 nvlist_free(zhp->zfs_props);
775 nvlist_free(zhp->zfs_user_props);
776 nvlist_free(zhp->zfs_recvd_props);
777 free(zhp);
916 zfs_spa_version(zfs_handle_t *zhp, int *spa_version)
918 zpool_handle_t *zpool_handle = zhp->zpool_hdl;
932 zfs_which_resv_prop(zfs_handle_t *zhp, zfs_prop_t *resv_prop)
936 if (zfs_spa_version(zhp, &spa_version) < 0)
954 uint64_t zoned, zfs_handle_t *zhp, zpool_handle_t *zpool_hdl,
1112 (!zfs_prop_setonce(prop) || zhp != NULL)) {
1132 if (zhp == NULL)
1134 version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1381 if (type == ZFS_TYPE_VOLUME && zhp != NULL) {
1382 uint64_t volsize = zfs_prop_get_int(zhp,
1384 uint64_t blocksize = zfs_prop_get_int(zhp,
1455 zfs_add_synthetic_resv(zfs_handle_t *zhp, nvlist_t *nvl)
1468 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1469 if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
1471 old_reservation = zfs_prop_get_int(zhp, resv_prop);
1475 zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));
1493 (void) no_memory(zhp->zfs_hdl);
1600 zfs_prop_set(zfs_handle_t *zhp, const char *propname, const char *propval)
1604 libzfs_handle_t *hdl = zhp->zfs_hdl;
1609 zhp->zfs_name);
1617 ret = zfs_prop_set_list(zhp, nvl);
1631 zfs_prop_set_list(zfs_handle_t *zhp, nvlist_t *props)
1638 libzfs_handle_t *hdl = zhp->zfs_hdl;
1645 zhp->zfs_name);
1647 if ((nvl = zfs_valid_proplist(hdl, zhp->zfs_type, props,
1648 zfs_prop_get_int(zhp, ZFS_PROP_ZONED), zhp, zhp->zpool_hdl,
1660 (added_resv = zfs_add_synthetic_resv(zhp, nvl)) == -1) {
1691 cls[cl_idx] = changelist_gather(zhp, prop, 0, 0);
1716 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1739 uint64_t old_volsize = zfs_prop_get_int(zhp,
1769 (void) get_stats(zhp);
1790 zfs_prop_inherit(zfs_handle_t *zhp, const char *propname, boolean_t received)
1795 libzfs_handle_t *hdl = zhp->zfs_hdl;
1800 "cannot inherit %s for '%s'"), propname, zhp->zfs_name);
1814 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1817 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc) != 0)
1835 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
1842 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1846 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
1855 if ((cl = changelist_gather(zhp, prop, 0, 0)) == NULL)
1869 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc)) != 0) {
1879 (void) get_stats(zhp);
1892 getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
1898 if (nvlist_lookup_nvlist(zhp->zfs_props,
1903 verify(!zhp->zfs_props_table ||
1904 zhp->zfs_props_table[prop] == B_TRUE);
1913 getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
1919 if (nvlist_lookup_nvlist(zhp->zfs_props,
1924 verify(!zhp->zfs_props_table ||
1925 zhp->zfs_props_table[prop] == B_TRUE);
1934 zfs_is_recvd_props_mode(zfs_handle_t *zhp)
1936 return (zhp->zfs_props == zhp->zfs_recvd_props);
1940 zfs_set_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
1942 *cookie = (uint64_t)(uintptr_t)zhp->zfs_props;
1943 zhp->zfs_props = zhp->zfs_recvd_props;
1947 zfs_unset_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
1949 zhp->zfs_props = (nvlist_t *)(uintptr_t)*cookie;
1963 get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zprop_source_t *src,
1971 boolean_t received = zfs_is_recvd_props_mode(zhp);
2022 if (!zhp->zfs_mntcheck &&
2024 libzfs_handle_t *hdl = zhp->zfs_hdl;
2027 if (libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0) {
2028 zhp->zfs_mntopts = zfs_strdup(hdl,
2030 if (zhp->zfs_mntopts == NULL)
2034 zhp->zfs_mntcheck = B_TRUE;
2037 if (zhp->zfs_mntopts == NULL)
2040 mnt.mnt_mntopts = zhp->zfs_mntopts;
2051 *val = getprop_uint64(zhp, prop, source);
2077 *val = getprop_uint64(zhp, prop, source);
2081 *source = zhp->zfs_name;
2086 *val = (zhp->zfs_mntopts != NULL);
2090 *val = zhp->zfs_dmustats.dds_num_clones;
2097 if (!zfs_prop_valid_for_type(prop, zhp->zfs_head_type) ||
2098 zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
2100 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2101 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_ZPLPROPS, &zc)) {
2105 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &zplprops) != 0 ||
2116 *val = zhp->zfs_dmustats.dds_inconsistent;
2123 *val = getprop_uint64(zhp, prop, source);
2137 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
2139 return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP,
2151 get_source(zfs_handle_t *zhp, zprop_source_t *srctype, char *source,
2164 if (strcmp(source, zhp->zfs_name) == 0) {
2175 zfs_prop_get_recvd(zfs_handle_t *zhp, const char *propname, char *propbuf,
2181 if (zhp->zfs_recvd_props == NULL)
2182 if (get_recvd_props_ioctl(zhp) != 0)
2189 if (!nvlist_exists(zhp->zfs_recvd_props, propname))
2191 zfs_set_recvd_props_mode(zhp, &cookie);
2192 err = zfs_prop_get(zhp, prop, propbuf, proplen,
2194 zfs_unset_recvd_props_mode(zhp, &cookie);
2198 if (nvlist_lookup_nvlist(zhp->zfs_recvd_props,
2210 get_clones_string(zfs_handle_t *zhp, char *propbuf, size_t proplen)
2215 value = zfs_get_clones_nvl(zhp);
2238 get_clones_cb(zfs_handle_t *zhp, void *arg)
2243 zfs_close(zhp);
2247 if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, gca->buf, sizeof (gca->buf),
2251 fnvlist_add_boolean(gca->value, zfs_get_name(zhp));
2256 (void) zfs_iter_children(zhp, get_clones_cb, gca);
2257 zfs_close(zhp);
2262 zfs_get_clones_nvl(zfs_handle_t *zhp)
2266 if (nvlist_lookup_nvlist(zhp->zfs_props,
2274 if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT)
2283 gca.numclones = zfs_prop_get_int(zhp, ZFS_PROP_NUMCLONES);
2285 gca.origin = zhp->zfs_name;
2293 (void) strlcpy(pool, zhp->zfs_name, sizeof (pool));
2295 root = zfs_open(zhp->zfs_hdl, pool,
2303 nvlist_add_nvlist(zhp->zfs_props,
2311 verify(0 == nvlist_lookup_nvlist(zhp->zfs_props,
2328 zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen,
2335 boolean_t received = zfs_is_recvd_props_mode(zhp);
2340 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
2356 val = getprop_uint64(zhp, prop, &source);
2380 str = getprop_string(zhp, prop, &source);
2397 relpath = zhp->zfs_name + strlen(source);
2402 if ((zpool_get_prop(zhp->zpool_hdl,
2438 str = getprop_string(zhp, prop, &source);
2445 if (get_clones_string(zhp, propbuf, proplen) != 0)
2454 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2482 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2503 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2511 switch (zhp->zfs_type) {
2537 if (get_numeric_property(zhp, ZFS_PROP_MOUNTED,
2552 (void) strlcpy(propbuf, zhp->zfs_name, proplen);
2561 getprop_string(zhp, prop, &source), proplen);
2599 if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2607 if (get_numeric_property(zhp, prop, src,
2618 str = getprop_string(zhp, prop, &source);
2625 if (get_numeric_property(zhp, prop, src,
2638 get_source(zhp, src, source, statbuf, statlen);
2649 zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop)
2654 (void) get_numeric_property(zhp, prop, NULL, &source, &val);
2660 zfs_prop_set_int(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t val)
2665 return (zfs_prop_set(zhp, zfs_prop_to_name(prop), buf));
2672 zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value,
2680 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) {
2681 return (zfs_error_fmt(zhp->zfs_hdl, EZFS_PROPTYPE,
2689 if (get_numeric_property(zhp, prop, src, &source, value) != 0)
2692 get_source(zhp, src, source, statbuf, statlen);
2869 zfs_prop_get_userquota_common(zfs_handle_t *zhp, const char *propname,
2875 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2878 zfs_prop_get_int(zhp, ZFS_PROP_ZONED),
2884 err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_USERSPACE_ONE, &zc);
2893 zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname,
2898 return (zfs_prop_get_userquota_common(zhp, propname, propvalue,
2903 zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname,
2910 err = zfs_prop_get_userquota_common(zhp, propname, &propvalue,
2928 zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname,
2935 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2941 /* snapname is the short name, append it to zhp's fsname */
2944 (void) strlcpy(zc.zc_value, zhp->zfs_name,
2953 err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SPACE_WRITTEN, &zc);
2962 zfs_prop_get_written(zfs_handle_t *zhp, const char *propname,
2968 err = zfs_prop_get_written_int(zhp, propname, &propvalue);
2985 zfs_get_name(const zfs_handle_t *zhp)
2987 return (zhp->zfs_name);
2994 zfs_get_pool_name(const zfs_handle_t *zhp)
2996 return (zhp->zpool_hdl->zpool_name);
3003 zfs_get_type(const zfs_handle_t *zhp)
3005 return (zhp->zfs_type);
3063 zfs_handle_t *zhp;
3090 while ((zhp = make_dataset_handle(hdl, parent)) == NULL) {
3108 is_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
3115 zfs_close(zhp);
3120 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
3124 zfs_close(zhp);
3128 zfs_close(zhp);
3140 zfs_handle_t *zhp;
3148 if ((zhp = make_dataset_handle(hdl, path)) != NULL) {
3149 int ds_type = zhp->zfs_type;
3151 zfs_close(zhp);
3412 zfs_destroy(zfs_handle_t *zhp, boolean_t defer)
3416 if (zhp->zfs_type == ZFS_TYPE_BOOKMARK) {
3418 fnvlist_add_boolean(nv, zhp->zfs_name);
3422 return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3424 zhp->zfs_name));
3429 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3431 if (ZFS_IS_VOLUME(zhp)) {
3438 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_DESTROY, &zc) != 0 &&
3440 return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3442 zhp->zfs_name));
3445 remove_mountpoint(zhp);
3456 zfs_check_snap_cb(zfs_handle_t *zhp, void *arg)
3463 "%s@%s", zhp->zfs_name, dd->snapname);
3468 rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd);
3469 zfs_close(zhp);
3474 * Destroys all snapshots with the given name in zhp & descendants.
3477 zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer)
3484 (void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd);
3487 ret = zfs_standard_error_fmt(zhp->zfs_hdl, ENOENT,
3489 zhp->zfs_name, snapname);
3491 ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer);
3545 zfs_clone(zfs_handle_t *zhp, const char *target, nvlist_t *props)
3550 libzfs_handle_t *hdl = zhp->zfs_hdl;
3553 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);
3572 if (ZFS_IS_VOLUME(zhp)) {
3578 zhp, zhp->zpool_hdl, errbuf)) == NULL)
3582 ret = lzc_clone(target, zhp->zfs_name, props);
3598 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3600 return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));
3603 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3605 return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET,
3609 return (zfs_standard_error(zhp->zfs_hdl, errno,
3621 zfs_promote(zfs_handle_t *zhp)
3623 libzfs_handle_t *hdl = zhp->zfs_hdl;
3630 "cannot promote '%s'"), zhp->zfs_name);
3632 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
3638 (void) strlcpy(parent, zhp->zfs_dmustats.dds_origin, sizeof (parent));
3645 (void) strlcpy(zc.zc_value, zhp->zfs_dmustats.dds_origin,
3647 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3674 zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
3680 if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) == 0) {
3682 "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
3686 rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
3688 zfs_close(zhp);
3782 zfs_handle_t *zhp;
3796 if ((zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM |
3803 (void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd);
3810 zfs_close(zhp);
3828 rollback_destroy_dependent(zfs_handle_t *zhp, void *data)
3834 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
3838 zfs_close(zhp);
3841 if (zfs_destroy(zhp, B_FALSE) != 0)
3844 changelist_remove(clp, zhp->zfs_name);
3848 zfs_close(zhp);
3853 rollback_destroy(zfs_handle_t *zhp, void *data)
3857 if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
3858 cbp->cb_error |= zfs_iter_dependents(zhp, B_FALSE,
3861 cbp->cb_error |= zfs_destroy(zhp, B_FALSE);
3864 zfs_close(zhp);
3876 zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, boolean_t force)
3884 assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM ||
3885 zhp->zfs_type == ZFS_TYPE_VOLUME);
3893 (void) zfs_iter_snapshots(zhp, rollback_destroy, &cb);
3894 (void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb);
3904 if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
3905 if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
3907 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
3909 (old_volsize == zfs_prop_get_int(zhp, resv_prop));
3919 err = lzc_rollback(zhp->zfs_name, NULL, 0);
3921 (void) zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3923 zhp->zfs_name);
3933 if ((zhp->zfs_type == ZFS_TYPE_VOLUME) &&
3934 (zhp = make_dataset_handle(zhp->zfs_hdl, zhp->zfs_name))) {
3936 new_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
3938 err = zfs_prop_set_int(zhp, resv_prop,
3941 zfs_close(zhp);
3950 zfs_rename(zfs_handle_t *zhp, const char *target, boolean_t recursive,
3960 libzfs_handle_t *hdl = zhp->zfs_hdl;
3964 if (strcmp(zhp->zfs_name, target) == 0)
3973 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
3980 (void) strlcpy(parent, zhp->zfs_name,
3994 if (strncmp(zhp->zfs_name, target, delim - target)
3995 != 0 || zhp->zfs_name[delim - target] != '@') {
4003 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4012 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4021 if (strncmp(zhp->zfs_name, target, delim - target) != 0 ||
4022 zhp->zfs_name[delim - target] != '/') {
4029 if (is_descendant(zhp->zfs_name, target)) {
4038 dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name);
4041 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
4048 parentname = zfs_strdup(zhp->zfs_hdl, zhp->zfs_name);
4055 zhrp = zfs_open(zhp->zfs_hdl, parentname, ZFS_TYPE_DATASET);
4060 } else if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT) {
4061 if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0,
4077 if (ZFS_IS_VOLUME(zhp))
4082 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4087 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_RENAME, &zc)) != 0) {
4101 (void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf);
4112 changelist_rename(cl, zfs_get_name(zhp), target);
4131 zfs_get_user_props(zfs_handle_t *zhp)
4133 return (zhp->zfs_user_props);
4137 zfs_get_recvd_props(zfs_handle_t *zhp)
4139 if (zhp->zfs_recvd_props == NULL)
4140 if (get_recvd_props_ioctl(zhp) != 0)
4142 return (zhp->zfs_recvd_props);
4159 zfs_expand_proplist(zfs_handle_t *zhp, zprop_list_t **plp, boolean_t received,
4162 libzfs_handle_t *hdl = zhp->zfs_hdl;
4173 userprops = zfs_get_user_props(zhp);
4226 if (zfs_prop_get(zhp, entry->pl_prop,
4231 if (received && zfs_prop_get_recvd(zhp,
4244 if (received && zfs_prop_get_recvd(zhp,
4276 zfs_prune_proplist(zfs_handle_t *zhp, uint8_t *props)
4284 zhp->zfs_props_table = props;
4286 curr = nvlist_next_nvpair(zhp->zfs_props, NULL);
4290 nvpair_t *next = nvlist_next_nvpair(zhp->zfs_props, curr);
4300 (void) nvlist_remove(zhp->zfs_props,
4388 zfs_userspace(zfs_handle_t *zhp, zfs_userquota_prop_t type,
4393 libzfs_handle_t *hdl = zhp->zfs_hdl;
4396 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4437 zfs_hold_one(zfs_handle_t *zhp, void *arg)
4444 "%s@%s", zhp->zfs_name, ha->snapname);
4450 rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha);
4451 zfs_close(zhp);
4456 zfs_hold(zfs_handle_t *zhp, const char *snapname, const char *tag,
4466 (void) zfs_hold_one(zfs_handle_dup(zhp), &ha);
4476 zhp->zfs_name, snapname);
4477 (void) zfs_standard_error(zhp->zfs_hdl, ret, errbuf);
4481 ret = zfs_hold_nvl(zhp, cleanup_fd, ha.nvl);
4488 zfs_hold_nvl(zfs_handle_t *zhp, int cleanup_fd, nvlist_t *holds)
4492 libzfs_handle_t *hdl = zhp->zfs_hdl;
4556 zfs_release_one(zfs_handle_t *zhp, void *arg)
4564 "%s@%s", zhp->zfs_name, ha->snapname);
4578 rv = zfs_iter_filesystems(zhp, zfs_release_one, ha);
4579 zfs_close(zhp);
4584 zfs_release(zfs_handle_t *zhp, const char *snapname, const char *tag,
4591 libzfs_handle_t *hdl = zhp->zfs_hdl;
4599 (void) zfs_release_one(zfs_handle_dup(zhp), &ha);
4607 zhp->zfs_name, snapname);
4665 zfs_get_fsacl(zfs_handle_t *zhp, nvlist_t **nvl)
4668 libzfs_handle_t *hdl = zhp->zfs_hdl;
4674 assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
4675 zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
4688 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4732 zfs_set_fsacl(zfs_handle_t *zhp, boolean_t un, nvlist_t *nvl)
4735 libzfs_handle_t *hdl = zhp->zfs_hdl;
4741 assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
4742 zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
4756 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4786 zfs_get_holds(zfs_handle_t *zhp, nvlist_t **nvl)
4791 err = lzc_get_holds(zhp->zfs_name, nvl);
4794 libzfs_handle_t *hdl = zhp->zfs_hdl;
4798 zhp->zfs_name);