Skip to contentSkip to conversation

drm/test: add a test suite for GEM objects backed by shmem

RFC PATCH Superseded Marco Pagani 2 participants 6 messages Oct 23, 2023 – Nov 6, 2023

Subsystems (3)

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 drm/test: add a test suite for GEM objects backed by shmem

This patch introduces an initial KUnit test suite for GEM objects backed by shmem buffers.

---
 drivers/gpu/drm/Kconfig                    |   1 +
 drivers/gpu/drm/tests/Makefile             |   3 +-
 drivers/gpu/drm/tests/drm_gem_shmem_test.c | 303 +++++++++++++++++++++
 3 files changed, 306 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/tests/drm_gem_shmem_test.c
drivers/gpu/drm/Kconfig +1 -0
index 3eee8636f847..f0a77e3e04d7 100644
@@ -84,6 +84,7 @@ config DRM_KUNIT_TEST
 	select DRM_EXPORT_FOR_TESTS if m
 	select DRM_KUNIT_TEST_HELPERS
 	select DRM_EXEC
+	select DRM_GEM_SHMEM_HELPER
 	default KUNIT_ALL_TESTS
 	help
 	  This builds unit tests for DRM. This option is not useful for
drivers/gpu/drm/tests/Makefile +2 -1
index ba7baa622675..b8227aab369e 100644
@@ -18,6 +18,7 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \
 	drm_plane_helper_test.o \
 	drm_probe_helper_test.o \
 	drm_rect_test.o	\
-	drm_exec_test.o
+	drm_exec_test.o \
+	drm_gem_shmem_test.o
 
 CFLAGS_drm_mm_test.o := $(DISABLE_STRUCTLEAK_PLUGIN)
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +303 -0

303 lines not on this page · raw message

base-commit: 3f5ba636d6987ddffeaa056dea1c524da63912f3

Signature · 1 line
2.41.0
maintainer
#1 lore raw

Hi Marco,

Quoted 16 lines · Marco Pagani

This patch introduces an initial KUnit test suite for GEM objects backed by shmem buffers.

---
 drivers/gpu/drm/Kconfig                    |   1 +
 drivers/gpu/drm/tests/Makefile             |   3 +-
 drivers/gpu/drm/tests/drm_gem_shmem_test.c | 303 +++++++++++++++++++++
 3 files changed, 306 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/tests/drm_gem_shmem_test.c
drivers/gpu/drm/Kconfig +0 -0
index 3eee8636f847..f0a77e3e04d7 100644

drivers/gpu/drm/Kconfig config DRM_KUNIT_TEST · line 87

Quoted 4 lines
drivers/gpu/drm/Kconfig +1 -0
@@ -84,6 +84,7 @@ config DRM_KUNIT_TEST
 	select DRM_EXPORT_FOR_TESTS if m
 	select DRM_KUNIT_TEST_HELPERS
 	select DRM_EXEC
+	select DRM_GEM_SHMEM_HELPER

I know that DRM_EXEC already stands out, but these should be ordered alphabetically, so it should be before DRM_KUNIT_TEST_HELPERS.

Quoted 8 lines
drivers/gpu/drm/Kconfig +0 -0
 	default KUNIT_ALL_TESTS
 	help
 	  This builds unit tests for DRM. This option is not useful for
drivers/gpu/drm/tests/Makefile +0 -0
index ba7baa622675..b8227aab369e 100644

drivers/gpu/drm/tests/Makefile obj-$(CONFIG_DRM_KUNIT_TEST) += \ · line 22

Quoted 6 lines
drivers/gpu/drm/tests/Makefile +2 -1
@@ -18,6 +18,7 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \
 	drm_plane_helper_test.o \
 	drm_probe_helper_test.o \
 	drm_rect_test.o	\
-	drm_exec_test.o
+	drm_exec_test.o \
+	drm_gem_shmem_test.o

Ditto.

