Exercise software page-table insertion, range validation, collisions,
rollback and removal without a device or MMIO. Keep fixture partial-init
cleanup NULL-safe and idempotent because KUnit calls exit after init
failure. These tests do not validate GPU TLB/cache behavior or rendering.

Signed-off-by: Gabriel Gama <[email protected]>
---
diff --git a/drivers/gpu/drm/gma500/Kconfig b/drivers/gpu/drm/gma500/Kconfig
index 
dc4c56638819289919e2fd90d9c2be32fdfd6170..b6e2dda1383b65f6216b061b78a3f78fb6753fb5
 100644
--- a/drivers/gpu/drm/gma500/Kconfig
+++ b/drivers/gpu/drm/gma500/Kconfig
@@ -16,3 +16,13 @@
          Say yes for an experimental 2D KMS framebuffer driver for the
          Intel GMA500 (Poulsbo), Intel GMA600 (Moorestown/Oak Trail) and
          Intel GMA3600/3650 (Cedar Trail).
+
+config DRM_GMA500_KUNIT_TEST
+       bool "KUnit tests for the GMA500 SGX page tables" if !KUNIT_ALL_TESTS
+       depends on DRM_GMA500=y && KUNIT=y
+       default KUNIT_ALL_TESTS
+       help
+         Run software-only tests for SGX page-table range validation,
+         rollback, mapping collisions and removal. The tests use a software
+         page directory with no device or hardware context, and never
+         submit commands to the GPU or access its registers.
diff --git a/drivers/gpu/drm/gma500/Makefile b/drivers/gpu/drm/gma500/Makefile
index 
58fed80c7392a02c317011365c9ce3165412bf3d..069400d70ba8cda62992f9efab9de5010ddf9b75
 100644
--- a/drivers/gpu/drm/gma500/Makefile
+++ b/drivers/gpu/drm/gma500/Makefile
@@ -39,4 +39,6 @@
 gma500_gfx-$(CONFIG_ACPI) +=  opregion.o
 gma500_gfx-$(CONFIG_DRM_FBDEV_EMULATION) +=  fbdev.o
 
+gma500_gfx-$(CONFIG_DRM_GMA500_KUNIT_TEST) += mmu_test.o
+
 obj-$(CONFIG_DRM_GMA500) += gma500_gfx.o
