drivers/gpu/drm/tests/drm_gem_shmem_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * KUnit test suite for GEM objects backed by shmem buffers
   4  *
   5  * Copyright (C) 2023 Red Hat, Inc.
   6  *
   7  * Author: Marco Pagani <[email protected]>
   8  */
   9
  10 #include <linux/dma-buf.h>
  11 #include <linux/iosys-map.h>
  12 #include <linux/sizes.h>
  13
  14 #include <kunit/test.h>
  15
  16 #include <drm/drm_device.h>
  17 #include <drm/drm_drv.h>
  18 #include <drm/drm_gem.h>
  19 #include <drm/drm_gem_shmem_helper.h>
  20 #include <drm/drm_kunit_helpers.h>
  21
  22 #define TEST_SIZE               SZ_1M
  23 #define TEST_BYTE               0xae
  24
  25 /*
  26  * Wrappers to avoid an explicit type casting when passing action
  27  * functions to kunit_add_action().
  28  */
  29 static void kfree_wrapper(void *ptr)
  30 {
  31         const void *obj = ptr;
  32
  33         kfree(obj);
  34 }
  35
  36 static void sg_free_table_wrapper(void *ptr)
  37 {
  38         struct sg_table *sgt = ptr;
  39
  40         sg_free_table(sgt);
  41 }
  42
  43 static void drm_gem_shmem_free_wrapper(void *ptr)
  44 {
  45         struct drm_gem_shmem_object *shmem = ptr;
  46
  47         drm_gem_shmem_free(shmem);
  48 }
  49
  50 /*
  51  * Test creating a shmem GEM object backed by shmem buffer. The test
  52  * case succeeds if the GEM object is successfully allocated with the
  53  * shmem file node and object functions attributes set, and the size
  54  * attribute is equal to the correct size.
  55  */
  56 static void drm_gem_shmem_test_obj_create(struct kunit *test)
  57 {
  58         struct drm_device *drm_dev = test->priv;
  59         struct drm_gem_shmem_object *shmem;
  60
  61         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
  62         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
  63         KUNIT_EXPECT_EQ(test, shmem->base.size, TEST_SIZE);
  64         KUNIT_EXPECT_NOT_NULL(test, shmem->base.filp);
  65         KUNIT_EXPECT_NOT_NULL(test, shmem->base.funcs);
  66
  67         drm_gem_shmem_free(shmem);
  68 }
  69
  70 /*
  71  * Test creating a shmem GEM object from a scatter/gather table exported
  72  * via a DMA-BUF. The test case succeed if the GEM object is successfully
  73  * created with the shmem file node attribute equal to NULL and the sgt
  74  * attribute pointing to the scatter/gather table that has been imported.
  75  */
  76 static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
  77 {
  78         struct drm_device *drm_dev = test->priv;
  79         struct drm_gem_shmem_object *shmem;
  80         struct drm_gem_object *gem_obj;
  81         struct dma_buf buf_mock;
  82         struct dma_buf_attachment attach_mock;
  83         struct sg_table *sgt;
  84         char *buf;
  85         int ret;
  86
  87         /* Create a mock scatter/gather table */
  88         buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
  89         KUNIT_ASSERT_NOT_NULL(test, buf);
  90
  91         sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
  92         KUNIT_ASSERT_NOT_NULL(test, sgt);
  93
  94         ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt);
  95         KUNIT_ASSERT_EQ(test, ret, 0);
  96
  97         ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
  98         KUNIT_ASSERT_EQ(test, ret, 0);
  99
 100         ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt);
 101         KUNIT_ASSERT_EQ(test, ret, 0);
 102
 103         sg_init_one(sgt->sgl, buf, TEST_SIZE);
 104
 105         /* Init a mock DMA-BUF */
 106         buf_mock.size = TEST_SIZE;
 107         attach_mock.dmabuf = &buf_mock;
 108
 109         gem_obj = drm_gem_shmem_prime_import_sg_table(drm_dev, &attach_mock, sgt);
 110         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);
 111         KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE);
 112         KUNIT_EXPECT_NULL(test, gem_obj->filp);
 113         KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);
 114
 115         /* The scatter/gather table will be freed by drm_gem_shmem_free */
 116         kunit_remove_action(test, sg_free_table_wrapper, sgt);
 117         kunit_remove_action(test, kfree_wrapper, sgt);
 118
 119         shmem = to_drm_gem_shmem_obj(gem_obj);
 120         KUNIT_EXPECT_PTR_EQ(test, shmem->sgt, sgt);
 121
 122         drm_gem_shmem_free(shmem);
 123 }
 124
 125 /*
 126  * Test pinning backing pages for a shmem GEM object. The test case
 127  * succeeds if a suitable number of backing pages are allocated, and
 128  * the pages table counter attribute is increased by one.
 129  */
 130 static void drm_gem_shmem_test_pin_pages(struct kunit *test)
 131 {
 132         struct drm_device *drm_dev = test->priv;
 133         struct drm_gem_shmem_object *shmem;
 134         int i, ret;
 135
 136         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 137         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 138         KUNIT_EXPECT_NULL(test, shmem->pages);
 139         KUNIT_EXPECT_EQ(test, shmem->pages_use_count, 0);
 140
 141         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 142         KUNIT_ASSERT_EQ(test, ret, 0);
 143
 144         ret = drm_gem_shmem_pin(shmem);
 145         KUNIT_ASSERT_EQ(test, ret, 0);
 146         KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
 147         KUNIT_EXPECT_EQ(test, shmem->pages_use_count, 1);
 148
 149         for (i = 0; i < (shmem->base.size >> PAGE_SHIFT); i++)
 150                 KUNIT_ASSERT_NOT_NULL(test, shmem->pages[i]);
 151
 152         drm_gem_shmem_unpin(shmem);
 153         KUNIT_EXPECT_NULL(test, shmem->pages);
 154         KUNIT_EXPECT_EQ(test, shmem->pages_use_count, 0);
 155 }
 156
 157 /*
 158  * Test creating a virtual mapping for a shmem GEM object. The test
 159  * case succeeds if the backing memory is mapped and the reference
 160  * counter for virtual mapping is increased by one. Moreover, the test
 161  * case writes and then reads a test pattern over the mapped memory.
 162  */
 163 static void drm_gem_shmem_test_vmap(struct kunit *test)
 164 {
 165         struct drm_device *drm_dev = test->priv;
 166         struct drm_gem_shmem_object *shmem;
 167         struct iosys_map map;
 168         int ret, i;
 169
 170         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 171         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 172         KUNIT_EXPECT_NULL(test, shmem->vaddr);
 173         KUNIT_EXPECT_EQ(test, shmem->vmap_use_count, 0);
 174
 175         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 176         KUNIT_ASSERT_EQ(test, ret, 0);
 177
 178         ret = drm_gem_shmem_vmap(shmem, &map);
 179         KUNIT_ASSERT_EQ(test, ret, 0);
 180         KUNIT_ASSERT_NOT_NULL(test, shmem->vaddr);
 181         KUNIT_ASSERT_FALSE(test, iosys_map_is_null(&map));
 182         KUNIT_EXPECT_EQ(test, shmem->vmap_use_count, 1);
 183
 184         iosys_map_memset(&map, 0, TEST_BYTE, TEST_SIZE);
 185         for (i = 0; i < TEST_SIZE; i++)
 186                 KUNIT_EXPECT_EQ(test, iosys_map_rd(&map, i, u8), TEST_BYTE);
 187
 188         drm_gem_shmem_vunmap(shmem, &map);
 189         KUNIT_EXPECT_NULL(test, shmem->vaddr);
 190         KUNIT_EXPECT_EQ(test, shmem->vmap_use_count, 0);
 191 }
 192
 193 /*
 194  * Test exporting a scatter/gather table of pinned pages suitable for
 195  * PRIME usage from a shmem GEM object. The test case succeeds if a
 196  * scatter/gather table large enough to accommodate the backing memory
 197  * is successfully exported.
 198  */
 199 static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
 200 {
 201         struct drm_device *drm_dev = test->priv;
 202         struct drm_gem_shmem_object *shmem;
 203         struct sg_table *sgt;
 204         struct scatterlist *sg;
 205         unsigned int si, len = 0;
 206         int ret;
 207
 208         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 209         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 210
 211         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 212         KUNIT_ASSERT_EQ(test, ret, 0);
 213
 214         ret = drm_gem_shmem_pin(shmem);
 215         KUNIT_ASSERT_EQ(test, ret, 0);
 216
 217         sgt = drm_gem_shmem_get_sg_table(shmem);
 218         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
 219         KUNIT_EXPECT_NULL(test, shmem->sgt);
 220
 221         ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt);
 222         KUNIT_ASSERT_EQ(test, ret, 0);
 223
 224         for_each_sgtable_sg(sgt, sg, si) {
 225                 KUNIT_EXPECT_NOT_NULL(test, sg);
 226                 len += sg->length;
 227         }
 228
 229         KUNIT_EXPECT_GE(test, len, TEST_SIZE);
 230 }
 231
 232 /*
 233  * Test pinning pages and exporting a scatter/gather table suitable for
 234  * driver usage from a shmem GEM object. The test case succeeds if the
 235  * backing pages are pinned and a scatter/gather table large enough to
 236  * accommodate the backing memory is successfully exported.
 237  */
 238 static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
 239 {
 240         struct drm_device *drm_dev = test->priv;
 241         struct drm_gem_shmem_object *shmem;
 242         struct sg_table *sgt;
 243         struct scatterlist *sg;
 244         unsigned int si, ret, len = 0;
 245
 246         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 247         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 248
 249         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 250         KUNIT_ASSERT_EQ(test, ret, 0);
 251
 252         /* The scatter/gather table will be freed by drm_gem_shmem_free */
 253         sgt = drm_gem_shmem_get_pages_sgt(shmem);
 254         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
 255         KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
 256         KUNIT_EXPECT_EQ(test, shmem->pages_use_count, 1);
 257         KUNIT_EXPECT_PTR_EQ(test, sgt, shmem->sgt);
 258
 259         for_each_sgtable_sg(sgt, sg, si) {
 260                 KUNIT_EXPECT_NOT_NULL(test, sg);
 261                 len += sg->length;
 262         }
 263
 264         KUNIT_EXPECT_GE(test, len, TEST_SIZE);
 265 }
 266
 267 /*
 268  * Test updating the madvise state of a shmem GEM object. The test
 269  * case checks that the function for setting madv updates it only if
 270  * its current value is greater or equal than zero and returns false
 271  * if it has a negative value.
 272  */
 273 static void drm_gem_shmem_test_madvise(struct kunit *test)
 274 {
 275         struct drm_device *drm_dev = test->priv;
 276         struct drm_gem_shmem_object *shmem;
 277         int ret;
 278
 279         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 280         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 281         KUNIT_ASSERT_EQ(test, shmem->madv, 0);
 282
 283         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 284         KUNIT_ASSERT_EQ(test, ret, 0);
 285
 286         ret = drm_gem_shmem_madvise(shmem, 1);
 287         KUNIT_EXPECT_TRUE(test, ret);
 288         KUNIT_ASSERT_EQ(test, shmem->madv, 1);
 289
 290         /* Set madv to a negative value */
 291         ret = drm_gem_shmem_madvise(shmem, -1);
 292         KUNIT_EXPECT_FALSE(test, ret);
 293         KUNIT_ASSERT_EQ(test, shmem->madv, -1);
 294
 295         /* Check that madv cannot be set back to a positive value */
 296         ret = drm_gem_shmem_madvise(shmem, 0);
 297         KUNIT_EXPECT_FALSE(test, ret);
 298         KUNIT_ASSERT_EQ(test, shmem->madv, -1);
 299 }
 300
 301 /*
 302  * Test purging a shmem GEM object. First, assert that a newly created
 303  * shmem GEM object is not purgeable. Then, set madvise to a positive
 304  * value and call drm_gem_shmem_get_pages_sgt() to pin and dma-map the
 305  * backing pages. Finally, assert that the shmem GEM object is now
 306  * purgeable and purge it.
 307  */
 308 static void drm_gem_shmem_test_purge(struct kunit *test)
 309 {
 310         struct drm_device *drm_dev = test->priv;
 311         struct drm_gem_shmem_object *shmem;
 312         struct sg_table *sgt;
 313         int ret;
 314
 315         shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
 316         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
 317
 318         ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
 319         KUNIT_ASSERT_EQ(test, ret, 0);
 320
 321         ret = drm_gem_shmem_is_purgeable(shmem);
 322         KUNIT_EXPECT_FALSE(test, ret);
 323
 324         ret = drm_gem_shmem_madvise(shmem, 1);
 325         KUNIT_EXPECT_TRUE(test, ret);
 326
 327         /* The scatter/gather table will be freed by drm_gem_shmem_free */
 328         sgt = drm_gem_shmem_get_pages_sgt(shmem);
 329         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
 330
 331         ret = drm_gem_shmem_is_purgeable(shmem);
 332         KUNIT_EXPECT_TRUE(test, ret);
 333
 334         drm_gem_shmem_purge(shmem);
 335         KUNIT_EXPECT_NULL(test, shmem->pages);
 336         KUNIT_EXPECT_NULL(test, shmem->sgt);
 337         KUNIT_EXPECT_EQ(test, shmem->madv, -1);
 338 }
 339
 340 static int drm_gem_shmem_test_init(struct kunit *test)
 341 {
 342         struct device *dev;
 343         struct drm_device *drm_dev;
 344
 345         /* Allocate a parent device */
 346         dev = drm_kunit_helper_alloc_device(test);
 347         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 348
 349         /*
 350          * The DRM core will automatically initialize the GEM core and create
 351          * a DRM Memory Manager object which provides an address space pool
 352          * for GEM objects allocation.
 353          */
 354         drm_dev = __drm_kunit_helper_alloc_drm_device(test, dev, sizeof(*drm_dev),
 355                                                       0, DRIVER_GEM);
 356         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, drm_dev);
 357
 358         test->priv = drm_dev;
 359
 360         return 0;
 361 }
 362
 363 static struct kunit_case drm_gem_shmem_test_cases[] = {
 364         KUNIT_CASE(drm_gem_shmem_test_obj_create),
 365         KUNIT_CASE(drm_gem_shmem_test_obj_create_private),
 366         KUNIT_CASE(drm_gem_shmem_test_pin_pages),
 367         KUNIT_CASE(drm_gem_shmem_test_vmap),
 368         KUNIT_CASE(drm_gem_shmem_test_get_pages_sgt),
 369         KUNIT_CASE(drm_gem_shmem_test_get_sg_table),
 370         KUNIT_CASE(drm_gem_shmem_test_madvise),
 371         KUNIT_CASE(drm_gem_shmem_test_purge),
 372         {}
 373 };
 374
 375 static struct kunit_suite drm_gem_shmem_suite = {
 376         .name = "drm_gem_shmem",
 377         .init = drm_gem_shmem_test_init,
 378         .test_cases = drm_gem_shmem_test_cases
 379 };
 380
 381 kunit_test_suite(drm_gem_shmem_suite);
 382
 383 MODULE_LICENSE("GPL");