Skip to contentSkip to conversation

kunit: make test->lock irq safe

PATCH Applied [email protected] 4 participants 11 messages May 11, 2021 – May 13, 2021

Subsystems (6)
lore
Share & tools
lore
#0 lore raw

PATCH v5 1/3 kunit: make test->lock irq safe

From: Vlastimil Babka <[email protected]>

The upcoming SLUB kunit test will be calling kunit_find_named_resource() from a context with disabled interrupts. That means kunit's test->lock needs to be IRQ safe to avoid potential deadlocks and lockdep splats.

This patch therefore changes the test->lock usage to spin_lock_irqsave() and spin_unlock_irqrestore().

---
Changes since v4
Rebased whole series on 5.13-rc1

 include/kunit/test.h |  5 +++--
 lib/kunit/test.c     | 18 +++++++++++-------
 2 files changed, 14 insertions(+), 9 deletions(-)
include/kunit/test.h +3 -2
index 49601c4b98b8..524d4789af22 100644
@@ -515,8 +515,9 @@ kunit_find_resource(struct kunit *test,
 		    void *match_data)
 {
 	struct kunit_resource *res, *found = NULL;
+	unsigned long flags;
 
-	spin_lock(&test->lock);
+	spin_lock_irqsave(&test->lock, flags);
 
 	list_for_each_entry_reverse(res, &test->resources, node) {
 		if (match(test, res, (void *)match_data)) {
@@ -526,7 +527,7 @@ kunit_find_resource(struct kunit *test,
 		}
 	}
 
-	spin_unlock(&test->lock);
+	spin_unlock_irqrestore(&test->lock, flags);
 
 	return found;
 }
lib/kunit/test.c +11 -7
index 2f6cc0123232..45f068864d76 100644
@@ -475,6 +475,7 @@ int kunit_add_resource(struct kunit *test,
 		       void *data)
 {
 	int ret = 0;
+	unsigned long flags;
 
 	res->free = free;
 	kref_init(&res->refcount);
@@ -487,10 +488,10 @@ int kunit_add_resource(struct kunit *test,
 		res->data = data;
 	}
 
-	spin_lock(&test->lock);
+	spin_lock_irqsave(&test->lock, flags);
 	list_add_tail(&res->node, &test->resources);
 	/* refcount for list is established by kref_init() */
-	spin_unlock(&test->lock);
+	spin_unlock_irqrestore(&test->lock, flags);
 
 	return ret;
 }
@@ -548,9 +549,11 @@ EXPORT_SYMBOL_GPL(kunit_alloc_and_get_resource);
 
 void kunit_remove_resource(struct kunit *test, struct kunit_resource *res)
 {
-	spin_lock(&test->lock);
+	unsigned long flags;
+
+	spin_lock_irqsave(&test->lock, flags);
 	list_del(&res->node);
-	spin_unlock(&test->lock);
+	spin_unlock_irqrestore(&test->lock, flags);
 	kunit_put_resource(res);
 }
 EXPORT_SYMBOL_GPL(kunit_remove_resource);
@@ -630,6 +633,7 @@ EXPORT_SYMBOL_GPL(kunit_kfree);
 void kunit_cleanup(struct kunit *test)
 {
 	struct kunit_resource *res;
+	unsigned long flags;
 
 	/*
 	 * test->resources is a stack - each allocation must be freed in the
@@ -641,9 +645,9 @@ void kunit_cleanup(struct kunit *test)
 	 * protect against the current node being deleted, not the next.
 	 */
 	while (true) {
-		spin_lock(&test->lock);
+		spin_lock_irqsave(&test->lock, flags);
 		if (list_empty(&test->resources)) {
-			spin_unlock(&test->lock);
+			spin_unlock_irqrestore(&test->lock, flags);
 			break;
 		}
 		res = list_last_entry(&test->resources,
@@ -654,7 +658,7 @@ void kunit_cleanup(struct kunit *test)
 		 * resource, and this can't happen if the test->lock
 		 * is held.
 		 */
-		spin_unlock(&test->lock);
+		spin_unlock_irqrestore(&test->lock, flags);
 		kunit_remove_resource(test, res);
 	}
 	current->kunit_test = NULL;

--
2.31.1.272.g89b43f80a5

#1 lore raw

PATCH v5 2/3 mm/slub, kunit: add a KUnit test for SLUB debugging functionality

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

---
Changes since v4
Use two tests with KASAN dependency.
Remove setting current test during init and exit.

Changes since v3

Use kunit_resource to silence bug reports and count errors suggested by Marco Elver.
Make the test depends on !KASAN thanks to report from the kernel test robot.

Changes since v2

Use bit operation & instead of logical && as reported by kernel test robot and Dan Carpenter

Changes since v1

Conversion from kselftest to KUnit test suggested by Marco Elver. Error silencing.
Error counting improvements.

 lib/Kconfig.debug |  12 ++++
 lib/Makefile      |   1 +
 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +12 -0
index 678c13967580..7723f58a9394 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
 	  If unsure, say N.
 
+config SLUB_KUNIT_TEST
+	tristate "KUnit test for SLUB cache error detection" if !KUNIT_ALL_TESTS
+	depends on SLUB_DEBUG && KUNIT
+	default KUNIT_ALL_TESTS
+	help
+	  This builds SLUB allocator unit test.
+	  Tests SLUB cache debugging functionality.
+	  For more information on KUnit and unit tests in general please refer
+	  to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+	  If unsure, say N.
+
 config TEST_UDELAY
 	tristate "udelay test driver"
 	help
lib/Makefile +1 -0
index e11cfc18b6c0..386215dcb0a0 100644
@@ -353,5 +353,6 @@ obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
 obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o
 obj-$(CONFIG_BITS_TEST) += test_bits.o
 obj-$(CONFIG_CMDLINE_KUNIT_TEST) += cmdline_kunit.o
+obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 
 obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o
lib/slub_kunit.c new file +155 -0

155 lines not on this page · raw message

mm/slab.h +1 -0
index 18c1927cd196..9b690fa44cae 100644
@@ -215,6 +215,7 @@ DECLARE_STATIC_KEY_TRUE(slub_debug_enabled);
 DECLARE_STATIC_KEY_FALSE(slub_debug_enabled);
 #endif
 extern void print_tracking(struct kmem_cache *s, void *object);
+long validate_slab_cache(struct kmem_cache *s);
 #else
 static inline void print_tracking(struct kmem_cache *s, void *object)
 {
mm/slub.c +43 -3

116 lines not on this page · raw message

--
2.31.1.272.g89b43f80a5

Reviewed-by on v5 2/3
#2 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

Quoted 25 lines · On Tue, 11 May 2021 at 17:07, <[email protected]> wrote:

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Quoted 5 lines

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

I think I had already reviewed v4, and the changes here are fine:

Others who had reviewed/acked v4, probably need to re-ack/review. Note, I think if you addressed the comments and didn't change much else, you can typically carry the acks/reviews, unless the other person changed their mind explicitly.

Quoted 192 lines

---
Changes since v4
Use two tests with KASAN dependency.
Remove setting current test during init and exit.

Changes since v3

Use kunit_resource to silence bug reports and count errors suggested by Marco Elver.
Make the test depends on !KASAN thanks to report from the kernel test robot.

Changes since v2

Use bit operation & instead of logical && as reported by kernel test robot and Dan Carpenter

Changes since v1

Conversion from kselftest to KUnit test suggested by Marco Elver. Error silencing.
Error counting improvements.

 lib/Kconfig.debug |  12 ++++
 lib/Makefile      |   1 +
 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +12 -0
index 678c13967580..7723f58a9394 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
          If unsure, say N.
 
+config SLUB_KUNIT_TEST
+       tristate "KUnit test for SLUB cache error detection" if !KUNIT_ALL_TESTS
+       depends on SLUB_DEBUG && KUNIT
+       default KUNIT_ALL_TESTS
+       help
+         This builds SLUB allocator unit test.
+         Tests SLUB cache debugging functionality.
+         For more information on KUnit and unit tests in general please refer
+         to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+         If unsure, say N.
+
 config TEST_UDELAY
        tristate "udelay test driver"
        help
lib/Makefile +1 -0
index e11cfc18b6c0..386215dcb0a0 100644
@@ -353,5 +353,6 @@ obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
 obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o
 obj-$(CONFIG_BITS_TEST) += test_bits.o
 obj-$(CONFIG_CMDLINE_KUNIT_TEST) += cmdline_kunit.o
+obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 
 obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o
lib/slub_kunit.c new file +122 -0
new file mode 100644
index 000000000000..f28965f64ef6
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <kunit/test.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include "../mm/slab.h"
+
+static struct kunit_resource resource;
+static int slab_errors;
+
+static void test_clobber_zone(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_alloc", 64, 0,
+                               SLAB_RED_ZONE, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kasan_disable_current();
+       p[64] = 0x12;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kasan_enable_current();
+       kmem_cache_free(s, p);
+       kmem_cache_destroy(s);
+}
+
+#ifndef CONFIG_KASAN
+static void test_next_pointer(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_next_ptr_free", 64, 0,
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+       unsigned long tmp;
+       unsigned long *ptr_addr;
+
+       kmem_cache_free(s, p);
+
+       ptr_addr = (unsigned long *)(p + s->offset);
+       tmp = *ptr_addr;
+       p[s->offset] = 0x12;
+
+       /*
+        * Expecting three errors.
+        * One for the corrupted freechain and the other one for the wrong
+        * count of objects in use. The third error is fixing broken cache.
+        */
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 3, slab_errors);
+
+       /*
+        * Try to repair corrupted freepointer.
+        * Still expecting two errors. The first for the wrong count
+        * of objects in use.
+        * The second error is for fixing broken cache.
+        */
+       *ptr_addr = tmp;
+       slab_errors = 0;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       /*
+        * Previous validation repaired the count of objects in use.
+        * Now expecting no error.
+        */
+       slab_errors = 0;
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 0, slab_errors);
+
+       kmem_cache_destroy(s);
+}
+
+static void test_first_word(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_1th_word_free", 64, 0,
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kmem_cache_free(s, p);
+       *p = 0x78;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kmem_cache_destroy(s);
+}
+
+static void test_clobber_50th_byte(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_50th_word_free", 64, 0,
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kmem_cache_free(s, p);
+       p[50] = 0x9a;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kmem_cache_destroy(s);
+}
+#endif
+
+static void test_clobber_redzone_free(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_free", 64, 0,
+                               SLAB_RED_ZONE, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kasan_disable_current();
+       kmem_cache_free(s, p);
+       p[64] = 0xab;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kasan_enable_current();
+       kmem_cache_destroy(s);
+}
+

lib/slub_kunit.c line 132

Quoted 10 lines
lib/slub_kunit.c new file +10 -0
+static int test_init(struct kunit *test)
+{
+       slab_errors = 0;
+
+       kunit_add_named_resource(test, NULL, NULL, &resource,
+                                       "slab_errors", &slab_errors);
+       return 0;
+}
+
+static void test_exit(struct kunit *test) {}

Does removing test_exit() and not setting it below work?

lib/slub_kunit.c line 144

Quoted 11 lines
lib/slub_kunit.c new file +11 -0
+static struct kunit_case test_cases[] = {
+       KUNIT_CASE(test_clobber_zone),
+
+#ifndef CONFIG_KASAN
+       KUNIT_CASE(test_next_pointer),
+       KUNIT_CASE(test_first_word),
+       KUNIT_CASE(test_clobber_50th_byte),
+#endif
+
+       KUNIT_CASE(test_clobber_redzone_free),
+       {}

This is better, and tells us which tests exactly were the ones causing problems with KASAN.

Quoted 155 lines
lib/slub_kunit.c new file +11 -0
+};
+
+static struct kunit_suite test_suite = {
+       .name = "slub_test",
+       .init = test_init,
+       .exit = test_exit,
+       .test_cases = test_cases,
+};
+kunit_test_suite(test_suite);
+
+MODULE_LICENSE("GPL");
mm/slab.h +1 -0
index 18c1927cd196..9b690fa44cae 100644
@@ -215,6 +215,7 @@ DECLARE_STATIC_KEY_TRUE(slub_debug_enabled);
 DECLARE_STATIC_KEY_FALSE(slub_debug_enabled);
 #endif
 extern void print_tracking(struct kmem_cache *s, void *object);
+long validate_slab_cache(struct kmem_cache *s);
 #else
 static inline void print_tracking(struct kmem_cache *s, void *object)
 {
mm/slub.c +43 -4
index feda53ae62ba..985fd6ef033c 100644
@@ -35,6 +35,7 @@
 #include <linux/prefetch.h>
 #include <linux/memcontrol.h>
 #include <linux/random.h>
+#include <kunit/test.h>
 
 #include <trace/events/kmem.h>
 
@@ -447,6 +448,26 @@ static inline bool cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
 static unsigned long object_map[BITS_TO_LONGS(MAX_OBJS_PER_PAGE)];
 static DEFINE_SPINLOCK(object_map_lock);
 
+#if IS_ENABLED(CONFIG_KUNIT)
+static bool slab_add_kunit_errors(void)
+{
+       struct kunit_resource *resource;
+
+       if (likely(!current->kunit_test))
+               return false;
+
+       resource = kunit_find_named_resource(current->kunit_test, "slab_errors");
+       if (!resource)
+               return false;
+
+       (*(int *)resource->data)++;
+       kunit_put_resource(resource);
+       return true;
+}
+#else
+static inline bool slab_add_kunit_errors(void) { return false; }
+#endif
+
 /*
  * Determine a map of object in use on a page.
  *
@@ -677,6 +698,9 @@ static void slab_fix(struct kmem_cache *s, char *fmt, ...)
        struct va_format vaf;
        va_list args;
 
+       if (slab_add_kunit_errors())
+               return;
+
        va_start(args, fmt);
        vaf.fmt = fmt;
        vaf.va = &args;
@@ -740,6 +764,9 @@ static void print_trailer(struct kmem_cache *s, struct page *page, u8 *p)
 void object_err(struct kmem_cache *s, struct page *page,
                        u8 *object, char *reason)
 {
+       if (slab_add_kunit_errors())
+               return;
+
        slab_bug(s, "%s", reason);
        print_trailer(s, page, object);
 }
@@ -750,6 +777,9 @@ static __printf(3, 4) void slab_err(struct kmem_cache *s, struct page *page,
        va_list args;
        char buf[100];
 
+       if (slab_add_kunit_errors())
+               return;
+
        va_start(args, fmt);
        vsnprintf(buf, sizeof(buf), fmt, args);
        va_end(args);
@@ -799,12 +829,16 @@ static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
        while (end > fault && end[-1] == value)
                end--;
 
+       if (slab_add_kunit_errors())
+               goto skip_bug_print;
+
        slab_bug(s, "%s overwritten", what);
        pr_err("0x%p-0x%p @offset=%tu. First byte 0x%x instead of 0x%x\n",
                                        fault, end - 1, fault - addr,
                                        fault[0], value);
        print_trailer(s, page, object);
 
+skip_bug_print:
        restore_bytes(s, what, value, fault, end);
        return 0;
 }
@@ -4662,9 +4696,11 @@ static int validate_slab_node(struct kmem_cache *s,
                validate_slab(s, page);
                count++;
        }
-       if (count != n->nr_partial)
+       if (count != n->nr_partial) {
                pr_err("SLUB %s: %ld partial slabs counted but counter=%ld\n",
                       s->name, count, n->nr_partial);
+               slab_add_kunit_errors();
+       }
 
        if (!(s->flags & SLAB_STORE_USER))
                goto out;
@@ -4673,16 +4709,18 @@ static int validate_slab_node(struct kmem_cache *s,
                validate_slab(s, page);
                count++;
        }
-       if (count != atomic_long_read(&n->nr_slabs))
+       if (count != atomic_long_read(&n->nr_slabs)) {
                pr_err("SLUB: %s %ld slabs counted but counter=%ld\n",
                       s->name, count, atomic_long_read(&n->nr_slabs));
+               slab_add_kunit_errors();
+       }
 
 out:
        spin_unlock_irqrestore(&n->list_lock, flags);
        return count;
 }
 
-static long validate_slab_cache(struct kmem_cache *s)
+long validate_slab_cache(struct kmem_cache *s)
 {
        int node;
        unsigned long count = 0;
@@ -4694,6 +4732,8 @@ static long validate_slab_cache(struct kmem_cache *s)
 
        return count;
 }
+EXPORT_SYMBOL(validate_slab_cache);
+
 /*
  * Generate lists of code addresses where slabcache objects are allocated
  * and freed.
--

2.31.1.272.g89b43f80a5

Reviewed-by Acked-by Daniel Latypov
#3 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

Quoted 26 lines · Marco Elver
Quoted 25 lines · On Tue, 11 May 2021 at 17:07, <[email protected]> wrote:

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Quoted 5 lines
Quoted 5 lines

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

Quoted 8 lines

I think I had already reviewed v4, and the changes here are fine:

Others who had reviewed/acked v4, probably need to re-ack/review. Note, I think if you addressed the comments and didn't change much else, you can typically carry the acks/reviews, unless the other person changed their mind explicitly.

FTR, besides me and Marco, v4 had also:

#4 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

In reply to Marco Elver

ut 11. 5. 2021 o 17:16 Marco Elver <[email protected]> napísal(a):

Quoted 19 lines · On Tue, 11 May 2021 at 17:07, <[email protected]> wrote:
Quoted 17 lines

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Quoted 6 lines
Quoted 6 lines

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig. Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies

non-allocated

Quoted 11 lines
Quoted 7 lines

objects.

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

I think I had already reviewed v4, and the changes here are fine:

Thank you again.

I’m sorry about, I forgot to add this tags.

Quoted 15 lines

Others who had reviewed/acked v4, probably need to re-ack/review. Note, I think if you addressed the comments and didn't change much else, you can typically carry the acks/reviews, unless the other person changed their mind explicitly.

Quoted 10 lines

---
Changes since v4
Use two tests with KASAN dependency.
Remove setting current test during init and exit.

Changes since v3

Use kunit_resource to silence bug reports and count errors suggested by Marco Elver.
Make the test depends on !KASAN thanks to report from the kernel test

robot.

Quoted 26 lines
Quoted 26 lines

Changes since v2

Use bit operation & instead of logical && as reported by kernel test robot and Dan Carpenter

Changes since v1

Conversion from kselftest to KUnit test suggested by Marco Elver. Error silencing.
Error counting improvements.

 lib/Kconfig.debug |  12 ++++
 lib/Makefile      |   1 +
 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +0 -0
index 678c13967580..7723f58a9394 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
Quoted 4 lines

lib/Kconfig.debug config BITS_TEST

Quoted 4 lines
lib/Kconfig.debug +2 -0
          If unsure, say N.
 
+config SLUB_KUNIT_TEST
+       tristate "KUnit test for SLUB cache error detection" if

!KUNIT_ALL_TESTS

Quoted 6 lines

lib/Kconfig.debug config BITS_TEST

Quoted 6 lines
lib/Kconfig.debug +6 -0
+       depends on SLUB_DEBUG && KUNIT
+       default KUNIT_ALL_TESTS
+       help
+         This builds SLUB allocator unit test.
+         Tests SLUB cache debugging functionality.
+         For more information on KUnit and unit tests in general

please refer

Quoted 30 lines
Quoted 30 lines
lib/Kconfig.debug +4 -0
+         to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+         If unsure, say N.
+
 config TEST_UDELAY
        tristate "udelay test driver"
        help
lib/Makefile +1 -0
index e11cfc18b6c0..386215dcb0a0 100644
@@ -353,5 +353,6 @@ obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
 obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o
 obj-$(CONFIG_BITS_TEST) += test_bits.o
 obj-$(CONFIG_CMDLINE_KUNIT_TEST) += cmdline_kunit.o
+obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 
 obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o
lib/slub_kunit.c new file +6 -0
new file mode 100644
index 000000000000..f28965f64ef6
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <kunit/test.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+#include "../mm/slab.h"
+
+static struct kunit_resource resource;
+static int slab_errors;
+
+static void test_clobber_zone(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_alloc",

64, 0,

Quoted 10 lines
Quoted 10 lines
lib/slub_kunit.c new file +10 -0
+                               SLAB_RED_ZONE, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kasan_disable_current();
+       p[64] = 0x12;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kasan_enable_current();
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+       kmem_cache_free(s, p);
+       kmem_cache_destroy(s);
+}
+
+#ifndef CONFIG_KASAN
+static void test_next_pointer(struct kunit *test)
+{
+       struct kmem_cache *s =

kmem_cache_create("TestSlub_next_ptr_free", 64, 0,

Quoted 6 lines
Quoted 6 lines
lib/slub_kunit.c new file +6 -0
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+       unsigned long tmp;
+       unsigned long *ptr_addr;
+
+       kmem_cache_free(s, p);
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+
+       ptr_addr = (unsigned long *)(p + s->offset);
+       tmp = *ptr_addr;
+       p[s->offset] = 0x12;
+
+       /*
+        * Expecting three errors.
+        * One for the corrupted freechain and the other one for the

wrong

Quoted 1 line

lib/slub_kunit.c line 47

Quoted 1 line
lib/slub_kunit.c new file +1 -0
+        * count of objects in use. The third error is fixing broken

cache.

Quoted 22 lines
Quoted 22 lines
lib/slub_kunit.c new file +22 -0
+        */
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 3, slab_errors);
+
+       /*
+        * Try to repair corrupted freepointer.
+        * Still expecting two errors. The first for the wrong count
+        * of objects in use.
+        * The second error is for fixing broken cache.
+        */
+       *ptr_addr = tmp;
+       slab_errors = 0;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       /*
+        * Previous validation repaired the count of objects in use.
+        * Now expecting no error.
+        */
+       slab_errors = 0;
+       validate_slab_cache(s);
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+       KUNIT_EXPECT_EQ(test, 0, slab_errors);
+
+       kmem_cache_destroy(s);
+}
+
+static void test_first_word(struct kunit *test)
+{
+       struct kmem_cache *s =

kmem_cache_create("TestSlub_1th_word_free", 64, 0,

Quoted 7 lines
Quoted 7 lines
lib/slub_kunit.c new file +7 -0
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kmem_cache_free(s, p);
+       *p = 0x78;
+
+       validate_slab_cache(s);
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kmem_cache_destroy(s);
+}
+
+static void test_clobber_50th_byte(struct kunit *test)
+{
+       struct kmem_cache *s =

kmem_cache_create("TestSlub_50th_word_free", 64, 0,

Quoted 8 lines
Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+                               SLAB_POISON, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kmem_cache_free(s, p);
+       p[50] = 0x9a;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
Quoted 8 lines

lib/slub_kunit.c

Quoted 8 lines
lib/slub_kunit.c new file +8 -0
+
+       kmem_cache_destroy(s);
+}
+#endif
+
+static void test_clobber_redzone_free(struct kunit *test)
+{
+       struct kmem_cache *s = kmem_cache_create("TestSlub_RZ_free",

64, 0,

Quoted 18 lines
Quoted 18 lines
lib/slub_kunit.c new file +18 -0
+                               SLAB_RED_ZONE, NULL);
+       u8 *p = kmem_cache_alloc(s, GFP_KERNEL);
+
+       kasan_disable_current();
+       kmem_cache_free(s, p);
+       p[64] = 0xab;
+
+       validate_slab_cache(s);
+       KUNIT_EXPECT_EQ(test, 2, slab_errors);
+
+       kasan_enable_current();
+       kmem_cache_destroy(s);
+}
+
+static int test_init(struct kunit *test)
+{
+       slab_errors = 0;
+
Quoted 8 lines

lib/slub_kunit.c line 132

Quoted 6 lines
lib/slub_kunit.c new file +6 -0
+       kunit_add_named_resource(test, NULL, NULL, &resource,
+                                       "slab_errors", &slab_errors);
+       return 0;
+}
+
+static void test_exit(struct kunit *test) {}

Does removing test_exit() and not setting it below work?

Yes this works. Thank you for that. I try to remove function but I didn't think about not setting it, so it didn't work. I will fix it.

Quoted 49 lines

lib/slub_kunit.c line 144

Quoted 11 lines
lib/slub_kunit.c new file +11 -0
+static struct kunit_case test_cases[] = {
+       KUNIT_CASE(test_clobber_zone),
+
+#ifndef CONFIG_KASAN
+       KUNIT_CASE(test_next_pointer),
+       KUNIT_CASE(test_first_word),
+       KUNIT_CASE(test_clobber_50th_byte),
+#endif
+
+       KUNIT_CASE(test_clobber_redzone_free),
+       {}

This is better, and tells us which tests exactly were the ones causing problems with KASAN.

Quoted 33 lines
lib/slub_kunit.c new file +11 -0
+};
+
+static struct kunit_suite test_suite = {
+       .name = "slub_test",
+       .init = test_init,
+       .exit = test_exit,
+       .test_cases = test_cases,
+};
+kunit_test_suite(test_suite);
+
+MODULE_LICENSE("GPL");
mm/slab.h +1 -0
index 18c1927cd196..9b690fa44cae 100644
@@ -215,6 +215,7 @@ DECLARE_STATIC_KEY_TRUE(slub_debug_enabled);
 DECLARE_STATIC_KEY_FALSE(slub_debug_enabled);
 #endif
 extern void print_tracking(struct kmem_cache *s, void *object);
+long validate_slab_cache(struct kmem_cache *s);
 #else
 static inline void print_tracking(struct kmem_cache *s, void *object)
 {
mm/slub.c +1 -0
index feda53ae62ba..985fd6ef033c 100644
@@ -35,6 +35,7 @@
 #include <linux/prefetch.h>
 #include <linux/memcontrol.h>
 #include <linux/random.h>
+#include <kunit/test.h>
 
Quoted 3 lines

mm/slub.c static inline bool cmpxchg_double_slab(struct

Quoted 3 lines
mm/slub.c +0 -0
 #include <trace/events/kmem.h>
 
@@ -447,6 +448,26 @@ static inline bool cmpxchg_double_slab(struct

kmem_cache *s, struct page *page,

Quoted 12 lines

mm/slub.c static inline bool cmpxchg_double_slab(struct kmem_cache *s, struct page *page,

Quoted 12 lines
mm/slub.c +9 -0
 static unsigned long object_map[BITS_TO_LONGS(MAX_OBJS_PER_PAGE)];
 static DEFINE_SPINLOCK(object_map_lock);
 
+#if IS_ENABLED(CONFIG_KUNIT)
+static bool slab_add_kunit_errors(void)
+{
+       struct kunit_resource *resource;
+
+       if (likely(!current->kunit_test))
+               return false;
+
+       resource = kunit_find_named_resource(current->kunit_test,

"slab_errors");

Quoted 7 lines
Quoted 7 lines
mm/slub.c +7 -0
+       if (!resource)
+               return false;
+
+       (*(int *)resource->data)++;
+       kunit_put_resource(resource);
+       return true;
+}
Quoted 8 lines

mm/slub.c static void slab_fix(struct kmem_cache *s, char

Quoted 8 lines
mm/slub.c +4 -0
+#else
+static inline bool slab_add_kunit_errors(void) { return false; }
+#endif
+
 /*
  * Determine a map of object in use on a page.
  *
@@ -677,6 +698,9 @@ static void slab_fix(struct kmem_cache *s, char

*fmt, ...)

Quoted 10 lines

mm/slub.c static void print_trailer(struct kmem_cache *s,

Quoted 10 lines
mm/slub.c +3 -0
        struct va_format vaf;
        va_list args;
 
+       if (slab_add_kunit_errors())
+               return;
+
        va_start(args, fmt);
        vaf.fmt = fmt;
        vaf.va = &args;
@@ -740,6 +764,9 @@ static void print_trailer(struct kmem_cache *s,

struct page *page, u8 *p)

Quoted 10 lines

mm/slub.c static __printf(3, 4) void slab_err(struct

Quoted 10 lines
mm/slub.c +3 -0
 void object_err(struct kmem_cache *s, struct page *page,
                        u8 *object, char *reason)
 {
+       if (slab_add_kunit_errors())
+               return;
+
        slab_bug(s, "%s", reason);
        print_trailer(s, page, object);
 }
@@ -750,6 +777,9 @@ static __printf(3, 4) void slab_err(struct

kmem_cache *s, struct page *page,

Quoted 10 lines

mm/slub.c static int check_bytes_and_report(struct

Quoted 10 lines
mm/slub.c +3 -0
        va_list args;
        char buf[100];
 
+       if (slab_add_kunit_errors())
+               return;
+
        va_start(args, fmt);
        vsnprintf(buf, sizeof(buf), fmt, args);
        va_end(args);
@@ -799,12 +829,16 @@ static int check_bytes_and_report(struct

kmem_cache *s, struct page *page,

Quoted 8 lines

mm/slub.c static int check_bytes_and_report(struct kmem_cache *s, struct page *page,

Quoted 8 lines
mm/slub.c +3 -0
        while (end > fault && end[-1] == value)
                end--;
 
+       if (slab_add_kunit_errors())
+               goto skip_bug_print;
+
        slab_bug(s, "%s overwritten", what);
        pr_err("0x%p-0x%p @offset=%tu. First byte 0x%x instead of

0x%x\n",

Quoted 9 lines

mm/slub.c static int validate_slab_node(struct kmem_cache

Quoted 9 lines
mm/slub.c +1 -0
                                        fault, end - 1, fault - addr,
                                        fault[0], value);
        print_trailer(s, page, object);
 
+skip_bug_print:
        restore_bytes(s, what, value, fault, end);
        return 0;
 }
@@ -4662,9 +4696,11 @@ static int validate_slab_node(struct kmem_cache

*s,

Quoted 6 lines

mm/slub.c static int validate_slab_node(struct kmem_cache *s,

Quoted 6 lines
mm/slub.c +1 -1
                validate_slab(s, page);
                count++;
        }
-       if (count != n->nr_partial)
+       if (count != n->nr_partial) {
                pr_err("SLUB %s: %ld partial slabs counted but

counter=%ld\n",

Quoted 7 lines

mm/slub.c static int validate_slab_node(struct kmem_cache

Quoted 7 lines
mm/slub.c +2 -0
                       s->name, count, n->nr_partial);
+               slab_add_kunit_errors();
+       }
 
        if (!(s->flags & SLAB_STORE_USER))
                goto out;
@@ -4673,16 +4709,18 @@ static int validate_slab_node(struct kmem_cache

*s,

Quoted 15 lines
Quoted 15 lines
mm/slub.c +3 -1
                validate_slab(s, page);
                count++;
        }
-       if (count != atomic_long_read(&n->nr_slabs))
+       if (count != atomic_long_read(&n->nr_slabs)) {
                pr_err("SLUB: %s %ld slabs counted but counter=%ld\n",
                       s->name, count, atomic_long_read(&n->nr_slabs));
+               slab_add_kunit_errors();
+       }
 
 out:
        spin_unlock_irqrestore(&n->list_lock, flags);
        return count;
 }
 
Quoted 6 lines

mm/slub.c static long validate_slab_cache(struct kmem_cache

Quoted 6 lines
mm/slub.c +1 -1
-static long validate_slab_cache(struct kmem_cache *s)
+long validate_slab_cache(struct kmem_cache *s)
 {
        int node;
        unsigned long count = 0;
@@ -4694,6 +4732,8 @@ static long validate_slab_cache(struct kmem_cache

*s)

Quoted 7 lines

mm/slub.c static long validate_slab_cache(struct kmem_cache *s)

Quoted 7 lines
mm/slub.c +2 -0
        return count;
 }
+EXPORT_SYMBOL(validate_slab_cache);
+
 /*
  * Generate lists of code addresses where slabcache objects are

allocated

Quoted 4 lines
Quoted 4 lines
mm/slub.c +0 -1
  * and freed.
--

2.31.1.272.g89b43f80a5

#5 lore raw

PATCH 1/1 mm/slub, kunit: add a KUnit test for SLUB debugging functionality-fix

In reply to [email protected]

From: Oliver Glitta <[email protected]>

Remove unused function test_exit(), from SLUB KUnit test.

---
 lib/slub_kunit.c | 3 ---
 1 file changed, 3 deletions(-)
lib/slub_kunit.c +0 -3
index f28965f64ef6..8662dc6cb509 100644
@@ -129,8 +129,6 @@ static int test_init(struct kunit *test)
 	return 0;
 }
 
-static void test_exit(struct kunit *test) {}
-
 static struct kunit_case test_cases[] = {
 	KUNIT_CASE(test_clobber_zone),
 
@@ -147,7 +145,6 @@ static struct kunit_case test_cases[] = {
 static struct kunit_suite test_suite = {
 	.name = "slub_test",
 	.init = test_init,
-	.exit = test_exit,
 	.test_cases = test_cases,
 };
 kunit_test_suite(test_suite);
Signature · 1 line
2.31.1.272.g89b43f80a5
maintainer
#6 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

In reply to [email protected]
Quoted 42 lines · On Tue, 11 May 2021 17:07:33 +0200 [email protected] wrote:

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

...

 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +0 -0
index 678c13967580..7723f58a9394 100644

lib/Kconfig.debug config BITS_TEST · line 2433

Quoted 5 lines
lib/Kconfig.debug +2 -0
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
 	  If unsure, say N.
 
+config SLUB_KUNIT_TEST
+	tristate "KUnit test for SLUB cache error detection" if !KUNIT_ALL_TESTS

This means it can be compiled as a kernel module. Did you runtime test the code as a module?

ERROR: modpost: "kasan_enable_current" [lib/slub_kunit.ko] undefined!
ERROR: modpost: "kasan_disable_current" [lib/slub_kunit.ko] undefined!

mm/kasan/common.c renamed from mm/kasan/common.c~a +3 -0
@@ -51,11 +51,14 @@ void kasan_enable_current(void)
 {
 	current->kasan_depth++;
 }
+EXPORT_SYMBOL(kasan_enable_current);
 
 void kasan_disable_current(void)
 {
 	current->kasan_depth--;
 }
+EXPORT_SYMBOL(kasan_disable_current);
+
 #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
 
 void __kasan_unpoison_range(const void *address, size_t size)

_

Acked-by
#7 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

Quoted 72 lines · Andrew Morton
Quoted 42 lines · On Tue, 11 May 2021 17:07:33 +0200 [email protected] wrote:

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

...

 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +0 -0
index 678c13967580..7723f58a9394 100644

lib/Kconfig.debug config BITS_TEST · line 2433

Quoted 5 lines
lib/Kconfig.debug +2 -0
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
        If unsure, say N.
 
+config SLUB_KUNIT_TEST
+     tristate "KUnit test for SLUB cache error detection" if !KUNIT_ALL_TESTS

This means it can be compiled as a kernel module. Did you runtime test the code as a module?

ERROR: modpost: "kasan_enable_current" [lib/slub_kunit.ko] undefined!
ERROR: modpost: "kasan_disable_current" [lib/slub_kunit.ko] undefined!

mm/kasan/common.c renamed from mm/kasan/common.c~a +3 -0
@@ -51,11 +51,14 @@ void kasan_enable_current(void)
 {
        current->kasan_depth++;
 }
+EXPORT_SYMBOL(kasan_enable_current);
 
 void kasan_disable_current(void)
 {
        current->kasan_depth--;
 }
+EXPORT_SYMBOL(kasan_disable_current);
+
 #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
 
 void __kasan_unpoison_range(const void *address, size_t size)
Quoted 1 line

_

#8 lore raw

Re: [PATCH v5 2/3] mm/slub, kunit: add a KUnit test for SLUB debugging functionality

In reply to Andrew Morton

št 13. 5. 2021 o 6:44 Andrew Morton <[email protected]> napísal(a):

Quoted 46 lines · On Tue, 11 May 2021 17:07:33 +0200 [email protected] wrote:
Quoted 44 lines

From: Oliver Glitta <[email protected]>

SLUB has resiliency_test() function which is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it. KUnit should be a proper replacement for it.

Try changing byte in redzone after allocation and changing pointer to next free node, first byte, 50th byte and redzone byte. Check if validation finds errors.

There are several differences from the original resiliency test:
Tests create own caches with known state instead of corrupting shared kmalloc caches.

The corruption of freepointer uses correct offset, the original resiliency test got broken with freepointer changes.

Scratch changing random byte test, because it does not have meaning in this form where we need deterministic results.

Add new option CONFIG_SLUB_KUNIT_TEST in Kconfig.
Tests next_pointer, first_word and clobber_50th_byte do not run with KASAN option on. Because the test deliberately modifies non-allocated objects.

Use kunit_resource to count errors in cache and silence bug reports. Count error whenever slab_bug() or slab_fix() is called or when the count of pages is wrong.

...

 lib/slub_kunit.c  | 155 ++++++++++++++++++++++++++++++++++++++++++++++
 mm/slab.h         |   1 +
 mm/slub.c         |  46 +++++++++++++-
 5 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 lib/slub_kunit.c
lib/Kconfig.debug +0 -0
index 678c13967580..7723f58a9394 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
Quoted 8 lines

lib/Kconfig.debug config BITS_TEST · line 2433

Quoted 4 lines
lib/Kconfig.debug +2 -0
        If unsure, say N.
 
+config SLUB_KUNIT_TEST
+     tristate "KUnit test for SLUB cache error detection" if !KUNIT_ALL_TESTS

This means it can be compiled as a kernel module. Did you runtime test the code as a module?

We tested this as a module in the previous version, but I forgot to try it with this new one. So we didn't find this error. Thank you for your fix.

Quoted 22 lines

ERROR: modpost: "kasan_enable_current" [lib/slub_kunit.ko] undefined!
ERROR: modpost: "kasan_disable_current" [lib/slub_kunit.ko] undefined!

mm/kasan/common.c renamed from mm/kasan/common.c~a +3 -0
@@ -51,11 +51,14 @@ void kasan_enable_current(void)
 {
        current->kasan_depth++;
 }
+EXPORT_SYMBOL(kasan_enable_current);
 
 void kasan_disable_current(void)
 {
        current->kasan_depth--;
 }
+EXPORT_SYMBOL(kasan_disable_current);
+
 #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
 
 void __kasan_unpoison_range(const void *address, size_t size)

_

#9 lore raw

PATCH v5 3/3 slub: remove resiliency_test() function

In reply to [email protected]

From: Oliver Glitta <[email protected]>

Function resiliency_test() is hidden behind #ifdef SLUB_RESILIENCY_TEST that is not part of Kconfig, so nobody runs it.

This function is replaced with KUnit test for SLUB added by the previous patch "selftests: add a KUnit test for SLUB debugging functionality".

---
 mm/slub.c | 64 -------------------------------------------------------
 1 file changed, 64 deletions(-)
mm/slub.c +0 -64
index 985fd6ef033c..88e2c1847698 100644
@@ -154,9 +154,6 @@ static inline bool kmem_cache_has_cpu_partial(struct kmem_cache *s)
  * - Variable sizing of the per node arrays
  */
 
-/* Enable to test recovery from slab corruption on boot */
-#undef SLUB_RESILIENCY_TEST
-
 /* Enable to log cmpxchg failures */
 #undef SLUB_DEBUG_CMPXCHG
 
@@ -4951,66 +4948,6 @@ static int list_locations(struct kmem_cache *s, char *buf,
 }
 #endif	/* CONFIG_SLUB_DEBUG */
 
-#ifdef SLUB_RESILIENCY_TEST
-static void __init resiliency_test(void)
-{
-	u8 *p;
-	int type = KMALLOC_NORMAL;
-
-	BUILD_BUG_ON(KMALLOC_MIN_SIZE > 16 || KMALLOC_SHIFT_HIGH < 10);
-
-	pr_err("SLUB resiliency testing\n");
-	pr_err("-----------------------\n");
-	pr_err("A. Corruption after allocation\n");
-
-	p = kzalloc(16, GFP_KERNEL);
-	p[16] = 0x12;
-	pr_err("\n1. kmalloc-16: Clobber Redzone/next pointer 0x12->0x%p\n\n",
-	       p + 16);
-
-	validate_slab_cache(kmalloc_caches[type][4]);
-
-	/* Hmmm... The next two are dangerous */
-	p = kzalloc(32, GFP_KERNEL);
-	p[32 + sizeof(void *)] = 0x34;
-	pr_err("\n2. kmalloc-32: Clobber next pointer/next slab 0x34 -> -0x%p\n",
-	       p);
-	pr_err("If allocated object is overwritten then not detectable\n\n");
-
-	validate_slab_cache(kmalloc_caches[type][5]);
-	p = kzalloc(64, GFP_KERNEL);
-	p += 64 + (get_cycles() & 0xff) * sizeof(void *);
-	*p = 0x56;
-	pr_err("\n3. kmalloc-64: corrupting random byte 0x56->0x%p\n",
-	       p);
-	pr_err("If allocated object is overwritten then not detectable\n\n");
-	validate_slab_cache(kmalloc_caches[type][6]);
-
-	pr_err("\nB. Corruption after free\n");
-	p = kzalloc(128, GFP_KERNEL);
-	kfree(p);
-	*p = 0x78;
-	pr_err("1. kmalloc-128: Clobber first word 0x78->0x%p\n\n", p);
-	validate_slab_cache(kmalloc_caches[type][7]);
-
-	p = kzalloc(256, GFP_KERNEL);
-	kfree(p);
-	p[50] = 0x9a;
-	pr_err("\n2. kmalloc-256: Clobber 50th byte 0x9a->0x%p\n\n", p);
-	validate_slab_cache(kmalloc_caches[type][8]);
-
-	p = kzalloc(512, GFP_KERNEL);
-	kfree(p);
-	p[512] = 0xab;
-	pr_err("\n3. kmalloc-512: Clobber redzone 0xab->0x%p\n\n", p);
-	validate_slab_cache(kmalloc_caches[type][9]);
-}
-#else
-#ifdef CONFIG_SYSFS
-static void resiliency_test(void) {};
-#endif
-#endif	/* SLUB_RESILIENCY_TEST */
-
 #ifdef CONFIG_SYSFS
 enum slab_stat_type {
 	SL_ALL,			/* All slabs */
@@ -5859,7 +5796,6 @@ static int __init slab_sysfs_init(void)
 	}
 
 	mutex_unlock(&slab_mutex);
-	resiliency_test();
 	return 0;
 }
 
Signature · 1 line
2.31.1.272.g89b43f80a5
Reviewed-by Brendan Higgins on v5 1/3
#10 lore raw
In reply to [email protected]
Quoted 11 lines · On 5/11/21 5:07 PM, [email protected] wrote:

From: Vlastimil Babka <[email protected]>

The upcoming SLUB kunit test will be calling kunit_find_named_resource() from a context with disabled interrupts. That means kunit's test->lock needs to be IRQ safe to avoid potential deadlocks and lockdep splats.

This patch therefore changes the test->lock usage to spin_lock_irqsave() and spin_unlock_irqrestore().

Note v4 had

and it's unchanged AFAIK.