Quoted 42 lines
drivers/gpu/drm/tests/Makefile +0 -0
 CFLAGS_drm_mm_test.o := $(DISABLE_STRUCTLEAK_PLUGIN)
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +35 -0
new file mode 100644
index 000000000000..0bf6727f08d2
@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit test suite for GEM objects backed by shmem buffers
+ *
+ * Copyright (C) 2023 Red Hat, Inc.
+ *
+ * Author: Marco Pagani <[email protected]>
+ */
+
+#include <linux/dma-buf.h>
+#include <linux/iosys-map.h>
+#include <linux/sizes.h>
+
+#include <kunit/test.h>
+
+#include <drm/drm_device.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_gem.h>
+#include <drm/drm_gem_shmem_helper.h>
+#include <drm/drm_kunit_helpers.h>
+
+#define TEST_SIZE		SZ_1M
+#define TEST_BYTE		0xae
+
+struct fake_dev {
+	struct drm_device drm_dev;
+	struct device *dev;
+};
+
+/* Test creating a shmem GEM object */
+static void drm_gem_shmem_test_obj_create(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 45

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_EQ(test, shmem->base.size, TEST_SIZE);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->base.filp);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->base.funcs);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test creating a private shmem GEM object from a scatter/gather table */

Thanks for documenting those tests. I believe we should also document what we expect from the test: should the test succeed? fail? if it fails, what is the cause of failure?

Based on the following test, I think something like the following would be good:

Test that creating a private shmem GEM object from a previously allocated sg_table succeeds and is properly initialized

Feel free to change it to something else if you find something missing.

Quoted 28 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +28 -0
+static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct drm_gem_object *gem_obj;
+	struct dma_buf buf_mock;
+	struct dma_buf_attachment attach_mock;
+	struct sg_table *sgt;
+	char *buf;
+	int ret;
+
+	/* Create a mock scatter/gather table */
+	buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, buf);
+
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, sgt);
+
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	sg_init_one(sgt->sgl, buf, TEST_SIZE);
+
+	/* Init a mock DMA-BUF */
+	buf_mock.size = TEST_SIZE;
+	attach_mock.dmabuf = &buf_mock;
+
+	gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 83

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	KUNIT_ASSERT_EQ(test, gem_obj->size, TEST_SIZE);
+	KUNIT_ASSERT_NULL(test, gem_obj->filp);
+	KUNIT_ASSERT_NOT_NULL(test, gem_obj->funcs);
+
+	shmem = to_drm_gem_shmem_obj(gem_obj);
+	KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}

KUNIT_ASSERT_* will stop the execution of the test on failure, you should probably use a bit more of KUNIT_EXPECT_* calls otherwise you'll leak resources.

You also probably want to use a kunit_action to clean up and avoid that whole discussion

