zfs list: Allow more fields in ZFS_ITER_SIMPLE mode

If the fields to be listed and sorted by are constrained to those
populated by dsl_dataset_fast_stat(), then zfs list is much faster,
as it does not need to open each objset and reads its properties.

A previous optimization by Pawel Dawidek
(0cee24064a79f9c01fc4521543c37acea538405f) took advantage
of this to make listing snapshot names sorted only by name much faster.

However, it was limited to `-o name -s name`, this work extends this
optimization to work with:
  - name
  - guid
  - createtxg
  - numclones
  - inconsistent
  - redacted
  - origin
and could be further extended to any other properties supported by
dsl_dataset_fast_stat() or similar, that do not require extra locking
or reading from disk.

This was committed before (9a9e2e343dfa2af28bf7910de77ae73aa006de62),
but was reverted due to a regression when used with an older kernel.

If the kernel does not populate zc->zc_objset_stats, we now fallback
to getting the properties via the slower interface, to avoid problems
with newer userland and older kernels.

Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Allan Jude <allan@klarasystems.com>
Closes #14110

diff --git a/cmd/zfs/zfs_iter.c b/cmd/zfs/zfs_iter.c
index a0a80d481648fdb20b01fedf2188b8c1fbe2ba3a..0f8ddd93aad778a6293f2e5b676bbeb0f7aa9bb8 100644 (file)
--- a/cmd/zfs/zfs_iter.c
+++ b/cmd/zfs/zfs_iter.c
@@ -143,19 +143,20 @@ zfs_callback(zfs_handle_t *zhp, void *data)
                    (cb->cb_types &
                    (ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME))) &&
                    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
-                       (void) zfs_iter_filesystems(zhp, zfs_callback, data);
+                       (void) zfs_iter_filesystems(zhp, cb->cb_flags,
+                           zfs_callback, data);
                }
 
                if (((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT |
                    ZFS_TYPE_BOOKMARK)) == 0) && include_snaps) {
-                       (void) zfs_iter_snapshots(zhp,
-                           (cb->cb_flags & ZFS_ITER_SIMPLE) != 0,
+                       (void) zfs_iter_snapshots(zhp, cb->cb_flags,
                            zfs_callback, data, 0, 0);
                }
 
                if (((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT |
                    ZFS_TYPE_BOOKMARK)) == 0) && include_bmarks) {
-                       (void) zfs_iter_bookmarks(zhp, zfs_callback, data);
+                       (void) zfs_iter_bookmarks(zhp, cb->cb_flags,
+                           zfs_callback, data);
                }
 
                cb->cb_depth--;
@@ -211,18 +212,58 @@ zfs_free_sort_columns(zfs_sort_column_t *sc)
        }
 }
 
-int
-zfs_sort_only_by_name(const zfs_sort_column_t *sc)
+/*
+ * Return true if all of the properties to be sorted are populated by
+ * dsl_dataset_fast_stat(). Note that sc == NULL (no sort) means we
+ * don't need any extra properties, so returns true.
+ */
+boolean_t
+zfs_sort_only_by_fast(const zfs_sort_column_t *sc)
 {
-       return (sc != NULL && sc->sc_next == NULL &&
-           sc->sc_prop == ZFS_PROP_NAME);
+       while (sc != NULL) {
+               switch (sc->sc_prop) {
+               case ZFS_PROP_NAME:
+               case ZFS_PROP_GUID:
+               case ZFS_PROP_CREATETXG:
+               case ZFS_PROP_NUMCLONES:
+               case ZFS_PROP_INCONSISTENT:
+               case ZFS_PROP_REDACTED:
+               case ZFS_PROP_ORIGIN:
+                       break;
+               default:
+                       return (B_FALSE);
+               }
+               sc = sc->sc_next;
+       }
+
+       return (B_TRUE);
 }
 
-int
-zfs_sort_only_by_createtxg(const zfs_sort_column_t *sc)
+boolean_t
+zfs_list_only_by_fast(const zprop_list_t *p)
 {
-       return (sc != NULL && sc->sc_next == NULL &&
-           sc->sc_prop == ZFS_PROP_CREATETXG);
+       if (p == NULL) {
+               /* NULL means 'all' so we can't use simple mode */
+               return (B_FALSE);
+       }
+
+       while (p != NULL) {
+               switch (p->pl_prop) {
+               case ZFS_PROP_NAME:
+               case ZFS_PROP_GUID:
+               case ZFS_PROP_CREATETXG:
+               case ZFS_PROP_NUMCLONES:
+               case ZFS_PROP_INCONSISTENT:
+               case ZFS_PROP_REDACTED:
+               case ZFS_PROP_ORIGIN:
+                       break;
+               default:
+                       return (B_FALSE);
+               }
+               p = p->pl_next;
+       }
+
+       return (B_TRUE);
 }
 
 static int

diff --git a/cmd/zfs/zfs_iter.h b/cmd/zfs/zfs_iter.h
index effb22ded3fc0aa66fbd64821dd65873509d3b96..d742ec7b2ec43d1c8dd9df12cd02cc32a8b29128 100644 (file)
--- a/cmd/zfs/zfs_iter.h
+++ b/cmd/zfs/zfs_iter.h
@@ -40,20 +40,12 @@ typedef struct zfs_sort_column {
        boolean_t               sc_reverse;
 } zfs_sort_column_t;
 
