ddt: split internal DDT API into separate header

Just to make it easier to know which bits to pay attention to.

Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Rob Norris <rob.norris@klarasystems.com>
Sponsored-by: Klara, Inc.
Sponsored-by: iXsystems, Inc.
Closes #15887

diff --git a/cmd/zdb/zdb.c b/cmd/zdb/zdb.c
index 35d71012f77f7636f514af6505dc8cfdc7dec3ea..63fb41df82e3f0d8e1d9dd9f3427a32d028e4051 100644 (file)
--- a/cmd/zdb/zdb.c
+++ b/cmd/zdb/zdb.c
@@ -74,6 +74,7 @@
 #include <sys/arc.h>
 #include <sys/arc_impl.h>
 #include <sys/ddt.h>
+#include <sys/ddt_impl.h>
 #include <sys/zfeature.h>
 #include <sys/abd.h>
 #include <sys/blkptr.h>

diff --git a/include/Makefile.am b/include/Makefile.am
index cb28a2d6c96c08da2ff6731c1c3552edc1a168da..fa725c2e7a5f894a4a37df837a67618a3d9533ef 100644 (file)
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -37,6 +37,7 @@ COMMON_H = \
        sys/dataset_kstats.h \
        sys/dbuf.h \
        sys/ddt.h \
+       sys/ddt_impl.h \
        sys/dmu.h \
        sys/dmu_impl.h \
        sys/dmu_objset.h \

diff --git a/include/sys/ddt.h b/include/sys/ddt.h
index 39cffeb366a0fec0759595000a8ba6ad0eb053ac..25b8e7c9d37126bbbb378abe00faea2a73b09daa 100644 (file)
--- a/include/sys/ddt.h
+++ b/include/sys/ddt.h
@@ -152,57 +152,16 @@ typedef struct ddt_bookmark {
        uint64_t        ddb_cursor;
 } ddt_bookmark_t;
 
-/*
- * Ops vector to access a specific DDT object type.
- */
-typedef struct ddt_ops {
-       char ddt_op_name[32];
-       int (*ddt_op_create)(objset_t *os, uint64_t *object, dmu_tx_t *tx,
-           boolean_t prehash);
-       int (*ddt_op_destroy)(objset_t *os, uint64_t object, dmu_tx_t *tx);
-       int (*ddt_op_lookup)(objset_t *os, uint64_t object, ddt_entry_t *dde);
-       void (*ddt_op_prefetch)(objset_t *os, uint64_t object,
-           ddt_entry_t *dde);
-       int (*ddt_op_update)(objset_t *os, uint64_t object, ddt_entry_t *dde,
-           dmu_tx_t *tx);
-       int (*ddt_op_remove)(objset_t *os, uint64_t object, ddt_entry_t *dde,
-           dmu_tx_t *tx);
-       int (*ddt_op_walk)(objset_t *os, uint64_t object, ddt_entry_t *dde,
-           uint64_t *walk);
-       int (*ddt_op_count)(objset_t *os, uint64_t object, uint64_t *count);
-} ddt_ops_t;
-
-#define        DDT_NAMELEN     107
-
-extern void ddt_object_name(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz, char *name);
-extern int ddt_object_walk(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz, uint64_t *walk, ddt_entry_t *dde);
-extern int ddt_object_count(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz, uint64_t *count);
-extern int ddt_object_info(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz, dmu_object_info_t *);
-extern boolean_t ddt_object_exists(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz);
-
 extern void ddt_bp_fill(const ddt_phys_t *ddp, blkptr_t *bp,
     uint64_t txg);
 extern void ddt_bp_create(enum zio_checksum checksum, const ddt_key_t *ddk,
     const ddt_phys_t *ddp, blkptr_t *bp);
 
-extern void ddt_key_fill(ddt_key_t *ddk, const blkptr_t *bp);
-
 extern void ddt_phys_fill(ddt_phys_t *ddp, const blkptr_t *bp);
 extern void ddt_phys_clear(ddt_phys_t *ddp);
 extern void ddt_phys_addref(ddt_phys_t *ddp);
 extern void ddt_phys_decref(ddt_phys_t *ddp);
-extern void ddt_phys_free(ddt_t *ddt, ddt_key_t *ddk, ddt_phys_t *ddp,
-    uint64_t txg);
 extern ddt_phys_t *ddt_phys_select(const ddt_entry_t *dde, const blkptr_t *bp);
-extern uint64_t ddt_phys_total_refcnt(const ddt_entry_t *dde);
-
-extern void ddt_stat_update(ddt_t *ddt, ddt_entry_t *dde, uint64_t neg);
-extern void ddt_stat_add(ddt_stat_t *dst, const ddt_stat_t *src, uint64_t neg);
 
 extern void ddt_histogram_add(ddt_histogram_t *dst, const ddt_histogram_t *src);
 extern void ddt_histogram_stat(ddt_stat_t *dds, const ddt_histogram_t *ddh);
@@ -236,13 +195,9 @@ extern int ddt_load(spa_t *spa);
 extern void ddt_unload(spa_t *spa);
 extern void ddt_sync(spa_t *spa, uint64_t txg);
 extern int ddt_walk(spa_t *spa, ddt_bookmark_t *ddb, ddt_entry_t *dde);
-extern int ddt_object_update(ddt_t *ddt, enum ddt_type type,
-    enum ddt_class clazz, ddt_entry_t *dde, dmu_tx_t *tx);
 
 extern boolean_t ddt_addref(spa_t *spa, const blkptr_t *bp);
 
-extern const ddt_ops_t ddt_zap_ops;
-
 #ifdef __cplusplus
 }
 #endif