Quoted 189 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +189 -0
+
+/* Test pinning backing pages */
+static void drm_gem_shmem_test_pin_pages(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	int i, ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 0);
+
+	ret = drm_gem_shmem_pin(shmem);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 1);
+
+	for (i = 0; i < (shmem->base.size >> PAGE_SHIFT); i++)
+		KUNIT_ASSERT_NOT_NULL(test, shmem->pages[i]);
+
+	drm_gem_shmem_unpin(shmem);
+	KUNIT_ASSERT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 0);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test creating a virtual mapping */
+static void drm_gem_shmem_test_vmap(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct iosys_map map;
+	int ret, i;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 0);
+
+	ret = drm_gem_shmem_vmap(shmem, &map);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 1);
+	KUNIT_ASSERT_FALSE(test, iosys_map_is_null(&map));
+
+	iosys_map_memset(&map, 0, TEST_BYTE, TEST_SIZE);
+	for (i = 0; i < TEST_SIZE; i++)
+		KUNIT_ASSERT_EQ(test, iosys_map_rd(&map, i, u8), TEST_BYTE);
+
+	drm_gem_shmem_vunmap(shmem, &map);
+	KUNIT_ASSERT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 0);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test exporting a scatter/gather table */
+static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	struct scatterlist *sg;
+	unsigned int si, len = 0;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	ret = drm_gem_shmem_pin(shmem);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+
+	sgt = drm_gem_shmem_get_sg_table(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+	KUNIT_ASSERT_NULL(test, shmem->sgt);
+
+	for_each_sgtable_sg(sgt, sg, si) {
+		KUNIT_ASSERT_NOT_NULL(test, sg);
+		len += sg->length;
+	}
+	KUNIT_ASSERT_GE(test, len, TEST_SIZE);
+
+	kfree(sgt);
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test exporting a scatter/gather pinned table for PRIME */
+static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	struct scatterlist *sg;
+	unsigned int si, len = 0;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	sgt = drm_gem_shmem_get_pages_sgt(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+	KUNIT_ASSERT_PTR_EQ(test, sgt, shmem->sgt);
+
+	for_each_sgtable_sg(sgt, sg, si) {
+		KUNIT_ASSERT_NOT_NULL(test, sg);
+		len += sg->length;
+	}
+	KUNIT_ASSERT_GE(test, len, TEST_SIZE);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test updating madvise status */
+static void drm_gem_shmem_test_madvise(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_EQ(test, shmem->madv, 0);
+
+	ret = drm_gem_shmem_madvise(shmem, 1);
+	KUNIT_ASSERT_TRUE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, 1);
+
+	ret = drm_gem_shmem_madvise(shmem, -1);
+	KUNIT_ASSERT_FALSE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, -1);
+
+	ret = drm_gem_shmem_madvise(shmem, 0);
+	KUNIT_ASSERT_FALSE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, -1);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test purging */
+static void drm_gem_shmem_test_purge(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	ret = drm_gem_shmem_is_purgeable(shmem);
+	KUNIT_ASSERT_FALSE(test, ret);
+
+	ret = drm_gem_shmem_madvise(shmem, 1);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	sgt = drm_gem_shmem_get_pages_sgt(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+
+	ret = drm_gem_shmem_is_purgeable(shmem);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	drm_gem_shmem_purge(shmem);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	drm_gem_shmem_free(shmem);
+}
+
+static int drm_gem_shmem_test_init(struct kunit *test)
+{
+	struct fake_dev *fdev;
+	struct device *dev;
+
+	/* Allocate a parent device */
+	dev = drm_kunit_helper_alloc_device(test);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
+
+	/*
+	 * The DRM core will automatically initialize the GEM core and create
+	 * a DRM Memory Manager object which provides an address space pool
+	 * for GEM objects allocation.
+	 */
+	fdev = drm_kunit_helper_alloc_drm_device(test, dev, struct fake_dev,
+						 drm_dev, DRIVER_GEM);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fdev);
+
+	fdev->dev = dev;
+	test->priv = fdev;

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 282

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+
+	return 0;
+}
+
+static void drm_gem_shmem_test_exit(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+
+	drm_kunit_helper_free_device(test, fdev->dev);
+}

You don't need to call drm_kunit_helper_free_device() anymore

Maxime

#2 lore raw
Quoted 27 lines · Maxime Ripard

Hi Marco,

Quoted 16 lines · Marco Pagani

This patch introduces an initial KUnit test suite for GEM objects backed by shmem buffers.

---
 drivers/gpu/drm/Kconfig                    |   1 +
 drivers/gpu/drm/tests/Makefile             |   3 +-
 drivers/gpu/drm/tests/drm_gem_shmem_test.c | 303 +++++++++++++++++++++
 3 files changed, 306 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/tests/drm_gem_shmem_test.c
drivers/gpu/drm/Kconfig +0 -0
index 3eee8636f847..f0a77e3e04d7 100644

drivers/gpu/drm/Kconfig config DRM_KUNIT_TEST · line 87

Quoted 4 lines
drivers/gpu/drm/Kconfig +1 -0
@@ -84,6 +84,7 @@ config DRM_KUNIT_TEST
 	select DRM_EXPORT_FOR_TESTS if m
 	select DRM_KUNIT_TEST_HELPERS
 	select DRM_EXEC
+	select DRM_GEM_SHMEM_HELPER

I know that DRM_EXEC already stands out, but these should be ordered alphabetically, so it should be before DRM_KUNIT_TEST_HELPERS.

Quoted 17 lines
Quoted 8 lines
drivers/gpu/drm/Kconfig +0 -0
 	default KUNIT_ALL_TESTS
 	help
 	  This builds unit tests for DRM. This option is not useful for