-#define        ZFS_ITER_RECURSE           (1 << 0)
-#define        ZFS_ITER_ARGS_CAN_BE_PATHS (1 << 1)
-#define        ZFS_ITER_PROP_LISTSNAPS    (1 << 2)
-#define        ZFS_ITER_DEPTH_LIMIT       (1 << 3)
-#define        ZFS_ITER_RECVD_PROPS       (1 << 4)
-#define        ZFS_ITER_LITERAL_PROPS     (1 << 5)
-#define        ZFS_ITER_SIMPLE            (1 << 6)
-
 int zfs_for_each(int, char **, int options, zfs_type_t,
     zfs_sort_column_t *, zprop_list_t **, int, zfs_iter_f, void *);
 int zfs_add_sort_column(zfs_sort_column_t **, const char *, boolean_t);
 void zfs_free_sort_columns(zfs_sort_column_t *);
-int zfs_sort_only_by_name(const zfs_sort_column_t *);
-int zfs_sort_only_by_createtxg(const zfs_sort_column_t *);
+boolean_t zfs_sort_only_by_fast(const zfs_sort_column_t *);
+boolean_t zfs_list_only_by_fast(const zprop_list_t *);
 
 #ifdef __cplusplus
 }

diff --git a/cmd/zfs/zfs_main.c b/cmd/zfs/zfs_main.c
index 03640a4cdced0d2eadd867d724ef6670429d80bd..44440dc3dd4d942412a2629548909bfc70ae9827 100644 (file)
--- a/cmd/zfs/zfs_main.c
+++ b/cmd/zfs/zfs_main.c
@@ -1531,7 +1531,7 @@ destroy_print_snapshots(zfs_handle_t *fs_zhp, destroy_cbdata_t *cb)
        int err;
        assert(cb->cb_firstsnap == NULL);
        assert(cb->cb_prevsnap == NULL);
