clk: Add kunit tests for fixed rate and parent data

Load a small DTB for KUnit from of_core_init() as long as CONFIG_OF=y and CONFIG_KUNIT=y/m. This allows KUnit tests to load overlays into the running system. It also allows KUnit tests to run on any architecture that supports it so that devicetree can be used while unit testing architecture specific code.

Overlays need a target node to apply their overlays to, so make a fake bus called 'kunit-bus' in the root node to allow this. Make the node a simple-bus so that platform devices are automatically created for nodes added as children of this node. Unit test overlays can target this node via the label 'kunit_bus'.

Cc Rob Herring <[email protected]>

Cc Frank Rowand <[email protected]>

Signed-off-by Stephen Boyd <[email protected]>

---
 drivers/of/.kunitconfig |   3 +
 drivers/of/Kconfig      |  13 +++
 drivers/of/Makefile     |   4 +
 drivers/of/base.c       | 182 ++++++++++++++++++++++++++++++++++++++++
 drivers/of/kunit.dtso   |  10 +++
 drivers/of/of_private.h |   6 ++
 drivers/of/of_test.c    |  43 ++++++++++
 drivers/of/unittest.c   | 101 +---------------------
 8 files changed, 262 insertions(+), 100 deletions(-)
 create mode 100644 drivers/of/.kunitconfig
 create mode 100644 drivers/of/kunit.dtso
 create mode 100644 drivers/of/of_test.c

drivers/of/.kunitconfig new file +3 -0

new file mode 100644
index 000000000000..5a8fee11978c
@@ -0,0 +1,3 @@
+CONFIG_KUNIT=y
+CONFIG_OF=y
+CONFIG_OF_KUNIT_TEST=y

drivers/of/Kconfig +13 -0

index 644386833a7b..f6739b9560c5 100644
@@ -37,6 +37,19 @@ config OF_UNITTEST
 
 	  If unsure, say N here. This option is not safe to enable.
 
+config OF_KUNIT
+	def_bool KUNIT
+	select OF_RESOLVE
+
+config OF_KUNIT_TEST
+	tristate "Devicetree KUnit DTB Test" if !KUNIT_ALL_TESTS
+	depends on KUNIT
+	default KUNIT_ALL_TESTS
+	help
+	  This option builds KUnit unit tests for device tree infrastructure.
+
+	  If unsure, say N here, but this option is safe to enable.
+
 config OF_ALL_DTBS
 	bool "Build all Device Tree Blobs"
 	depends on COMPILE_TEST

drivers/of/Makefile +4 -0

index e0360a44306e..cf6ee7ba6350 100644
@@ -19,4 +19,8 @@ obj-y	+= kexec.o
 endif
 endif
 
+DTC_FLAGS_kunit += -@
+obj-$(CONFIG_OF_KUNIT) += kunit.dtbo.o
+obj-$(CONFIG_OF_KUNIT_TEST) += of_test.o
+
 obj-$(CONFIG_OF_UNITTEST) += unittest-data/

drivers/of/base.c +0 -0

index ac6fde53342f..090c5d7925e4 100644
@@ -16,13 +16,16 @@
 

drivers/of/base.c +18 -0

+static int __init of_kunit_add_data(void)
+{
+	void *kunit_fdt;
+	void *kunit_fdt_align;
+	struct device_node *kunit_node = NULL, *np;
+	/*
+	 * __dtbo_kunit_begin[] and __dtbo_kunit_end[] are magically
+	 * created by cmd_dt_S_dtbo in scripts/Makefile.lib
+	 */
+	extern uint8_t __dtbo_kunit_begin[];
+	extern uint8_t __dtbo_kunit_end[];
+	const int size = __dtbo_kunit_end - __dtbo_kunit_begin;
+	int rc;
+	void *ret;
+
+	if (!size) {
+		pr_warn("kunit.dtbo is empty\n");
+		return -ENODATA;

drivers/of/base.c +10 -0

+	if (!ret) {
+		pr_warn("unflatten KUnit tree failed\n");
+		kfree(kunit_fdt);
+		return -ENODATA;
+	}
+	if (!kunit_node) {
+		pr_warn("KUnit tree is empty\n");
+		kfree(kunit_fdt);
+		return -ENODATA;
+	}

drivers/of/base.c +31 -0

+		of_root = kunit_node;
+		of_chosen = of_find_node_by_path("/chosen");
+	} else {
+		/* attach the sub-tree to live tree */
+		np = kunit_node->child;
+		while (np) {
+			struct device_node *next = np->sibling;
+
+			np->parent = of_root;
+			of_test_attach_node_and_children(np);
+			np = next;
+		}
+	}
+
+	if (!of_aliases)
+		of_aliases = of_find_node_by_path("/aliases");
+
+	of_overlay_mutex_unlock();
+
+	return 0;
+}
+#else
+static inline int __init of_kunit_add_data(void) { return 0; }
+#endif
+
 void __init of_core_init(void)
 {
 	struct device_node *np;
+	int ret;
 
+	ret = of_kunit_add_data();
+	if (ret) {
+		pr_err("failed to add kunit test data\n");
+		return;
+	}
 
 	/* Create the kset, and register existing nodes */
 	mutex_lock(&of_mutex);

@@ -1879,6 +1962,105 @@ int of_update_property(struct device_node *np, struct property *newprop)
 	return rc;
 }
 