drivers/gpu/drm/tests/Makefile +0 -0
index ba7baa622675..b8227aab369e 100644

drivers/gpu/drm/tests/Makefile obj-$(CONFIG_DRM_KUNIT_TEST) += \ · line 22

Quoted 6 lines
drivers/gpu/drm/tests/Makefile +2 -1
@@ -18,6 +18,7 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \
 	drm_plane_helper_test.o \
 	drm_probe_helper_test.o \
 	drm_rect_test.o	\
-	drm_exec_test.o
+	drm_exec_test.o \
+	drm_gem_shmem_test.o

Ditto.

Right, I'll sort them alphabetically for v2.

Quoted 57 lines
Quoted 42 lines
drivers/gpu/drm/tests/Makefile +0 -0
 CFLAGS_drm_mm_test.o := $(DISABLE_STRUCTLEAK_PLUGIN)
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +35 -0
new file mode 100644
index 000000000000..0bf6727f08d2
@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit test suite for GEM objects backed by shmem buffers
+ *
+ * Copyright (C) 2023 Red Hat, Inc.
+ *
+ * Author: Marco Pagani <[email protected]>
+ */
+
+#include <linux/dma-buf.h>
+#include <linux/iosys-map.h>
+#include <linux/sizes.h>
+
+#include <kunit/test.h>
+
+#include <drm/drm_device.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_gem.h>
+#include <drm/drm_gem_shmem_helper.h>
+#include <drm/drm_kunit_helpers.h>
+
+#define TEST_SIZE		SZ_1M
+#define TEST_BYTE		0xae
+
+struct fake_dev {
+	struct drm_device drm_dev;
+	struct device *dev;
+};
+
+/* Test creating a shmem GEM object */
+static void drm_gem_shmem_test_obj_create(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 45

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_EQ(test, shmem->base.size, TEST_SIZE);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->base.filp);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->base.funcs);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test creating a private shmem GEM object from a scatter/gather table */

Thanks for documenting those tests. I believe we should also document what we expect from the test: should the test succeed? fail? if it fails, what is the cause of failure?

Quoted 8 lines

Based on the following test, I think something like the following would be good:

Test that creating a private shmem GEM object from a previously allocated sg_table succeeds and is properly initialized

Feel free to change it to something else if you find something missing.

Sounds good to me. I'll improve the documentation for v2.

Quoted 43 lines
Quoted 28 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +28 -0
+static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct drm_gem_object *gem_obj;
+	struct dma_buf buf_mock;
+	struct dma_buf_attachment attach_mock;
+	struct sg_table *sgt;
+	char *buf;
+	int ret;
+
+	/* Create a mock scatter/gather table */
+	buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, buf);
+
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, sgt);
+
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	sg_init_one(sgt->sgl, buf, TEST_SIZE);
+
+	/* Init a mock DMA-BUF */
+	buf_mock.size = TEST_SIZE;
+	attach_mock.dmabuf = &buf_mock;
+
+	gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 83

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	KUNIT_ASSERT_EQ(test, gem_obj->size, TEST_SIZE);
+	KUNIT_ASSERT_NULL(test, gem_obj->filp);
+	KUNIT_ASSERT_NOT_NULL(test, gem_obj->funcs);
+
+	shmem = to_drm_gem_shmem_obj(gem_obj);
+	KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}

KUNIT_ASSERT_* will stop the execution of the test on failure, you should probably use a bit more of KUNIT_EXPECT_* calls otherwise you'll leak resources.

Quoted 3 lines

You also probably want to use a kunit_action to clean up and avoid that whole discussion

You are right. I slightly prefer using KUnit expectations (unless actions are strictly necessary) since I feel using actions makes test cases a bit less straightforward to understand. Is this okay for you?

