lib/slub_kunit.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <kunit/test.h>
   3 #include <kunit/test-bug.h>
   4 #include <linux/mm.h>
   5 #include <linux/slab.h>
   6 #include <linux/module.h>
   7 #include <linux/kernel.h>
   8 #include "../mm/slab.h"
   9
  10 static struct kunit_resource resource;
  11 static int slab_errors;
  12
  13 static void test_clobber_zone(struct kunit *test)
  14 {
  15         struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_alloc", 64, 0,
  16                                 SLAB_RED_ZONE|SLAB_NO_USER_FLAGS, NULL);
  17         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
  18
  19         kasan_disable_current();
  20         p[64] = 0x12;
  21
  22         validate_slab_cache(s);
  23         KUNIT_EXPECT_EQ(test, 2, slab_errors);
  24
  25         kasan_enable_current();
  26         kmem_cache_free(s, p);
  27         kmem_cache_destroy(s);
  28 }
  29
  30 #ifndef CONFIG_KASAN
  31 static void test_next_pointer(struct kunit *test)
  32 {
  33         struct kmem_cache *s = kmem_cache_create("TestSlub_next_ptr_free", 64, 0,
  34                                 SLAB_POISON|SLAB_NO_USER_FLAGS, NULL);
  35         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
  36         unsigned long tmp;
  37         unsigned long *ptr_addr;
  38
  39         kmem_cache_free(s, p);
  40
  41         ptr_addr = (unsigned long *)(p + s->offset);
  42         tmp = *ptr_addr;
  43         p[s->offset] = 0x12;
  44
  45         /*
  46          * Expecting three errors.
  47          * One for the corrupted freechain and the other one for the wrong
  48          * count of objects in use. The third error is fixing broken cache.
  49          */
  50         validate_slab_cache(s);
  51         KUNIT_EXPECT_EQ(test, 3, slab_errors);
  52
  53         /*
  54          * Try to repair corrupted freepointer.
  55          * Still expecting two errors. The first for the wrong count
  56          * of objects in use.
  57          * The second error is for fixing broken cache.
  58          */
  59         *ptr_addr = tmp;
  60         slab_errors = 0;
  61
  62         validate_slab_cache(s);
  63         KUNIT_EXPECT_EQ(test, 2, slab_errors);
  64
  65         /*
  66          * Previous validation repaired the count of objects in use.
  67          * Now expecting no error.
  68          */
  69         slab_errors = 0;
  70         validate_slab_cache(s);
  71         KUNIT_EXPECT_EQ(test, 0, slab_errors);
  72
  73         kmem_cache_destroy(s);
  74 }
  75
  76 static void test_first_word(struct kunit *test)
  77 {
  78         struct kmem_cache *s = kmem_cache_create("TestSlub_1th_word_free", 64, 0,
  79                                 SLAB_POISON|SLAB_NO_USER_FLAGS, NULL);
  80         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
  81
  82         kmem_cache_free(s, p);
  83         *p = 0x78;
  84
  85         validate_slab_cache(s);
  86         KUNIT_EXPECT_EQ(test, 2, slab_errors);
  87
  88         kmem_cache_destroy(s);
  89 }
  90
  91 static void test_clobber_50th_byte(struct kunit *test)
  92 {
  93         struct kmem_cache *s = kmem_cache_create("TestSlub_50th_word_free", 64, 0,
  94                                 SLAB_POISON|SLAB_NO_USER_FLAGS, NULL);
  95         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
  96
  97         kmem_cache_free(s, p);
  98         p[50] = 0x9a;
  99
 100         validate_slab_cache(s);
 101         KUNIT_EXPECT_EQ(test, 2, slab_errors);
 102
 103         kmem_cache_destroy(s);
 104 }
 105 #endif
 106
 107 static void test_clobber_redzone_free(struct kunit *test)
 108 {
 109         struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_free", 64, 0,
 110                                 SLAB_RED_ZONE|SLAB_NO_USER_FLAGS, NULL);
 111         u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
 112
 113         kasan_disable_current();
 114         kmem_cache_free(s, p);
 115         p[64] = 0xab;
 116
 117         validate_slab_cache(s);
 118         KUNIT_EXPECT_EQ(test, 2, slab_errors);
 119
 120         kasan_enable_current();
 121         kmem_cache_destroy(s);
 122 }
 123
 124 static int test_init(struct kunit *test)
 125 {
 126         slab_errors = 0;
 127
 128         kunit_add_named_resource(test, NULL, NULL, &resource,
 129                                         "slab_errors", &slab_errors);
 130         return 0;
 131 }
 132
 133 static struct kunit_case test_cases[] = {
 134         KUNIT_CASE(test_clobber_zone),
 135
 136 #ifndef CONFIG_KASAN
 137         KUNIT_CASE(test_next_pointer),
 138         KUNIT_CASE(test_first_word),
 139         KUNIT_CASE(test_clobber_50th_byte),
 140 #endif
 141
 142         KUNIT_CASE(test_clobber_redzone_free),
 143         {}
 144 };
 145
 146 static struct kunit_suite test_suite = {
 147         .name = "slub_test",
 148         .init = test_init,
 149         .test_cases = test_cases,
 150 };
 151 kunit_test_suite(test_suite);
 152
 153 MODULE_LICENSE("GPL");