drivers/of/base.c +89 -0

+{
+	struct property *prop;
+	struct property *save_next;
+	struct device_node *child;
+	int ret;
+
+	for_each_child_of_node(np, child)
+		child->parent = dup;
+
+	/*
+	 * "unittest internal error: unable to add testdata property"
+	 *
+	 *    If this message reports a property in node '/__symbols__' then
+	 *    the respective unittest overlay contains a label that has the
+	 *    same name as a label in the live devicetree.  The label will
+	 *    be in the live devicetree only if the devicetree source was
+	 *    compiled with the '-@' option.  If you encounter this error,
+	 *    please consider renaming __all__ of the labels in the unittest
+	 *    overlay dts files with an odd prefix that is unlikely to be
+	 *    used in a real devicetree.
+	 */
+
+	/*
+	 * open code for_each_property_of_node() because of_add_property()
+	 * sets prop->next to NULL
+	 */
+	for (prop = np->properties; prop != NULL; prop = save_next) {
+		save_next = prop->next;
+		ret = of_add_property(dup, prop);
+		if (ret) {
+			if (ret == -EEXIST && !strcmp(prop->name, "name"))
+				continue;
+			pr_err("unittest internal error: unable to add testdata property %pOF/%s",
+			       np, prop->name);
+		}
+	}
+}
+
+/**
+ * of_test_attach_node_and_children - attaches nodes and its children to live tree.
+ * @np:	Node to attach to live tree
+ *
+ * CAUTION: misleading function name - if node @np already exists in
+ * the live tree then children of @np are *not* attached to the live
+ * tree.  This works for the current test devicetree nodes because such
+ * nodes do not have child nodes.
+ */
+void __init of_test_attach_node_and_children(struct device_node *np)
+{
+	struct device_node *next, *dup, *child;
+	unsigned long flags;
+	const char *full_name;
+
+	full_name = kasprintf(GFP_KERNEL, "%pOF", np);
+
+	if (!strcmp(full_name, "/__local_fixups__") ||
+	    !strcmp(full_name, "/__fixups__")) {
+		kfree(full_name);
+		return;
+	}
+
+	dup = of_find_node_by_path(full_name);
+	kfree(full_name);
+	if (dup) {
+		update_node_properties(np, dup);
+		return;
+	}
+
+	child = np->child;
+	np->child = NULL;
+
+	mutex_lock(&of_mutex);
+	raw_spin_lock_irqsave(&devtree_lock, flags);
+	np->sibling = np->parent->child;
+	np->parent->child = np;
+	of_node_clear_flag(np, OF_DETACHED);
+	raw_spin_unlock_irqrestore(&devtree_lock, flags);
+
+	__of_attach_node_sysfs(np);
+	mutex_unlock(&of_mutex);
+
+	while (child) {
+		next = child->sibling;
+		of_test_attach_node_and_children(child);
+		child = next;
+	}
+}
+#endif
+
 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
 			 int id, const char *stem, int stem_len)
 {

drivers/of/kunit.dtso new file +0 -0

new file mode 100644
index 000000000000..d512057df98d

drivers/of/of_private.h +6 -0

index fb6792d381a6..2151a28ca234 100644
@@ -96,6 +96,12 @@ static inline void of_overlay_mutex_lock(void) {};
 static inline void of_overlay_mutex_unlock(void) {};
 #endif
 
+#if defined(CONFIG_OF_UNITTEST) || defined (CONFIG_KUNIT)
+void __init of_test_attach_node_and_children(struct device_node *np);
+#else
+static inline void __init of_test_attach_node_and_children(struct device_node *np) {}
+#endif
+
 #if defined(CONFIG_OF_UNITTEST) && defined(CONFIG_OF_OVERLAY)
 extern void __init unittest_unflatten_overlay_base(void);
 #else

drivers/of/of_test.c new file +14 -0

new file mode 100644
index 000000000000..a4d70ac344ad
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for OF APIs
+ */
+#include <linux/kconfig.h>
+#include <linux/of.h>
+
+#include <kunit/test.h>
+
+/*
+ * Test that the root node / exists.
+ */
+static void dtb_root_node_exists(struct kunit *test)
+{

Quoted 8 lines

drivers/of/base.c +0 -0

index ac6fde53342f..090c5d7925e4 100644
@@ -16,13 +16,16 @@
 
 #define pr_fmt(fmt)  "OF: " fmt
 

drivers/of/base.c line 26

Quoted 8 lines

drivers/of/base.c +2 -0

+#include <linux/align.h>
 #include <linux/console.h>
 #include <linux/ctype.h>
 #include <linux/cpu.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/of_fdt.h>

base.c deals with unflattened trees. There shouldn't be anything FDT related in it.

Quoted 10 lines

drivers/of/base.c +1 -0

 #include <linux/of_graph.h>
+#include <linux/printk.h>
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/string.h>

@@ -163,10 +166,90 @@ void __of_phandle_cache_inv_entry(phandle handle)
              phandle_cache[handle_hash] = NULL;
 }
 

drivers/of/base.c void __of_phandle_cache_inv_entry(phandle handle) · line 169

Quoted 1 line

drivers/of/base.c +1 -0

+#ifdef CONFIG_OF_KUNIT

base.c is already quite big. This should probably be its own file. Perhaps in kunit code because that's what we do for everything else (e.g. DT clock code goes in drivers/clk/). (My goal is to eliminate drivers/of/. That's easier than finding maintainers. ;) )