Quoted 202 lines
Quoted 189 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +189 -0
+
+/* Test pinning backing pages */
+static void drm_gem_shmem_test_pin_pages(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	int i, ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 0);
+
+	ret = drm_gem_shmem_pin(shmem);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 1);
+
+	for (i = 0; i < (shmem->base.size >> PAGE_SHIFT); i++)
+		KUNIT_ASSERT_NOT_NULL(test, shmem->pages[i]);
+
+	drm_gem_shmem_unpin(shmem);
+	KUNIT_ASSERT_NULL(test, shmem->pages);
+	KUNIT_ASSERT_EQ(test, shmem->pages_use_count, 0);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test creating a virtual mapping */
+static void drm_gem_shmem_test_vmap(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct iosys_map map;
+	int ret, i;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 0);
+
+	ret = drm_gem_shmem_vmap(shmem, &map);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	KUNIT_ASSERT_NOT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 1);
+	KUNIT_ASSERT_FALSE(test, iosys_map_is_null(&map));
+
+	iosys_map_memset(&map, 0, TEST_BYTE, TEST_SIZE);
+	for (i = 0; i < TEST_SIZE; i++)
+		KUNIT_ASSERT_EQ(test, iosys_map_rd(&map, i, u8), TEST_BYTE);
+
+	drm_gem_shmem_vunmap(shmem, &map);
+	KUNIT_ASSERT_NULL(test, shmem->vaddr);
+	KUNIT_ASSERT_EQ(test, shmem->vmap_use_count, 0);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test exporting a scatter/gather table */
+static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	struct scatterlist *sg;
+	unsigned int si, len = 0;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	ret = drm_gem_shmem_pin(shmem);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+
+	sgt = drm_gem_shmem_get_sg_table(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+	KUNIT_ASSERT_NULL(test, shmem->sgt);
+
+	for_each_sgtable_sg(sgt, sg, si) {
+		KUNIT_ASSERT_NOT_NULL(test, sg);
+		len += sg->length;
+	}
+	KUNIT_ASSERT_GE(test, len, TEST_SIZE);
+
+	kfree(sgt);
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test exporting a scatter/gather pinned table for PRIME */
+static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	struct scatterlist *sg;
+	unsigned int si, len = 0;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	sgt = drm_gem_shmem_get_pages_sgt(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+	KUNIT_ASSERT_PTR_EQ(test, sgt, shmem->sgt);
+
+	for_each_sgtable_sg(sgt, sg, si) {
+		KUNIT_ASSERT_NOT_NULL(test, sg);
+		len += sg->length;
+	}
+	KUNIT_ASSERT_GE(test, len, TEST_SIZE);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test updating madvise status */
+static void drm_gem_shmem_test_madvise(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+	KUNIT_ASSERT_EQ(test, shmem->madv, 0);
+
+	ret = drm_gem_shmem_madvise(shmem, 1);
+	KUNIT_ASSERT_TRUE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, 1);
+
+	ret = drm_gem_shmem_madvise(shmem, -1);
+	KUNIT_ASSERT_FALSE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, -1);
+
+	ret = drm_gem_shmem_madvise(shmem, 0);
+	KUNIT_ASSERT_FALSE(test, ret);
+	KUNIT_ASSERT_EQ(test, shmem->madv, -1);
+
+	drm_gem_shmem_free(shmem);
+}
+
+/* Test purging */
+static void drm_gem_shmem_test_purge(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	int ret;
+
+	shmem = drm_gem_shmem_create(&fdev->drm_dev, TEST_SIZE);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
+
+	ret = drm_gem_shmem_is_purgeable(shmem);
+	KUNIT_ASSERT_FALSE(test, ret);
+
+	ret = drm_gem_shmem_madvise(shmem, 1);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	sgt = drm_gem_shmem_get_pages_sgt(shmem);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
+
+	ret = drm_gem_shmem_is_purgeable(shmem);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	drm_gem_shmem_purge(shmem);
+	KUNIT_ASSERT_TRUE(test, ret);
+
+	drm_gem_shmem_free(shmem);
+}
+
+static int drm_gem_shmem_test_init(struct kunit *test)
+{
+	struct fake_dev *fdev;
+	struct device *dev;
+
+	/* Allocate a parent device */
+	dev = drm_kunit_helper_alloc_device(test);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
+
+	/*
+	 * The DRM core will automatically initialize the GEM core and create
+	 * a DRM Memory Manager object which provides an address space pool
+	 * for GEM objects allocation.
+	 */
+	fdev = drm_kunit_helper_alloc_drm_device(test, dev, struct fake_dev,
+						 drm_dev, DRIVER_GEM);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fdev);
+
+	fdev->dev = dev;
+	test->priv = fdev;

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 282

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+
+	return 0;
+}
+
+static void drm_gem_shmem_test_exit(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+
+	drm_kunit_helper_free_device(test, fdev->dev);
+}