diff --git a/drivers/gpu/drm/gma500/mmu_test.c 
b/drivers/gpu/drm/gma500/mmu_test.c
new file mode 100644
index 
0000000000000000000000000000000000000000..eebfaab2dde8159d0fc97da4b1bc49c7a003315d
--- /dev/null
+++ b/drivers/gpu/drm/gma500/mmu_test.c
@@ -0,0 +1,249 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* SGX page-table tests. No device, hardware context, or MMIO is required. */
+#include <kunit/test.h>
+#include <linux/highmem.h>
+
+#include "mmu.h"
+#include "psb_drv.h"
+
+struct psb_mmu_test_context {
+       struct psb_mmu_driver driver;
+       struct psb_mmu_pd *pd;
+       struct page *pages[4];
+};
+
+static int psb_mmu_test_init(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx;
+       int i;
+
+       test->priv = NULL;
+       ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
+       if (!ctx)
+               return -ENOMEM;
+       test->priv = ctx;
+       spin_lock_init(&ctx->driver.lock);
+       init_rwsem(&ctx->driver.sem);
+       ctx->pd = psb_mmu_alloc_pd(&ctx->driver, 1, 0);
+       if (!ctx->pd)
+               return -ENOMEM;
+       for (i = 0; i < ARRAY_SIZE(ctx->pages); i++) {
+               ctx->pages[i] = alloc_page(GFP_DMA32);
+               if (!ctx->pages[i])
+                       return -ENOMEM;
+       }
+       return 0;
+}
+
+static void psb_mmu_test_exit(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+       int i;
+
+       if (!ctx)
+               return;
+
+       if (ctx->pd) {
+               psb_mmu_free_pagedir(ctx->pd);
+               ctx->pd = NULL;
+       }
+       for (i = 0; i < ARRAY_SIZE(ctx->pages); i++) {
+               if (ctx->pages[i]) {
+                       __free_page(ctx->pages[i]);
+                       ctx->pages[i] = NULL;
+               }
+       }
+       test->priv = NULL;
+}
+
+static u32 psb_mmu_test_pte(struct psb_mmu_pd *pd, u32 address)
+{
+       struct psb_mmu_pt *pt = pd->tables[address >> PSB_PDE_SHIFT];
+       u32 *entries;
+       u32 value;
+
+       if (!pt)
+               return pd->invalid_pte;
+       entries = kmap_local_page(pt->p);
+       value = entries[(address >> PAGE_SHIFT) & 0x3ff];
+       kunmap_local(entries);
+       return value;
+}
+
+static void psb_mmu_zero_pages_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, NULL, 0, 0,
+                                                  0, 0, 0), 0);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0,
+                                                         0, 0, 0), 0);
+       psb_mmu_remove_pages(ctx->pd, 0, 0, 0, 0);
+       psb_mmu_remove_pfn_sequence(ctx->pd, 0, 0);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+}
+
+static void psb_mmu_zero_pages_existing_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+       u32 retained;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0x1000, 1, 0, 0, 0), 0);
+       retained = psb_mmu_test_pte(ctx->pd, 0x1000);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, NULL,
+                                                  0x1000, 0, 0, 1, 0), 0);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0,
+                                                         0x1000, 0, 0), 0);
+       psb_mmu_remove_pages(ctx->pd, 0x1000, 0, 0, 1);
+       psb_mmu_remove_pfn_sequence(ctx->pd, 0x1000, 0);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x1000), retained);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[0]->count, 1U);
+}
+
+static void psb_mmu_range_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  1, 1, 0, 0, 0), -EINVAL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0xfffff000UL, 2, 0, 0, 0),
+                       -ERANGE);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0, 4, 0, 4, 0), -EINVAL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0, 4, 3, 4, 0), -EINVAL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0, 4, 2, 1, 0), -EINVAL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0, 4, 2, U32_MAX, 0), 
-ERANGE);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, NULL,
+                                                  0, 1, 0, 0, 0), -EINVAL);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+}
+
+static void psb_mmu_last_page_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0xfffff000UL, 1, 0, 0, 0), 
0);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0xfffff000),
+                       (u32)(page_to_pfn(ctx->pages[0]) << PAGE_SHIFT) |
+                       PSB_PTE_VALID);
+       psb_mmu_remove_pages(ctx->pd, 0xfffff000UL, 1, 0, 0);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[1023], NULL);
+}
+
+static void psb_mmu_directory_boundary_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0x3ff000, 2, 0, 0, 0), 0);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[0]->count, 1U);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[1]->count, 1U);
+       psb_mmu_remove_pages(ctx->pd, 0x3ff000, 2, 0, 0);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[1], NULL);
+}
+
+static void psb_mmu_collision_rollback_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+       u32 retained;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages + 3,
+                                                  0x400000, 1, 0, 0, 0), 0);
+       retained = psb_mmu_test_pte(ctx->pd, 0x400000);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0x3ff000, 2, 0, 0, 0), 
-EBUSY);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x400000), retained);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[1]->count, 1U);
+}
+
+static void psb_mmu_tiled_rollback_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+       u32 retained;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages + 3,
+                                                  0x8000, 1, 0, 0, 0), 0);
+       retained = psb_mmu_test_pte(ctx->pd, 0x8000);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0x3000, 4, 2, 4, 0), -EBUSY);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x3000), 0U);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x4000), 0U);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x7000), 0U);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x8000), retained);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[0]->count, 1U);
+}
+
+static void psb_mmu_pfn_range_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0x100000,
+                                                         0, 1, 0), -ERANGE);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0xfffff,
+                                                         0, 2, 0), -ERANGE);
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0xfffff,
+                                                         0, 1, 0), 0);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0), 0xfffff001U);
+       psb_mmu_remove_pfn_sequence(ctx->pd, 0, 1);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+}
+
+static void psb_mmu_pfn_rollback_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+       u32 retained;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0x100,
+                                                         0x400000, 1, 0), 0);
+       retained = psb_mmu_test_pte(ctx->pd, 0x400000);
+       KUNIT_EXPECT_EQ(test, psb_mmu_insert_pfn_sequence(ctx->pd, 0x200,
+                                                         0x3ff000, 2, 0), 
-EBUSY);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+       KUNIT_EXPECT_EQ(test, psb_mmu_test_pte(ctx->pd, 0x400000), retained);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[1]->count, 1U);
+}
+
+static void psb_mmu_remove_hole_test(struct kunit *test)
+{
+       struct psb_mmu_test_context *ctx = test->priv;
+
+       KUNIT_ASSERT_EQ(test, psb_mmu_insert_pages(ctx->pd, ctx->pages,
+                                                  0x1000, 1, 0, 0, 0), 0);
+       psb_mmu_remove_pages(ctx->pd, 0x2000, 1, 0, 0);
+       KUNIT_EXPECT_EQ(test, ctx->pd->tables[0]->count, 1U);
+       psb_mmu_remove_pages(ctx->pd, 0x1000, 1, 0, 0);
+       psb_mmu_remove_pfn_sequence(ctx->pd, 0x400000, 1);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[0], NULL);
+       KUNIT_EXPECT_PTR_EQ(test, ctx->pd->tables[1], NULL);
+}
+
+static struct kunit_case psb_mmu_test_cases[] = {
+       KUNIT_CASE(psb_mmu_zero_pages_test),
+       KUNIT_CASE(psb_mmu_zero_pages_existing_test),
+       KUNIT_CASE(psb_mmu_range_test),
+       KUNIT_CASE(psb_mmu_last_page_test),
+       KUNIT_CASE(psb_mmu_directory_boundary_test),
+       KUNIT_CASE(psb_mmu_collision_rollback_test),
+       KUNIT_CASE(psb_mmu_tiled_rollback_test),
+       KUNIT_CASE(psb_mmu_pfn_range_test),
+       KUNIT_CASE(psb_mmu_pfn_rollback_test),
+       KUNIT_CASE(psb_mmu_remove_hole_test),
+       {}
+};
+
+static struct kunit_suite psb_mmu_test_suite = {
+       .name = "psb_mmu",
+       .init = psb_mmu_test_init,
+       .exit = psb_mmu_test_exit,
+       .test_cases = psb_mmu_test_cases,
+};
+
+kunit_test_suite(psb_mmu_test_suite);

Reply via email to