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