You don't need to call drm_kunit_helper_free_device() anymore

Quoted 1 line

Maxime

Right. Initially, I accidentally used an older tree that did not include commit 4f2b0b583baa4. I'll remove the whole exit function for v2.

Thanks,
Marco

maintainer
#3 lore raw

Hi,

Quoted 43 lines · Marco Pagani
Quoted 43 lines
Quoted 28 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +28 -0
+static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct drm_gem_object *gem_obj;
+	struct dma_buf buf_mock;
+	struct dma_buf_attachment attach_mock;
+	struct sg_table *sgt;
+	char *buf;
+	int ret;
+
+	/* Create a mock scatter/gather table */
+	buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, buf);
+
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, sgt);
+
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	sg_init_one(sgt->sgl, buf, TEST_SIZE);
+
+	/* Init a mock DMA-BUF */
+	buf_mock.size = TEST_SIZE;
+	attach_mock.dmabuf = &buf_mock;
+
+	gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 83

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	KUNIT_ASSERT_EQ(test, gem_obj->size, TEST_SIZE);
+	KUNIT_ASSERT_NULL(test, gem_obj->filp);
+	KUNIT_ASSERT_NOT_NULL(test, gem_obj->funcs);
+
+	shmem = to_drm_gem_shmem_obj(gem_obj);
+	KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}

KUNIT_ASSERT_* will stop the execution of the test on failure, you should probably use a bit more of KUNIT_EXPECT_* calls otherwise you'll leak resources.

Quoted 7 lines
Quoted 3 lines

You also probably want to use a kunit_action to clean up and avoid that whole discussion

You are right. I slightly prefer using KUnit expectations (unless actions are strictly necessary) since I feel using actions makes test cases a bit less straightforward to understand. Is this okay for you?

I disagree. Actions make it easier to reason about, even when comparing assertion vs expectation

Like, for the call to sg_alloc_table and drm_gem_shmem_prime_import_sg_table(), the reasonable use of assert vs expect would be something like:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

/*
* Here, it's already not super clear whether you want to expect vs
* assert. expect will make you handle the failure case later, assert will
* force you to call kfree on sgt. Both kind of suck in their own ways. */

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

/*
* If the assert fails, we forgot to call sg_free_table(sgt) and kfree(sgt). */

KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE);
KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

/*
* And here we have to handle the case where the expectation was wrong,
* but the test still continued.
*/

But if you're not using an action, you still have to call kfree(sgt), which means that you might still

shmem = to_drm_gem_shmem_obj(gem_obj);
KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);

/*
* If the assertion fails, we now have to call drm_gem_shmem_free(shmem) */

/* The scatter/gather table is freed by drm_gem_shmem_free */ drm_gem_shmem_free(shmem);

/* everything's fine now */

The semantics around drm_gem_shmem_free make it a bit convoluted, but doing it using goto/labels, plus handling the assertions and error reporting would be difficult.

Using actions, we have:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);
KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE); KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

/* drm_gem_shmem_free will free the struct sg_table itself */ kunit_remove_action(test, sg_free_table_wrapper, sgt); kunit_remove_action(test, kfree_wrapper, sgt);

shmem = to_drm_gem_shmem_obj(gem_obj);
KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);

ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem); KUNIT_ASSERT_EQ(test, ret, 0);

The last one is arguable, but for the previous ones it makes error handling much more convenient and easy to reason about.

The wrappers are also a bit inconvenient to use, but it's mostly there to avoid a compiler warning at the moment.

This patch will help hopefully:
https://lore.kernel.org/linux-kselftest/[email protected]/

Maxime

#4 lore raw
Quoted 132 lines · Maxime Ripard

Hi,