diff --git a/include/sys/ddt_impl.h b/include/sys/ddt_impl.h
new file mode 100644 (file)
index 0000000..c43ced5
--- /dev/null
+++ b/include/sys/ddt_impl.h
@@ -0,0 +1,86 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or https://opensource.org/licenses/CDDL-1.0.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016 by Delphix. All rights reserved.
+ * Copyright (c) 2023, Klara Inc.
+ */
+
+#ifndef _SYS_DDT_IMPL_H
+#define        _SYS_DDT_IMPL_H
+
+#include <sys/ddt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Ops vector to access a specific DDT object type.
+ */
+typedef struct ddt_ops {
+       char ddt_op_name[32];
+       int (*ddt_op_create)(objset_t *os, uint64_t *object, dmu_tx_t *tx,
+           boolean_t prehash);
+       int (*ddt_op_destroy)(objset_t *os, uint64_t object, dmu_tx_t *tx);
+       int (*ddt_op_lookup)(objset_t *os, uint64_t object, ddt_entry_t *dde);
+       void (*ddt_op_prefetch)(objset_t *os, uint64_t object,
+           ddt_entry_t *dde);
+       int (*ddt_op_update)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+           dmu_tx_t *tx);
+       int (*ddt_op_remove)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+           dmu_tx_t *tx);
+       int (*ddt_op_walk)(objset_t *os, uint64_t object, ddt_entry_t *dde,
+           uint64_t *walk);
+       int (*ddt_op_count)(objset_t *os, uint64_t object, uint64_t *count);
+} ddt_ops_t;
+
+extern const ddt_ops_t ddt_zap_ops;
+
+extern void ddt_stat_update(ddt_t *ddt, ddt_entry_t *dde, uint64_t neg);
+
+/*
+ * These are only exposed so that zdb can access them. Try not to use them
+ * outside of the DDT implementation proper, and if you do, consider moving
+ * them up.
+ */
+#define        DDT_NAMELEN     107
+
+extern uint64_t ddt_phys_total_refcnt(const ddt_entry_t *dde);
+
+extern void ddt_key_fill(ddt_key_t *ddk, const blkptr_t *bp);
+
+extern void ddt_stat_add(ddt_stat_t *dst, const ddt_stat_t *src, uint64_t neg);
+
+extern void ddt_object_name(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, char *name);
+extern int ddt_object_walk(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, uint64_t *walk, ddt_entry_t *dde);
+extern int ddt_object_count(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, uint64_t *count);
+extern int ddt_object_info(ddt_t *ddt, enum ddt_type type,
+    enum ddt_class clazz, dmu_object_info_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_DDT_H */

diff --git a/module/zfs/ddt.c b/module/zfs/ddt.c
index 43fc2aef5200e9d17b6df3bb31b0627747add93a..321437c2234a633b0947c9f6bc05b0ad15b92060 100644 (file)
--- a/module/zfs/ddt.c
+++ b/module/zfs/ddt.c
@@ -30,6 +30,7 @@
 #include <sys/spa_impl.h>
 #include <sys/zio.h>
 #include <sys/ddt.h>
+#include <sys/ddt_impl.h>
 #include <sys/zap.h>
 #include <sys/dmu_tx.h>
 #include <sys/arc.h>
@@ -171,6 +172,12 @@ ddt_object_sync(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
        ddo->ddo_mspace = doi.doi_fill_count * doi.doi_data_block_size;
 }
 
+static boolean_t
+ddt_object_exists(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
+{
+       return (!!ddt->ddt_object[type][class]);
+}
+
 static int
 ddt_object_lookup(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
     ddt_entry_t *dde)
@@ -193,7 +200,7 @@ ddt_object_prefetch(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
            ddt->ddt_object[type][class], dde);
 }
 
-int
+static int
 ddt_object_update(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
     ddt_entry_t *dde, dmu_tx_t *tx)
 {
@@ -244,12 +251,6 @@ ddt_object_info(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
            doi));
 }
 
-boolean_t
-ddt_object_exists(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
-{
-       return (!!ddt->ddt_object[type][class]);
-}
-
 void
 ddt_object_name(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
     char *name)
@@ -341,7 +342,7 @@ ddt_phys_decref(ddt_phys_t *ddp)
        }
 }
 
-void
+static void
 ddt_phys_free(ddt_t *ddt, ddt_key_t *ddk, ddt_phys_t *ddp, uint64_t txg)
 {
        blkptr_t blk;

diff --git a/module/zfs/ddt_stats.c b/module/zfs/ddt_stats.c
index 1f1a1188f97cfeece4f1e84db48fc77924c3735c..e1d367730854008d38469d9eb770bda717f394a8 100644 (file)
--- a/module/zfs/ddt_stats.c
+++ b/module/zfs/ddt_stats.c
@@ -30,6 +30,7 @@
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/ddt.h>
+#include <sys/ddt_impl.h>
 
 static void
 ddt_stat_generate(ddt_t *ddt, ddt_entry_t *dde, ddt_stat_t *dds)

diff --git a/module/zfs/ddt_zap.c b/module/zfs/ddt_zap.c
index 0ec3eccb1c144125149e3d523c9ce533cf96b4f8..56312881fdda0511604b268a997b608d9d4f4a48 100644 (file)
--- a/module/zfs/ddt_zap.c
+++ b/module/zfs/ddt_zap.c
@@ -28,6 +28,7 @@
 #include <sys/spa.h>
 #include <sys/zio.h>
 #include <sys/ddt.h>
+#include <sys/ddt_impl.h>
 #include <sys/zap.h>
 #include <sys/dmu_tx.h>
 #include <sys/zio_compress.h>