drm/test: add a test suite for GEM objects backed by shmem
Subsystems (3)
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
@@ -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
@@ -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
Maxime Ripard
maintainerHi Marco,
Quoted 16 lines · Marco Pagani
This patch introduces an initial KUnit test suite for GEM objects backed by shmem buffers.
Signed-off-by Marco Pagani <[email protected]>--- 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.cdrivers/gpu/drm/Kconfig +0
-0
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
-0default KUNIT_ALL_TESTS help This builds unit tests for DRM. This option is not useful fordrivers/gpu/drm/tests/Makefile +0
-0
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
-0CFLAGS_drm_mm_test.o := $(DISABLE_STRUCTLEAK_PLUGIN)drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +35
-0@@ -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
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.
Signed-off-by Marco Pagani <[email protected]>--- 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.cdrivers/gpu/drm/Kconfig +0
-0drivers/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_HELPERI know that
DRM_EXECalready stands out, but these should be ordered alphabetically, so it should be beforeDRM_KUNIT_TEST_HELPERS.
Quoted 17 lines
Quoted 8 lines
drivers/gpu/drm/Kconfig +0
-0default KUNIT_ALL_TESTS help This builds unit tests for DRM. This option is not useful fordrivers/gpu/drm/tests/Makefile +0
-0drivers/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.oDitto.
Right, I'll sort them alphabetically for v2.
Quoted 57 lines
Quoted 42 lines
drivers/gpu/drm/tests/Makefile +0
-0CFLAGS_drm_mm_test.o := $(DISABLE_STRUCTLEAK_PLUGIN)drivers/gpu/drm/tests/drm_gem_shmem_test.c new file +35
-0@@ -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_tablesucceeds and is properly initializedFeel 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_actionto 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
Maxime Ripard
maintainerHi,
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_actionto clean up and avoid that whole discussionYou 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
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_actionto clean up and avoid that whole discussionYou 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_tableanddrm_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 callsg_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 calldrm_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_freemake 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_freewill free the structsg_tableitself */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
Maxime Ripard
maintainerQuoted 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_actionto clean up and avoid that whole discussionYou 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_tableanddrm_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 callsg_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 calldrm_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_freemake 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_freewill free the structsg_tableitself */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