Quoted 43 lines · Marco Pagani
Quoted 43 lines
Quoted 28 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +28 -0
+static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct drm_gem_object *gem_obj;
+	struct dma_buf buf_mock;
+	struct dma_buf_attachment attach_mock;
+	struct sg_table *sgt;
+	char *buf;
+	int ret;
+
+	/* Create a mock scatter/gather table */
+	buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, buf);
+
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, sgt);
+
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	sg_init_one(sgt->sgl, buf, TEST_SIZE);
+
+	/* Init a mock DMA-BUF */
+	buf_mock.size = TEST_SIZE;
+	attach_mock.dmabuf = &buf_mock;
+
+	gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 83

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	KUNIT_ASSERT_EQ(test, gem_obj->size, TEST_SIZE);
+	KUNIT_ASSERT_NULL(test, gem_obj->filp);
+	KUNIT_ASSERT_NOT_NULL(test, gem_obj->funcs);
+
+	shmem = to_drm_gem_shmem_obj(gem_obj);
+	KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}

KUNIT_ASSERT_* will stop the execution of the test on failure, you should probably use a bit more of KUNIT_EXPECT_* calls otherwise you'll leak resources.

Quoted 7 lines
Quoted 3 lines

You also probably want to use a kunit_action to clean up and avoid that whole discussion

You are right. I slightly prefer using KUnit expectations (unless actions are strictly necessary) since I feel using actions makes test cases a bit less straightforward to understand. Is this okay for you?

I disagree. Actions make it easier to reason about, even when comparing assertion vs expectation

Like, for the call to sg_alloc_table and drm_gem_shmem_prime_import_sg_table(), the reasonable use of assert vs expect would be something like:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

/*
* Here, it's already not super clear whether you want to expect vs
* assert. expect will make you handle the failure case later, assert will
* force you to call kfree on sgt. Both kind of suck in their own ways. */

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

/*
* If the assert fails, we forgot to call sg_free_table(sgt) and kfree(sgt). */

KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE);
KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

/*
* And here we have to handle the case where the expectation was wrong,
* but the test still continued.
*/

But if you're not using an action, you still have to call kfree(sgt), which means that you might still

shmem = to_drm_gem_shmem_obj(gem_obj);
KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);

/*
* If the assertion fails, we now have to call drm_gem_shmem_free(shmem) */

/* The scatter/gather table is freed by drm_gem_shmem_free */ drm_gem_shmem_free(shmem);

/* everything's fine now */

The semantics around drm_gem_shmem_free make it a bit convoluted, but doing it using goto/labels, plus handling the assertions and error reporting would be difficult.

Using actions, we have:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);
KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE); KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

Quoted 3 lines

/* drm_gem_shmem_free will free the struct sg_table itself */ kunit_remove_action(test, sg_free_table_wrapper, sgt); kunit_remove_action(test, kfree_wrapper, sgt);

I agree that using actions makes error handling cleaner. However, I still have some concerns about the additional complexity that actions introduce. For instance, I feel these two lines make the testing harness more complex without asserting any additional property of the component under test.

In some sense, I wonder if it is worth worrying about memory leaks when a test case fails. At that point, the system is already in an inconsistent state due to a bug in the component under test, so it is unsafe to continue anyway.

Quoted 10 lines

shmem = to_drm_gem_shmem_obj(gem_obj);
KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);

ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem); KUNIT_ASSERT_EQ(test, ret, 0);

The last one is arguable, but for the previous ones it makes error handling much more convenient and easy to reason about.

Quoted 7 lines

The wrappers are also a bit inconvenient to use, but it's mostly there to avoid a compiler warning at the moment.

This patch will help hopefully:
https://lore.kernel.org/linux-kselftest/[email protected]/

Maxime

Thanks,
Marco

maintainer
#5 lore raw
Quoted 131 lines · Marco Pagani
Quoted 130 lines · Maxime Ripard
Quoted 43 lines · Marco Pagani
Quoted 43 lines
Quoted 28 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +28 -0
+static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
+{
+	struct fake_dev *fdev = test->priv;
+	struct drm_gem_shmem_object *shmem;
+	struct drm_gem_object *gem_obj;
+	struct dma_buf buf_mock;
+	struct dma_buf_attachment attach_mock;
+	struct sg_table *sgt;
+	char *buf;
+	int ret;
+
+	/* Create a mock scatter/gather table */
+	buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, buf);
+
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, sgt);
+
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	sg_init_one(sgt->sgl, buf, TEST_SIZE);
+
+	/* Init a mock DMA-BUF */
+	buf_mock.size = TEST_SIZE;
+	attach_mock.dmabuf = &buf_mock;
+
+	gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