Quoted 26 lines

drivers/of/base.c +25 -0

+static int __init of_kunit_add_data(void)
+{
+     void *kunit_fdt;
+     void *kunit_fdt_align;
+     struct device_node *kunit_node = NULL, *np;
+     /*
+      * __dtbo_kunit_begin[] and __dtbo_kunit_end[] are magically
+      * created by cmd_dt_S_dtbo in scripts/Makefile.lib
+      */
+     extern uint8_t __dtbo_kunit_begin[];
+     extern uint8_t __dtbo_kunit_end[];
+     const int size = __dtbo_kunit_end - __dtbo_kunit_begin;
+     int rc;
+     void *ret;
+
+     if (!size) {
+             pr_warn("kunit.dtbo is empty\n");
+             return -ENODATA;
+     }
+
+     kunit_fdt = kmalloc(size + FDT_ALIGN_SIZE, GFP_KERNEL);
+     if (!kunit_fdt)
+             return -ENOMEM;
+
+     kunit_fdt_align = PTR_ALIGN(kunit_fdt, FDT_ALIGN_SIZE);

drivers/of/base.c void __of_phandle_cache_inv_entry(phandle handle) · line 197

Quoted 3 lines

drivers/of/base.c +3 -0

+     memcpy(kunit_fdt_align, __dtbo_kunit_begin, size);
+
+     ret = of_fdt_unflatten_tree(kunit_fdt_align, NULL, &kunit_node);

I don't understand why this doesn't use of_overlay_fdt_apply(). Your test(s) shouldn't be any different than any other overlay user (granted, there aren't many). You apply the overlay, run your test, then remove the overlay.

Quoted 18 lines

drivers/of/base.c +17 -0

