regmap: Specifically test writing 0 as a value to sparse caches

Since 0 can look a lot like a NULL pointer when used in a cache some clever
data structures might potentially introduce bugs specific to handling it.
Add some explicit testing of storing 0 as a value in a sparse cache, at the
minute there are no issues and this will stop any appearing in the future.

Signed-off-by: Mark Brown <broonie@kernel.org>
Link: https://patch.msgid.link/20240924-regcache-zero-value-v1-1-8a1224214b52@kernel.org
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/base/regmap/regmap-kunit.c b/drivers/base/regmap/regmap-kunit.c
index 4bf3f1e59ed76013bc8a0d434cd0265f44f237fb..a42c7386b2106550acd4a36b91cdfd9b994296eb 100644 (file)
--- a/drivers/base/regmap/regmap-kunit.c
+++ b/drivers/base/regmap/regmap-kunit.c
@@ -1499,6 +1499,48 @@ static void cache_present(struct kunit *test)
                KUNIT_ASSERT_TRUE(test, regcache_reg_cached(map, param->from_reg + i));
 }
 
+static void cache_write_zero(struct kunit *test)
+{
+       const struct regmap_test_param *param = test->param_value;
+       struct regmap *map;
+       struct regmap_config config;
+       struct regmap_ram_data *data;
+       unsigned int val;
+       int i;
+
+       config = test_regmap_config;
+
+       map = gen_regmap(test, &config, &data);
+       KUNIT_ASSERT_FALSE(test, IS_ERR(map));
+       if (IS_ERR(map))
+               return;
+
+       for (i = 0; i < BLOCK_TEST_SIZE; i++)
+               data->read[param->from_reg + i] = false;
+
+       /* No defaults so no registers cached. */
+       for (i = 0; i < BLOCK_TEST_SIZE; i++)
+               KUNIT_ASSERT_FALSE(test, regcache_reg_cached(map, param->from_reg + i));
+
+       /* We didn't trigger any reads */
+       for (i = 0; i < BLOCK_TEST_SIZE; i++)
+               KUNIT_ASSERT_FALSE(test, data->read[param->from_reg + i]);
+
+       /* Write a zero value */
+       KUNIT_EXPECT_EQ(test, 0, regmap_write(map, 1, 0));
+
+       /* Read that zero value back */
+       KUNIT_EXPECT_EQ(test, 0, regmap_read(map, 1, &val));
+       KUNIT_EXPECT_EQ(test, 0, val);
+
+       /* From the cache? */
+       KUNIT_ASSERT_TRUE(test, regcache_reg_cached(map, 1));
+
+       /* Try to throw it away */
+       KUNIT_EXPECT_EQ(test, 0, regcache_drop_region(map, 1, 1));
+       KUNIT_ASSERT_FALSE(test, regcache_reg_cached(map, 1));
+}
+
 /* Check that caching the window register works with sync */
 static void cache_range_window_reg(struct kunit *test)
 {
@@ -2012,6 +2054,7 @@ static struct kunit_case regmap_test_cases[] = {
        KUNIT_CASE_PARAM(cache_drop_all_and_sync_no_defaults, sparse_cache_types_gen_params),
        KUNIT_CASE_PARAM(cache_drop_all_and_sync_has_defaults, sparse_cache_types_gen_params),
        KUNIT_CASE_PARAM(cache_present, sparse_cache_types_gen_params),
+       KUNIT_CASE_PARAM(cache_write_zero, sparse_cache_types_gen_params),
        KUNIT_CASE_PARAM(cache_range_window_reg, real_cache_types_only_gen_params),
 
        KUNIT_CASE_PARAM(raw_read_defaults_single, raw_test_types_gen_params),