drivers/gpu/drm/tests/drm_gem_shmem_test.c line 83

Quoted 10 lines
drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +10 -0
+	KUNIT_ASSERT_EQ(test, gem_obj->size, TEST_SIZE);
+	KUNIT_ASSERT_NULL(test, gem_obj->filp);
+	KUNIT_ASSERT_NOT_NULL(test, gem_obj->funcs);
+
+	shmem = to_drm_gem_shmem_obj(gem_obj);
+	KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);
+
+	/* The scatter/gather table is freed by drm_gem_shmem_free */
+	drm_gem_shmem_free(shmem);
+}

KUNIT_ASSERT_* will stop the execution of the test on failure, you should probably use a bit more of KUNIT_EXPECT_* calls otherwise you'll leak resources.

Quoted 7 lines
Quoted 3 lines

You also probably want to use a kunit_action to clean up and avoid that whole discussion

You are right. I slightly prefer using KUnit expectations (unless actions are strictly necessary) since I feel using actions makes test cases a bit less straightforward to understand. Is this okay for you?

I disagree. Actions make it easier to reason about, even when comparing assertion vs expectation

Like, for the call to sg_alloc_table and drm_gem_shmem_prime_import_sg_table(), the reasonable use of assert vs expect would be something like:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

/*
* Here, it's already not super clear whether you want to expect vs
* assert. expect will make you handle the failure case later, assert will
* force you to call kfree on sgt. Both kind of suck in their own ways. */

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);

/*
* If the assert fails, we forgot to call sg_free_table(sgt) and kfree(sgt). */

KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE);
KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

/*
* And here we have to handle the case where the expectation was wrong,
* but the test still continued.
*/

But if you're not using an action, you still have to call kfree(sgt), which means that you might still

shmem = to_drm_gem_shmem_obj(gem_obj);
KUNIT_ASSERT_PTR_EQ(test, shmem->sgt, sgt);

/*
* If the assertion fails, we now have to call drm_gem_shmem_free(shmem) */

/* The scatter/gather table is freed by drm_gem_shmem_free */ drm_gem_shmem_free(shmem);

/* everything's fine now */

The semantics around drm_gem_shmem_free make it a bit convoluted, but doing it using goto/labels, plus handling the assertions and error reporting would be difficult.

Using actions, we have:

sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sgt);

ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
KUNIT_ASSERT_EQ(test, ret, 0);

ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt); KUNIT_ASSERT_EQ(test, ret, 0);

sg_init_one(sgt->sgl, buf, TEST_SIZE);

gem_obj = drm_gem_shmem_prime_import_sg_table(&fdev->drm_dev, &attach_mock, sgt); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);
KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE); KUNIT_EXPECT_NULL(test, gem_obj->filp);
KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);

Quoted 8 lines
Quoted 3 lines

/* drm_gem_shmem_free will free the struct sg_table itself */ kunit_remove_action(test, sg_free_table_wrapper, sgt); kunit_remove_action(test, kfree_wrapper, sgt);

I agree that using actions makes error handling cleaner. However, I still have some concerns about the additional complexity that actions introduce. For instance, I feel these two lines make the testing harness more complex without asserting any additional property of the component under test.

If anything, the API makes it more difficult to deal with. It would actually be harder/messier to handle without an action.

Quoted 4 lines

In some sense, I wonder if it is worth worrying about memory leaks when a test case fails. At that point, the system is already in an inconsistent state due to a bug in the component under test, so it is unsafe to continue anyway.

I guess the larger issue is: once that code will be merged, we're going to have patches to convert to actions because they make it nicer and fix a couple of issues anyway.

So, if it's still the state we're going to end up in, why not doing it right from the beginning?

Maxime