+     if (!ret) {
+             pr_warn("unflatten KUnit tree failed\n");
+             kfree(kunit_fdt);
+             return -ENODATA;
+     }
+     if (!kunit_node) {
+             pr_warn("KUnit tree is empty\n");
+             kfree(kunit_fdt);
+             return -ENODATA;
+     }
+
+     of_overlay_mutex_lock();
+     rc = of_resolve_phandles(kunit_node);
+     if (rc) {
+             pr_err("Failed to resolve KUnit phandles (rc=%i)\n", rc);
+             of_overlay_mutex_unlock();
+             return -EINVAL;

drivers/of/base.c void __of_phandle_cache_inv_entry(phandle handle) · line 217

Quoted 3 lines

drivers/of/base.c +3 -0

+     }
+
+     if (!of_root) {

There's patches from Frank and others under review which will always create and empty DT if the bootloader/arch didn't provide one. This series should rely on that. (Or just assume that when that happens, your tests will run in more environments)

Quoted 4 lines

drivers/of/base.c +0 -0

@@ -1879,6 +1962,105 @@ int of_update_property(struct device_node *np, struct property *newprop)
      return rc;
 }
 

drivers/of/base.c int of_update_property(struct device_node *np, struct property *newprop) · line 1974

Quoted 10 lines

drivers/of/base.c +10 -0

+#if defined(CONFIG_OF_UNITTEST) || defined (CONFIG_KUNIT)
+/**
+ * update_node_properties - adds the properties of np into dup node (present in
+ * live tree) and updates parent of children of np to dup.
+ *
+ * @np: node whose properties are being added to the live tree
+ * @dup: node present in live tree to be updated
+ */
+static void __init update_node_properties(struct device_node *np,
+                                     struct device_node *dup)

Please split any moving of code to separate patches.

I'm not remembering why we need these test functions vs. just applying overlays. Frank? Perhaps because it's trying to test the overlay code itself. But you should just be a user of the overlay API and not need to do anything special.

Quoted 10 lines

drivers/of/kunit.dtso new file +4 -0

new file mode 100644
index 000000000000..d512057df98d
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+/dts-v1/;
+/plugin/;
+

drivers/of/kunit.dtso line 10

Quoted 6 lines

drivers/of/kunit.dtso new file +6 -0

+/ {
+     /* Container node where KUnit tests can load overlays */
+     kunit_bus: kunit-bus {
+             compatible = "simple-bus";
+     };
+};

Why do we need an overlay to apply overlays to?

Quoted 27 lines

drivers/of/of_test.c new file +19 -0

new file mode 100644
index 000000000000..a4d70ac344ad
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for OF APIs
+ */
+#include <linux/kconfig.h>
+#include <linux/of.h>
+
+#include <kunit/test.h>
+
+/*
+ * Test that the root node / exists.
+ */
+static void dtb_root_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/"));
+}
+
+/*
+ * Test that the /__symbols__ node exists.

drivers/of/of_test.c line 24

Quoted 5 lines

drivers/of/of_test.c new file +5 -0

+ */
+static void dtb_symbols_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/__symbols__"));
+}

Many base DTs will not have this. And the kunit tests themselves shouldn't need it because they should be independent of the base tree.

Quoted 25 lines

drivers/of/of_test.c new file +19 -0

new file mode 100644
index 000000000000..a4d70ac344ad
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for OF APIs
+ */
+#include <linux/kconfig.h>
+#include <linux/of.h>
+
+#include <kunit/test.h>
+
+/*
+ * Test that the root node / exists.
+ */
+static void dtb_root_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/"));
+}
+
+/*
+ * Test that the /__symbols__ node exists.

drivers/of/of_test.c line 24

Quoted 5 lines

drivers/of/of_test.c new file +5 -0

+ */
+static void dtb_symbols_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/__symbols__"));
+}

Many base DTs will not have this. And the kunit tests themselves shouldn't need it because they should be independent of the base tree.

Quoting Rob Herring (2023-03-21 10:33:03)

Quoted 26 lines · Stephen Boyd

Quoted 25 lines

drivers/of/of_test.c new file +19 -0

new file mode 100644
index 000000000000..a4d70ac344ad
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for OF APIs
+ */
+#include <linux/kconfig.h>
+#include <linux/of.h>
+
+#include <kunit/test.h>
+
+/*
+ * Test that the root node / exists.
+ */
+static void dtb_root_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/"));
+}
+
+/*
+ * Test that the /__symbols__ node exists.

Quoted 9 lines

drivers/of/of_test.c line 24

Quoted 5 lines

drivers/of/of_test.c new file +5 -0

+ */
+static void dtb_symbols_node_exists(struct kunit *test)
+{
+     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_find_node_by_path("/__symbols__"));
+}