-       err = zfs_iter_snapshots_sorted(fs_zhp, destroy_print_cb, cb, 0, 0);
+       err = zfs_iter_snapshots_sorted(fs_zhp, 0, destroy_print_cb, cb, 0, 0);
        if (cb->cb_firstsnap != NULL) {
                uint64_t used = 0;
                if (err == 0) {
@@ -1557,7 +1557,7 @@ snapshot_to_nvl_cb(zfs_handle_t *zhp, void *arg)
        if (!cb->cb_doclones && !cb->cb_defer_destroy) {
                cb->cb_target = zhp;
                cb->cb_first = B_TRUE;
-               err = zfs_iter_dependents(zhp, B_TRUE,
+               err = zfs_iter_dependents(zhp, 0, B_TRUE,
                    destroy_check_dependent, cb);
        }
 
@@ -1575,7 +1575,8 @@ gather_snapshots(zfs_handle_t *zhp, void *arg)
        destroy_cbdata_t *cb = arg;
        int err = 0;
 
-       err = zfs_iter_snapspec(zhp, cb->cb_snapspec, snapshot_to_nvl_cb, cb);
+       err = zfs_iter_snapspec(zhp, 0, cb->cb_snapspec,
+           snapshot_to_nvl_cb, cb);
        if (err == ENOENT)
                err = 0;
        if (err != 0)
@@ -1588,7 +1589,7 @@ gather_snapshots(zfs_handle_t *zhp, void *arg)
        }
 
        if (cb->cb_recurse)
-               err = zfs_iter_filesystems(zhp, gather_snapshots, cb);
+               err = zfs_iter_filesystems(zhp, 0, gather_snapshots, cb);
 
 out:
        zfs_close(zhp);
@@ -1613,7 +1614,7 @@ destroy_clones(destroy_cbdata_t *cb)
                         * false while destroying the clones.
                         */
                        cb->cb_defer_destroy = B_FALSE;
-                       err = zfs_iter_dependents(zhp, B_FALSE,
+                       err = zfs_iter_dependents(zhp, 0, B_FALSE,
                            destroy_callback, cb);
                        cb->cb_defer_destroy = defer;
                        zfs_close(zhp);
@@ -1824,7 +1825,7 @@ zfs_do_destroy(int argc, char **argv)
                 */
                cb.cb_first = B_TRUE;
                if (!cb.cb_doclones &&
-                   zfs_iter_dependents(zhp, B_TRUE, destroy_check_dependent,
+                   zfs_iter_dependents(zhp, 0, B_TRUE, destroy_check_dependent,
                    &cb) != 0) {
                        rv = 1;
                        goto out;
@@ -1835,7 +1836,7 @@ zfs_do_destroy(int argc, char **argv)
                        goto out;
                }
                cb.cb_batchedsnaps = fnvlist_alloc();
-               if (zfs_iter_dependents(zhp, B_FALSE, destroy_callback,
+               if (zfs_iter_dependents(zhp, 0, B_FALSE, destroy_callback,
                    &cb) != 0) {
                        rv = 1;
                        goto out;
@@ -3659,16 +3660,6 @@ found3:;
        argc -= optind;
        argv += optind;
 
-       /*
-        * If we are only going to list snapshot names and sort by name or
-        * by createtxg, then we can use faster version.
-        */
-       if (strcmp(fields, "name") == 0 &&
-           (zfs_sort_only_by_name(sortcol) ||
-           zfs_sort_only_by_createtxg(sortcol))) {
-               flags |= ZFS_ITER_SIMPLE;
-       }
-
        /*
         * If "-o space" and no types were specified, don't display snapshots.
         */
@@ -3696,6 +3687,15 @@ found3:;
 
        cb.cb_first = B_TRUE;
 
+       /*
+        * If we are only going to list and sort by properties that are "fast"
+        * then we can use "simple" mode and avoid populating the properties
+        * nvlist.
+        */
+       if (zfs_list_only_by_fast(cb.cb_proplist) &&
+           zfs_sort_only_by_fast(sortcol))
+               flags |= ZFS_ITER_SIMPLE;
+
        ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
            limit, list_callback, &cb);
 
@@ -4006,7 +4006,7 @@ rollback_check(zfs_handle_t *zhp, void *data)
                }
 
                if (cbp->cb_recurse) {
-                       if (zfs_iter_dependents(zhp, B_TRUE,
+                       if (zfs_iter_dependents(zhp, 0, B_TRUE,
                            rollback_check_dependent, cbp) != 0) {
                                zfs_close(zhp);
                                return (-1);
@@ -4105,10 +4105,10 @@ zfs_do_rollback(int argc, char **argv)
        if (cb.cb_create > 0)
                min_txg = cb.cb_create;
 
-       if ((ret = zfs_iter_snapshots(zhp, B_FALSE, rollback_check, &cb,
+       if ((ret = zfs_iter_snapshots(zhp, 0, rollback_check, &cb,
            min_txg, 0)) != 0)
                goto out;
-       if ((ret = zfs_iter_bookmarks(zhp, rollback_check, &cb)) != 0)
+       if ((ret = zfs_iter_bookmarks(zhp, 0, rollback_check, &cb)) != 0)
                goto out;
 
        if ((ret = cb.cb_error) != 0)
@@ -4250,7 +4250,7 @@ zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
        free(name);
 
        if (sd->sd_recursive)
-               rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
+               rv = zfs_iter_filesystems(zhp, 0, zfs_snapshot_cb, sd);
        zfs_close(zhp);
        return (rv);
 }
@@ -6310,7 +6310,7 @@ zfs_do_allow_unallow_impl(int argc, char **argv, boolean_t un)
 
                if (un && opts.recursive) {
                        struct deleg_perms data = { un, update_perm_nvl };
-                       if (zfs_iter_filesystems(zhp, set_deleg_perms,
+                       if (zfs_iter_filesystems(zhp, 0, set_deleg_perms,
                            &data) != 0)
                                goto cleanup0;
                }
@@ -6688,7 +6688,7 @@ get_one_dataset(zfs_handle_t *zhp, void *data)
        /*
         * Iterate over any nested datasets.
         */
-       if (zfs_iter_filesystems(zhp, get_one_dataset, data) != 0) {
+       if (zfs_iter_filesystems(zhp, 0, get_one_dataset, data) != 0) {
                zfs_close(zhp);
                return (1);
        }

diff --git a/cmd/zpool/zpool_main.c b/cmd/zpool/zpool_main.c
index 0872671f428fa363a7464fa9922a35ccfc747dda..af76d20f2d52a3c4be7e9171ad3a5958182c1d4f 100644 (file)
--- a/cmd/zpool/zpool_main.c
+++ b/cmd/zpool/zpool_main.c
@@ -8808,7 +8808,7 @@ check_unsupp_fs(zfs_handle_t *zhp, void *unsupp_fs)
                (*count)++;
        }
 
-       zfs_iter_filesystems(zhp, check_unsupp_fs, unsupp_fs);
+       zfs_iter_filesystems(zhp, 0, check_unsupp_fs, unsupp_fs);
 
        zfs_close(zhp);
 

diff --git a/contrib/pam_zfs_key/pam_zfs_key.c b/contrib/pam_zfs_key/pam_zfs_key.c
index e3fa9e9b2553b502c727027ae5f44e3db6145c32..99cdb8d7733f2773424f90fd01f55743cdbc80b8 100644 (file)
--- a/contrib/pam_zfs_key/pam_zfs_key.c
+++ b/contrib/pam_zfs_key/pam_zfs_key.c
@@ -535,7 +535,7 @@ zfs_key_config_get_dataset(zfs_key_config_t *config)
                        return (NULL);
                }
 
-               (void) zfs_iter_filesystems(zhp, find_dsname_by_prop_value,
+               (void) zfs_iter_filesystems(zhp, 0, find_dsname_by_prop_value,
                    config);
                zfs_close(zhp);
                char *dsname = config->dsname;

diff --git a/include/libzfs.h b/include/libzfs.h
index 2806d1f7cff5ead6c6ca26f99b9f0b639e36ff5d..e563749226ec5f4e2d3ad025c619491480102b63 100644 (file)
--- a/include/libzfs.h
+++ b/include/libzfs.h
@@ -646,19 +646,27 @@ _LIBZFS_H void zprop_print_one_property(const char *, zprop_get_cbdata_t *,
 /*
  * Iterator functions.
  */
+#define        ZFS_ITER_RECURSE                (1 << 0)
+#define        ZFS_ITER_ARGS_CAN_BE_PATHS      (1 << 1)
+#define        ZFS_ITER_PROP_LISTSNAPS         (1 << 2)
+#define        ZFS_ITER_DEPTH_LIMIT            (1 << 3)
+#define        ZFS_ITER_RECVD_PROPS            (1 << 4)
+#define        ZFS_ITER_LITERAL_PROPS          (1 << 5)
+#define        ZFS_ITER_SIMPLE                 (1 << 6)
+
 typedef int (*zfs_iter_f)(zfs_handle_t *, void *);
 _LIBZFS_H int zfs_iter_root(libzfs_handle_t *, zfs_iter_f, void *);
-_LIBZFS_H int zfs_iter_children(zfs_handle_t *, zfs_iter_f, void *);
-_LIBZFS_H int zfs_iter_dependents(zfs_handle_t *, boolean_t, zfs_iter_f,
+_LIBZFS_H int zfs_iter_children(zfs_handle_t *, int, zfs_iter_f, void *);
+_LIBZFS_H int zfs_iter_dependents(zfs_handle_t *, int, boolean_t, zfs_iter_f,
     void *);
-_LIBZFS_H int zfs_iter_filesystems(zfs_handle_t *, zfs_iter_f, void *);
-_LIBZFS_H int zfs_iter_snapshots(zfs_handle_t *, boolean_t, zfs_iter_f, void *,
+_LIBZFS_H int zfs_iter_filesystems(zfs_handle_t *, int, zfs_iter_f, void *);
+_LIBZFS_H int zfs_iter_snapshots(zfs_handle_t *, int, zfs_iter_f, void *,
     uint64_t, uint64_t);
-_LIBZFS_H int zfs_iter_snapshots_sorted(zfs_handle_t *, zfs_iter_f, void *,
+_LIBZFS_H int zfs_iter_snapshots_sorted(zfs_handle_t *, int, zfs_iter_f, void *,
     uint64_t, uint64_t);
-_LIBZFS_H int zfs_iter_snapspec(zfs_handle_t *, const char *, zfs_iter_f,
+_LIBZFS_H int zfs_iter_snapspec(zfs_handle_t *, int, const char *, zfs_iter_f,
     void *);
-_LIBZFS_H int zfs_iter_bookmarks(zfs_handle_t *, zfs_iter_f, void *);
+_LIBZFS_H int zfs_iter_bookmarks(zfs_handle_t *, int, zfs_iter_f, void *);
 _LIBZFS_H int zfs_iter_mounted(zfs_handle_t *, zfs_iter_f, void *);
 
 typedef struct get_all_cb {

diff --git a/lib/libzfs/libzfs.abi b/lib/libzfs/libzfs.abi
index 98873784e7dc96db1ecdd332f4812f9e805c5178..e5115e9731f3061098c6e43d97365af3ed677411 100644 (file)
--- a/lib/libzfs/libzfs.abi
+++ b/lib/libzfs/libzfs.abi
@@ -2925,13 +2925,14 @@
   <abi-instr address-size='64' path='lib/libzfs/libzfs_iter.c' language='LANG_C99'>
     <function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_filesystems'>
       <parameter type-id='9200a744' name='zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots'>
       <parameter type-id='9200a744' name='zhp'/>
-      <parameter type-id='c19b74c3' name='simple'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <parameter type-id='9c313c2d' name='min_txg'/>
@@ -2940,12 +2941,14 @@
     </function-decl>
     <function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks'>
       <parameter type-id='9200a744' name='zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_iter_snapshots_sorted' mangled-name='zfs_iter_snapshots_sorted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots_sorted'>
       <parameter type-id='9200a744' name='zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='d8e49ab9' name='callback'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <parameter type-id='9c313c2d' name='min_txg'/>
@@ -2954,6 +2957,7 @@
     </function-decl>
     <function-decl name='zfs_iter_snapspec' mangled-name='zfs_iter_snapspec' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapspec'>
       <parameter type-id='9200a744' name='fs_zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='80f4b756' name='spec_orig'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='arg'/>
@@ -2961,12 +2965,14 @@
     </function-decl>
     <function-decl name='zfs_iter_children' mangled-name='zfs_iter_children' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_children'>
       <parameter type-id='9200a744' name='zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_dependents'>
       <parameter type-id='9200a744' name='zhp'/>
+      <parameter type-id='95e97e5e' name='flags'/>
       <parameter type-id='c19b74c3' name='allowrecursion'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>

diff --git a/lib/libzfs/libzfs_changelist.c b/lib/libzfs/libzfs_changelist.c
index e5e735d38e00ffb354060eb2c2504512a367da87..d7ea60822419b9b1cc489aa80b8e071f29a00fce 100644 (file)
--- a/lib/libzfs/libzfs_changelist.c
+++ b/lib/libzfs/libzfs_changelist.c
@@ -552,7 +552,7 @@ change_one(zfs_handle_t *zhp, void *data)
                }
 
                if (!clp->cl_alldependents)
-                       ret = zfs_iter_children(zhp, change_one, data);
+                       ret = zfs_iter_children(zhp, 0, change_one, data);
 
                /*
                 * If we added the handle to the changelist, we will re-use it
@@ -721,11 +721,11 @@ changelist_gather(zfs_handle_t *zhp, zfs_prop_t prop, int gather_flags,
                        return (NULL);
                }
        } else if (clp->cl_alldependents) {
-               if (zfs_iter_dependents(zhp, B_TRUE, change_one, clp) != 0) {
+               if (zfs_iter_dependents(zhp, 0, B_TRUE, change_one, clp) != 0) {
                        changelist_free(clp);
                        return (NULL);
                }
-       } else if (zfs_iter_children(zhp, change_one, clp) != 0) {
+       } else if (zfs_iter_children(zhp, 0, change_one, clp) != 0) {
                changelist_free(clp);
                return (NULL);
        }

diff --git a/lib/libzfs/libzfs_crypto.c b/lib/libzfs/libzfs_crypto.c
index c241aeaa4da01d52555df2e1e14f66053e23609a..3ef88370108204491a72e3477be56da94e7edb2c 100644 (file)
--- a/lib/libzfs/libzfs_crypto.c
+++ b/lib/libzfs/libzfs_crypto.c
@@ -1226,7 +1226,7 @@ load_keys_cb(zfs_handle_t *zhp, void *arg)
                cb->cb_numfailed++;
 
 out:
-       (void) zfs_iter_filesystems(zhp, load_keys_cb, cb);
+       (void) zfs_iter_filesystems(zhp, 0, load_keys_cb, cb);
        zfs_close(zhp);
 
        /* always return 0, since this function is best effort */

diff --git a/lib/libzfs/libzfs_dataset.c b/lib/libzfs/libzfs_dataset.c
index fd9fbd658a57902537ef1f925c5d755334857499..9ecb1ac5c6fb351d6ffedbbb0a4602b679fc85d9 100644 (file)
--- a/lib/libzfs/libzfs_dataset.c
+++ b/lib/libzfs/libzfs_dataset.c
@@ -527,7 +527,30 @@ make_dataset_simple_handle_zc(zfs_handle_t *pzhp, zfs_cmd_t *zc)
        zhp->zfs_head_type = pzhp->zfs_type;
        zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
        zhp->zpool_hdl = zpool_handle(zhp);
-       zhp->zfs_dmustats = zc->zc_objset_stats;
+
+       if (zc->zc_objset_stats.dds_creation_txg != 0) {
+               /* structure assignment */
+               zhp->zfs_dmustats = zc->zc_objset_stats;
+       } else {
+               if (get_stats_ioctl(zhp, zc) == -1) {
+                       zcmd_free_nvlists(zc);
+                       free(zhp);
+                       return (NULL);
+               }
+               if (make_dataset_handle_common(zhp, zc) == -1) {
+                       zcmd_free_nvlists(zc);
+                       free(zhp);
+                       return (NULL);
+               }
+       }
+
+       if (zhp->zfs_dmustats.dds_is_snapshot ||
+           strchr(zc->zc_name, '@') != NULL)
+               zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
+       else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
+               zhp->zfs_type = ZFS_TYPE_VOLUME;
+       else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
+               zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
 
        return (zhp);
 }
@@ -734,7 +757,7 @@ zfs_open(libzfs_handle_t *hdl, const char *path, int types)
                 * Iterate bookmarks to find the right one.
                 */
                errno = 0;
-               if ((zfs_iter_bookmarks(pzhp, zfs_open_bookmarks_cb,
+               if ((zfs_iter_bookmarks(pzhp, 0, zfs_open_bookmarks_cb,
                    &cb_data) == 0) && (cb_data.zhp == NULL)) {
                        (void) zfs_error(hdl, EZFS_NOENT, errbuf);
                        zfs_close(pzhp);
@@ -2086,7 +2109,8 @@ getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
 static boolean_t
 zfs_is_recvd_props_mode(zfs_handle_t *zhp)
 {
-       return (zhp->zfs_props == zhp->zfs_recvd_props);
+       return (zhp->zfs_props != NULL &&
+           zhp->zfs_props == zhp->zfs_recvd_props);
 }
 
 static void
@@ -2288,19 +2312,28 @@ get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zprop_source_t *src,
                *val = zhp->zfs_dmustats.dds_redacted;
                break;
 
+       case ZFS_PROP_GUID:
+               if (zhp->zfs_dmustats.dds_guid != 0)
+                       *val = zhp->zfs_dmustats.dds_guid;
+               else
+                       *val = getprop_uint64(zhp, prop, source);
+               break;
+
        case ZFS_PROP_CREATETXG:
                /*
                 * We can directly read createtxg property from zfs
                 * handle for Filesystem, Snapshot and ZVOL types.
                 */
-               if ((zhp->zfs_type == ZFS_TYPE_FILESYSTEM) ||
+               if (((zhp->zfs_type == ZFS_TYPE_FILESYSTEM) ||
                    (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) ||
-                   (zhp->zfs_type == ZFS_TYPE_VOLUME)) {
+                   (zhp->zfs_type == ZFS_TYPE_VOLUME)) &&
+                   (zhp->zfs_dmustats.dds_creation_txg != 0)) {
                        *val = zhp->zfs_dmustats.dds_creation_txg;
                        break;
+               } else {
+                       *val = getprop_uint64(zhp, prop, source);
                }
                zfs_fallthrough;
-
        default:
                switch (zfs_prop_get_type(prop)) {
                case PROP_TYPE_NUMBER:
@@ -2443,7 +2476,7 @@ get_clones_cb(zfs_handle_t *zhp, void *arg)
        }
 
 out:
-       (void) zfs_iter_children(zhp, get_clones_cb, gca);
+       (void) zfs_iter_children(zhp, 0, get_clones_cb, gca);
        zfs_close(zhp);
        return (0);
 }
@@ -2728,7 +2761,13 @@ zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen,
                break;
 
        case ZFS_PROP_ORIGIN:
-               str = getprop_string(zhp, prop, &source);
+               if (*zhp->zfs_dmustats.dds_origin != '\0') {
+                       str = (char *)&zhp->zfs_dmustats.dds_origin;
+               } else {
+                       str = getprop_string(zhp, prop, &source);
+               }
+               if (str == NULL || *str == '\0')
+                       str = zfs_prop_default_string(prop);
                if (str == NULL)
                        return (-1);
                (void) strlcpy(propbuf, str, proplen);
@@ -3886,7 +3925,7 @@ zfs_check_snap_cb(zfs_handle_t *zhp, void *arg)
        if (lzc_exists(name))
                fnvlist_add_boolean(dd->nvl, name);
 
-       rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd);
+       rv = zfs_iter_filesystems(zhp, 0, zfs_check_snap_cb, dd);
        zfs_close(zhp);
        return (rv);
 }
@@ -4124,7 +4163,7 @@ zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
 
                fnvlist_add_boolean(sd->sd_nvl, name);
 
-               rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
+               rv = zfs_iter_filesystems(zhp, 0, zfs_snapshot_cb, sd);
        }
        zfs_close(zhp);
 
@@ -4301,7 +4340,7 @@ rollback_destroy(zfs_handle_t *zhp, void *data)
        rollback_data_t *cbp = data;
 
        if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
-               cbp->cb_error |= zfs_iter_dependents(zhp, B_FALSE,
+               cbp->cb_error |= zfs_iter_dependents(zhp, 0, B_FALSE,
                    rollback_destroy_dependent, cbp);
 
                cbp->cb_error |= zfs_destroy(zhp, B_FALSE);
@@ -4341,10 +4380,10 @@ zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, boolean_t force)
        if (cb.cb_create > 0)
                min_txg = cb.cb_create;
 
-       (void) zfs_iter_snapshots(zhp, B_FALSE, rollback_destroy, &cb,
+       (void) zfs_iter_snapshots(zhp, 0, rollback_destroy, &cb,
            min_txg, 0);
 
-       (void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb);
+       (void) zfs_iter_bookmarks(zhp, 0, rollback_destroy, &cb);
 
        if (cb.cb_error)
                return (-1);
@@ -4925,7 +4964,7 @@ zfs_hold_one(zfs_handle_t *zhp, void *arg)
                fnvlist_add_string(ha->nvl, name, ha->tag);
 
        if (ha->recursive)
-               rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha);
+               rv = zfs_iter_filesystems(zhp, 0, zfs_hold_one, ha);
        zfs_close(zhp);
        return (rv);
 }
@@ -5056,7 +5095,7 @@ zfs_release_one(zfs_handle_t *zhp, void *arg)
        }
 
        if (ha->recursive)
-               rv = zfs_iter_filesystems(zhp, zfs_release_one, ha);
+               rv = zfs_iter_filesystems(zhp, 0, zfs_release_one, ha);
        zfs_close(zhp);
        return (rv);
 }

diff --git a/lib/libzfs/libzfs_iter.c b/lib/libzfs/libzfs_iter.c
index a716521ab17d1997bfe7a81ff5e30088c93fb53a..55cb7a8b5035b6f154590b27b6b68d94887a8083 100644 (file)
--- a/lib/libzfs/libzfs_iter.c
+++ b/lib/libzfs/libzfs_iter.c
@@ -39,7 +39,8 @@
 #include "libzfs_impl.h"
 
 static int
-zfs_iter_clones(zfs_handle_t *zhp, zfs_iter_f func, void *data)
+zfs_iter_clones(zfs_handle_t *zhp, int flags __maybe_unused, zfs_iter_f func,
+    void *data)
 {
        nvlist_t *nvl = zfs_get_clones_nvl(zhp);
        nvpair_t *pair;
@@ -69,6 +70,7 @@ zfs_do_list_ioctl(zfs_handle_t *zhp, int arg, zfs_cmd_t *zc)
        orig_cookie = zc->zc_cookie;
 top:
        (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
+       zc->zc_objset_stats.dds_creation_txg = 0;
        rc = zfs_ioctl(zhp->zfs_hdl, arg, zc);
 
        if (rc == -1) {
@@ -101,7 +103,7 @@ top:
  * Iterate over all child filesystems
  */
 int
-zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
+zfs_iter_filesystems(zfs_handle_t *zhp, int flags, zfs_iter_f func, void *data)
 {
        zfs_cmd_t zc = {"\0"};
        zfs_handle_t *nzhp;
@@ -112,16 +114,21 @@ zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
 
        zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0);
 
+       if ((flags & ZFS_ITER_SIMPLE) == ZFS_ITER_SIMPLE)
+               zc.zc_simple = B_TRUE;
+
        while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
            &zc)) == 0) {
+               if (zc.zc_simple)
+                       nzhp = make_dataset_simple_handle_zc(zhp, &zc);
+               else
+                       nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
                /*
                 * Silently ignore errors, as the only plausible explanation is
                 * that the pool has since been removed.
                 */
-               if ((nzhp = make_dataset_handle_zc(zhp->zfs_hdl,
-                   &zc)) == NULL) {
+               if (nzhp == NULL)
                        continue;
-               }
 
                if ((ret = func(nzhp, data)) != 0) {
                        zcmd_free_nvlists(&zc);
@@ -136,7 +143,7 @@ zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
  * Iterate over all snapshots
  */
 int
-zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
+zfs_iter_snapshots(zfs_handle_t *zhp, int flags, zfs_iter_f func,
     void *data, uint64_t min_txg, uint64_t max_txg)
 {
        zfs_cmd_t zc = {"\0"};
@@ -148,7 +155,7 @@ zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
            zhp->zfs_type == ZFS_TYPE_BOOKMARK)
                return (0);
 
-       zc.zc_simple = simple;
+       zc.zc_simple = (flags & ZFS_ITER_SIMPLE) != 0;
 
        zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0);
 
@@ -168,7 +175,7 @@ zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
        while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
            &zc)) == 0) {
 
-               if (simple)
+               if (zc.zc_simple)
                        nzhp = make_dataset_simple_handle_zc(zhp, &zc);
                else
                        nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
@@ -190,7 +197,8 @@ zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
  * Iterate over all bookmarks
  */
 int
-zfs_iter_bookmarks(zfs_handle_t *zhp, zfs_iter_f func, void *data)
+zfs_iter_bookmarks(zfs_handle_t *zhp, int flags __maybe_unused,
+    zfs_iter_f func, void *data)
 {
        zfs_handle_t *nzhp;
        nvlist_t *props = NULL;
@@ -297,8 +305,8 @@ zfs_snapshot_compare(const void *larg, const void *rarg)
 }
 
 int
-zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback, void *data,
-    uint64_t min_txg, uint64_t max_txg)
+zfs_iter_snapshots_sorted(zfs_handle_t *zhp, int flags, zfs_iter_f callback,
+    void *data, uint64_t min_txg, uint64_t max_txg)
 {
        int ret = 0;
        zfs_node_t *node;
@@ -308,7 +316,7 @@ zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback, void *data,
        avl_create(&avl, zfs_snapshot_compare,
            sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));
 
-       ret = zfs_iter_snapshots(zhp, B_FALSE, zfs_sort_snaps, &avl, min_txg,
+       ret = zfs_iter_snapshots(zhp, flags, zfs_sort_snaps, &avl, min_txg,
            max_txg);
 
        for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
@@ -371,7 +379,7 @@ snapspec_cb(zfs_handle_t *zhp, void *arg)
  * return ENOENT at the end.
  */
 int
-zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
+zfs_iter_snapspec(zfs_handle_t *fs_zhp, int flags, const char *spec_orig,
     zfs_iter_f func, void *arg)
 {
        char *buf, *comma_separated, *cp;
@@ -411,7 +419,7 @@ zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
                                }
                        }
 
-                       err = zfs_iter_snapshots_sorted(fs_zhp,
+                       err = zfs_iter_snapshots_sorted(fs_zhp, flags,
                            snapspec_cb, &ssa, 0, 0);
                        if (ret == 0)
                                ret = err;
@@ -448,14 +456,14 @@ zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
  * and as close as possible.
  */
 int
-zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
+zfs_iter_children(zfs_handle_t *zhp, int flags, zfs_iter_f func, void *data)
 {
        int ret;
 
-       if ((ret = zfs_iter_snapshots(zhp, B_FALSE, func, data, 0, 0)) != 0)
+       if ((ret = zfs_iter_snapshots(zhp, flags, func, data, 0, 0)) != 0)
                return (ret);
 
-       return (zfs_iter_filesystems(zhp, func, data));
+       return (zfs_iter_filesystems(zhp, flags, func, data));
 }
 
 
@@ -466,6 +474,7 @@ typedef struct iter_stack_frame {
 
 typedef struct iter_dependents_arg {
        boolean_t first;
+       int flags;
        boolean_t allowrecursion;
        iter_stack_frame_t *stack;
        zfs_iter_f func;
@@ -481,7 +490,7 @@ iter_dependents_cb(zfs_handle_t *zhp, void *arg)
        ida->first = B_FALSE;
 
        if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
-               err = zfs_iter_clones(zhp, iter_dependents_cb, ida);
+               err = zfs_iter_clones(zhp, ida->flags, iter_dependents_cb, ida);
        } else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
                iter_stack_frame_t isf;
                iter_stack_frame_t *f;
@@ -515,9 +524,10 @@ iter_dependents_cb(zfs_handle_t *zhp, void *arg)
                isf.zhp = zhp;
                isf.next = ida->stack;
                ida->stack = &isf;
-               err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
+               err = zfs_iter_filesystems(zhp, ida->flags,
+                   iter_dependents_cb, ida);
                if (err == 0)
-                       err = zfs_iter_snapshots(zhp, B_FALSE,
+                       err = zfs_iter_snapshots(zhp, ida->flags,
                            iter_dependents_cb, ida, 0, 0);
                ida->stack = isf.next;
        }
@@ -531,10 +541,11 @@ iter_dependents_cb(zfs_handle_t *zhp, void *arg)
 }
 
 int
-zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
+zfs_iter_dependents(zfs_handle_t *zhp, int flags, boolean_t allowrecursion,
     zfs_iter_f func, void *data)
 {
        iter_dependents_arg_t ida;
+       ida.flags = flags;
        ida.allowrecursion = allowrecursion;
        ida.stack = NULL;
        ida.func = func;

diff --git a/lib/libzfs/libzfs_mount.c b/lib/libzfs/libzfs_mount.c
index 44f7d698c82c1b92a7d5e3b0c671f1b020168e9a..57737bc6c01ad76f21bbea0da09941e9672a7ba3 100644 (file)
--- a/lib/libzfs/libzfs_mount.c
+++ b/lib/libzfs/libzfs_mount.c
@@ -940,7 +940,7 @@ zfs_iter_cb(zfs_handle_t *zhp, void *data)
        }
 
        libzfs_add_handle(cbp, zhp);
-       if (zfs_iter_filesystems(zhp, zfs_iter_cb, cbp) != 0) {
+       if (zfs_iter_filesystems(zhp, 0, zfs_iter_cb, cbp) != 0) {
                zfs_close(zhp);
                return (-1);
        }
@@ -1289,7 +1289,7 @@ zpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags)
         * over all child filesystems.
         */
        libzfs_add_handle(&cb, zfsp);
-       if (zfs_iter_filesystems(zfsp, zfs_iter_cb, &cb) != 0)
+       if (zfs_iter_filesystems(zfsp, 0, zfs_iter_cb, &cb) != 0)
                goto out;
 
        /*

diff --git a/lib/libzfs/libzfs_sendrecv.c b/lib/libzfs/libzfs_sendrecv.c
index 089d46b130bedfe2ab350eb9618553180487fec5..ac1834733cee5893b9256b904fb9b8f7002c3812 100644 (file)
--- a/lib/libzfs/libzfs_sendrecv.c
+++ b/lib/libzfs/libzfs_sendrecv.c
@@ -616,10 +616,10 @@ send_iterate_fs(zfs_handle_t *zhp, void *arg)
                        min_txg = fromsnap_txg;
                if (!sd->replicate && tosnap_txg != 0)
                        max_txg = tosnap_txg;
-               (void) zfs_iter_snapshots_sorted(zhp, send_iterate_snap, sd,
+               (void) zfs_iter_snapshots_sorted(zhp, 0, send_iterate_snap, sd,
                    min_txg, max_txg);
        } else {
-               char snapname[MAXPATHLEN];
+               char snapname[MAXPATHLEN] = { 0 };
                zfs_handle_t *snap;
 
                (void) snprintf(snapname, sizeof (snapname), "%s@%s",
@@ -659,7 +659,7 @@ send_iterate_fs(zfs_handle_t *zhp, void *arg)
 
        /* Iterate over children. */
        if (sd->recursive)
-               rv = zfs_iter_filesystems(zhp, send_iterate_fs, sd);
+               rv = zfs_iter_filesystems(zhp, 0, send_iterate_fs, sd);
 
 out:
        /* Restore saved fields. */
@@ -1274,7 +1274,7 @@ dump_filesystem(zfs_handle_t *zhp, send_dump_data_t *sdd)
                                    zhp->zfs_name, sdd->tosnap);
                        }
                }
-               rv = zfs_iter_snapshots_sorted(zhp, dump_snapshot, sdd,
+               rv = zfs_iter_snapshots_sorted(zhp, 0, dump_snapshot, sdd,
                    min_txg, max_txg);
        } else {
                char snapname[MAXPATHLEN] = { 0 };
@@ -3125,9 +3125,9 @@ guid_to_name_cb(zfs_handle_t *zhp, void *arg)
                return (EEXIST);
        }
 
-       err = zfs_iter_children(zhp, guid_to_name_cb, gtnd);
+       err = zfs_iter_children(zhp, 0, guid_to_name_cb, gtnd);
        if (err != EEXIST && gtnd->bookmark_ok)
-               err = zfs_iter_bookmarks(zhp, guid_to_name_cb, gtnd);
+               err = zfs_iter_bookmarks(zhp, 0, guid_to_name_cb, gtnd);
        zfs_close(zhp);
        return (err);
 }
@@ -3181,9 +3181,10 @@ guid_to_name_redact_snaps(libzfs_handle_t *hdl, const char *parent,
                        continue;
                int err = guid_to_name_cb(zfs_handle_dup(zhp), &gtnd);
                if (err != EEXIST)
-                       err = zfs_iter_children(zhp, guid_to_name_cb, &gtnd);
+                       err = zfs_iter_children(zhp, 0, guid_to_name_cb, &gtnd);
                if (err != EEXIST && bookmark_ok)
-                       err = zfs_iter_bookmarks(zhp, guid_to_name_cb, &gtnd);
+                       err = zfs_iter_bookmarks(zhp, 0, guid_to_name_cb,
+                           &gtnd);
                zfs_close(zhp);
                if (err == EEXIST)
                        return (0);

diff --git a/module/zfs/zfs_ioctl.c b/module/zfs/zfs_ioctl.c
index a5168b937588d3ab6f07a97e372e4be8d7829bac..a55d9f88ab7d62ac53b2aba3b8c0ace22794e52f 100644 (file)
--- a/module/zfs/zfs_ioctl.c
+++ b/module/zfs/zfs_ioctl.c
@@ -2039,7 +2039,7 @@ zfs_ioc_objset_stats_impl(zfs_cmd_t *zc, objset_t *os)
 
        dmu_objset_fast_stat(os, &zc->zc_objset_stats);
 
-       if (zc->zc_nvlist_dst != 0 &&
+       if (!zc->zc_simple && zc->zc_nvlist_dst != 0 &&
            (error = dsl_prop_get_all(os, &nv)) == 0) {
                dmu_objset_stats(os, nv);
                /*
@@ -2326,8 +2326,7 @@ zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
                }
 
                if (zc->zc_simple) {
-                       zc->zc_objset_stats.dds_creation_txg =
-                           dsl_get_creationtxg(ds);
+                       dsl_dataset_fast_stat(ds, &zc->zc_objset_stats);
                        dsl_dataset_rele(ds, FTAG);
                        break;
                }