Many base DTs will not have this. And the kunit tests themselves shouldn't need it because they should be independent of the base tree.

When I try to apply an overlay it fails

OF: overlay: no fragments or symbols in overlay
OF: overlay: init_overlay_changeset() failed, ret = -22

     # of_overlay_apply_kunit_apply: ASSERTION FAILED at drivers/of/overlay_test.c:18
     Expected 0 == ({ extern uint8_t __dtbo_kunit_overlay_test_begin[]; extern uint8_t __dtbo_kunit_overlay_test_end[]; __of_overlay_apply_kunit((test), __dtbo_kunit_overlay_test_begin, __dtbo_kunit_overlay_test_end); }), but
         ({ extern uint8_t __dtbo_kunit_overlay_test_begin[]; extern uint8_t __dtbo_kunit_overlay_test_end[]; __of_overlay_apply_kunit((test), __dtbo_kunit_overlay_test_begin, __dtbo_kunit_overlay_test_end); }) == -12 (0xfffffffffffffff4)

[FAILED] of_overlay_apply_kunit_apply

Now I'm trying to hack on the fake root node to see if I can make it work.

Describe a binding for an empty device node used by KUnit tests to confirm overlays load properly.

Cc Rob Herring <[email protected]>

Cc Krzysztof Kozlowski <[email protected]>

Cc Brendan Higgins <[email protected]>

Cc David Gow <[email protected]>

Signed-off-by Stephen Boyd <[email protected]>

---
 .../bindings/test/test,kunit-empty.yaml       | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/test/test,kunit-empty.yaml

Documentation/devicetree/bindings/test/test,kunit-empty.yaml new file +0 -0

new file mode 100644
index 000000000000..592fd06031b8

Documentation/devicetree/bindings/test/test,kunit-empty.yaml new file +17 -0

+  An empty node to confirm KUnit can load device tree overlays.
+
+properties:
+  compatible:
+    const: test,kunit-empty
+
+required:
+  - compatible
+
+additionalProperties: false
+
+examples:
+  - |
+    kunit-node {
+      compatible = "test,kunit-empty";
+    };
+...

Signature · 2 lines

https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/
https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git

Describe a binding for a device that consumes a fixed rate clk in DT so that a KUnit test can get the clk registered by of_fixed_clk_setup() and test that it is setup properly.

Cc Rob Herring <[email protected]>

Cc Krzysztof Kozlowski <[email protected]>

Cc Brendan Higgins <[email protected]>

Cc David Gow <[email protected]>

Signed-off-by Stephen Boyd <[email protected]>

---
 .../kunit/test,clk-kunit-fixed-rate.yaml      | 35 +++++++++++++++++++

 1 file changed, 35 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml new file +2 -0

new file mode 100644
index 000000000000..58d7826d9c14
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml new file +17 -0

+
+  clocks:
+    maxItems: 1
+
+required:
+  - compatible
+  - clocks
+
+additionalProperties: false
+
+examples:
+  - |
+    clock-consumer {
+      compatible = "test,clk-kunit-fixed-rate";
+      clocks = <&fixed_clk>;
+    };
+...

Signature · 2 lines

https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/
https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git

Quoted 11 lines

Describe a binding for a device that consumes a fixed rate clk in DT so that a KUnit test can get the clk registered by of_fixed_clk_setup() and test that it is setup properly.

Cc Rob Herring <[email protected]>

Cc Krzysztof Kozlowski <[email protected]>

Cc Brendan Higgins <[email protected]>

Cc David Gow <[email protected]>

Signed-off-by Stephen Boyd <[email protected]>

---
 .../kunit/test,clk-kunit-fixed-rate.yaml      | 35 +++++++++++++++++++

Some stuff in test and some in kunit? I prefer 'test'.

Quoted 12 lines

 1 file changed, 35 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml new file +2 -0

new file mode 100644
index 000000000000..58d7826d9c14
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml line 12

Quoted 10 lines

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml new file +10 -0

+---
+$id: http://devicetree.org/schemas/kunit/test,clk-kunit-fixed-rate.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: KUnit clk fixed rate test clk consumer
+
+maintainers:
+  - Stephen Boyd <[email protected]>
+
+description: |

Drop '|'

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml line 18

Quoted 6 lines

Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml new file +6 -0

+  A clk consumer of a fixed rate clk used to test the fixed rate clk
+  implementation in the Linux kernel.
+
+properties:
+  compatible:
+    const: test,clk-kunit-fixed-rate

I tend to think we should drop 'kunit' from these bindings. You could use this for different test frameworks.

This patch series adds unit tests for the clk fixed rate basic type and the clk registration functions that use struct clk_parent_data. To get there, we add support for loading device tree overlays onto the live DTB along with probing platform drivers to bind to device nodes in the overlays. With this series, we're able to exercise some of the code in the common clk framework that uses devicetree lookups to find parents and the fixed rate clk code that scans device tree directly and creates clks. Please review.

I Cced everyone to all the patches so they get the full context. I'm hoping I can take the whole pile through the clk tree as they almost all depend on each other.

Changes from v1 (https://lore.kernel.org/r/[email protected]):
* Don't depend on UML, use unittest data approach to attach nodes
* Introduce overlay loading API for KUnit
* Move platform_device KUnit code to drivers/base/test
* Use #define macros for constants shared between unit tests and overlays
* Settle on "test" as a vendor prefix
* Make KUnit wrappers have "_kunit" postfix

Stephen Boyd (11):
of: Load KUnit DTB from of_core_init()
of: Add test managed wrappers for of_overlay_apply()/of_node_put()
dt-bindings: vendor-prefixes: Add "test" vendor for KUnit and friends
dt-bindings: test: Add KUnit empty node binding
of: Add a KUnit test for overlays and test managed APIs
platform: Add test managed platform_device/driver APIs
dt-bindings: kunit: Add fixed rate clk consumer test
clk: Add test managed clk provider/consumer APIs
clk: Add KUnit tests for clk fixed rate basic type
dt-bindings: clk: Add KUnit clk_parent_data test
clk: Add KUnit tests for clks registered with struct clk_parent_data

 .../clock/test,clk-kunit-parent-data.yaml     |  47 ++
 .../kunit/test,clk-kunit-fixed-rate.yaml      |  35 ++
 .../bindings/test/test,kunit-empty.yaml       |  30 ++
 .../devicetree/bindings/vendor-prefixes.yaml  |   2 +
 drivers/base/test/Makefile                    |   3 +
 drivers/base/test/platform_kunit-test.c       | 108 +++++
 drivers/base/test/platform_kunit.c            | 186 +++++++
 drivers/clk/.kunitconfig                      |   3 +
 drivers/clk/Kconfig                           |   7 +
 drivers/clk/Makefile                          |   9 +-
 drivers/clk/clk-fixed-rate_test.c             | 299 ++++++++++++
 drivers/clk/clk-fixed-rate_test.h             |   8 +
 drivers/clk/clk_kunit.c                       | 219 +++++++++
 drivers/clk/clk_parent_data_test.h            |  10 +
 drivers/clk/clk_test.c                        | 459 +++++++++++++++++-
 drivers/clk/kunit_clk_fixed_rate_test.dtso    |  19 +
 drivers/clk/kunit_clk_parent_data_test.dtso   |  28 ++
 drivers/of/.kunitconfig                       |   5 +
 drivers/of/Kconfig                            |  23 +
 drivers/of/Makefile                           |   7 +
 drivers/of/base.c                             | 182 +++++++
 drivers/of/kunit.dtso                         |  10 +
 drivers/of/kunit_overlay_test.dtso            |   9 +
 drivers/of/of_kunit.c                         | 123 +++++
 drivers/of/of_private.h                       |   6 +
 drivers/of/of_test.c                          |  43 ++
 drivers/of/overlay_test.c                     | 107 ++++
 drivers/of/unittest.c                         | 101 +---
 include/kunit/clk.h                           |  28 ++
 include/kunit/of.h                            |  90 ++++
 include/kunit/platform_device.h               |  15 +
 31 files changed, 2119 insertions(+), 102 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/clock/test,clk-kunit-parent-data.yaml
 create mode 100644 Documentation/devicetree/bindings/kunit/test,clk-kunit-fixed-rate.yaml
 create mode 100644 Documentation/devicetree/bindings/test/test,kunit-empty.yaml
 create mode 100644 drivers/base/test/platform_kunit-test.c
 create mode 100644 drivers/base/test/platform_kunit.c
 create mode 100644 drivers/clk/clk-fixed-rate_test.c
 create mode 100644 drivers/clk/clk-fixed-rate_test.h
 create mode 100644 drivers/clk/clk_kunit.c
 create mode 100644 drivers/clk/clk_parent_data_test.h
 create mode 100644 drivers/clk/kunit_clk_fixed_rate_test.dtso
 create mode 100644 drivers/clk/kunit_clk_parent_data_test.dtso
 create mode 100644 drivers/of/.kunitconfig
 create mode 100644 drivers/of/kunit.dtso
 create mode 100644 drivers/of/kunit_overlay_test.dtso
 create mode 100644 drivers/of/of_kunit.c
 create mode 100644 drivers/of/of_test.c
 create mode 100644 drivers/of/overlay_test.c
 create mode 100644 include/kunit/clk.h
 create mode 100644 include/kunit/of.h
 create mode 100644 include/kunit/platform_device.h

base-commit: fe15c26ee26efa11741a7b632e9f23b01aca4cc6 --
https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/
https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git

Quoted 14 lines

This patch series adds unit tests for the clk fixed rate basic type and the clk registration functions that use struct clk_parent_data. To get there, we add support for loading device tree overlays onto the live DTB along with probing platform drivers to bind to device nodes in the overlays. With this series, we're able to exercise some of the code in the common clk framework that uses devicetree lookups to find parents and the fixed rate clk code that scans device tree directly and creates clks. Please review.

I Cced everyone to all the patches so they get the full context. I'm hoping I can take the whole pile through the clk tree as they almost all depend on each other.

Quoted 9 lines

Changes from v1 (https://lore.kernel.org/r/[email protected]):
* Don't depend on UML, use unittest data approach to attach nodes
* Introduce overlay loading API for KUnit
* Move platform_device KUnit code to drivers/base/test
* Use #define macros for constants shared between unit tests and overlays
* Settle on "test" as a vendor prefix
* Make KUnit wrappers have "_kunit" postfix

Thanks! I like this much better, and it is working fine here under UML and x86_64.

There are some issues with other architectures (mostly endianness problems, but I got a refcount underflow in kunit_remove_resource after platform_device_alloc_kunit_test on sparc64 as well), but otherwise it's working on most of the things I've tried.

This patch series adds unit tests for the clk fixed rate basic type and the clk registration functions that use struct clk_parent_data. To get there, we add support for loading device tree overlays onto the live DTB along with probing platform drivers to bind to device nodes in the overlays. With this series, we're able to exercise some of the code in the common clk framework that uses devicetree lookups to find parents and the fixed rate clk code that scans device tree directly and creates clks. Please review.

I Cced everyone to all the patches so they get the full context. I'm hoping I can take the whole pile through the clk tree as they almost all depend on each other.

Changes from v1 (https://lore.kernel.org/r/[email protected]):
* Don't depend on UML, use unittest data approach to attach nodes
* Introduce overlay loading API for KUnit
* Move platform_device KUnit code to drivers/base/test
* Use #define macros for constants shared between unit tests and overlays
* Settle on "test" as a vendor prefix
* Make KUnit wrappers have "_kunit" postfix

Hi,

Quoted 13 lines · Stephen Boyd

This patch series adds unit tests for the clk fixed rate basic type and the clk registration functions that use struct clk_parent_data. To get there, we add support for loading device tree overlays onto the live DTB along with probing platform drivers to bind to device nodes in the overlays. With this series, we're able to exercise some of the code in the common clk framework that uses devicetree lookups to find parents and the fixed rate clk code that scans device tree directly and creates clks. Please review.

I Cced everyone to all the patches so they get the full context. I'm hoping I can take the whole pile through the clk tree as they almost all depend on each other.

Quoted 8 lines

Changes from v1 (https://lore.kernel.org/r/[email protected]):
* Don't depend on UML, use unittest data approach to attach nodes
* Introduce overlay loading API for KUnit
* Move platform_device KUnit code to drivers/base/test
* Use #define macros for constants shared between unit tests and overlays
* Settle on "test" as a vendor prefix
* Make KUnit wrappers have "_kunit" postfix

Maybe I'm overthinking this, but wouldn't it make more sense to have a kunit *prefix* to those functions? Any other function in the kernel taking a kunit test pointer as a parameter starts with kunit (like kunit_kzalloc), so it would make more sense to me that kunit-related clk functions follow the same pattern.