10 files changed, 531 insertions, 91 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index a858b55e8ac7..bc6673ab3a08 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2076,6 +2076,14 @@ config TEST_STACKINIT
 
           If unsure, say N.
 
+config TEST_MEMINIT
+        tristate "Test heap/page initialization"
+        help
+          Test if the kernel is zero-initializing heap and page allocations.
+          This can be useful to test init_on_alloc and init_on_free features.
+
+          If unsure, say N.
+
 endif # RUNTIME_TESTING_MENU
 
 config MEMTEST
diff --git a/lib/Makefile b/lib/Makefile
index fdd56bc219b8..59067f51f3ab 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -92,6 +92,7 @@ obj-$(CONFIG_TEST_MEMCAT_P) += test_memcat_p.o
 obj-$(CONFIG_TEST_OBJAGG) += test_objagg.o
 obj-$(CONFIG_TEST_STACKINIT) += test_stackinit.o
 obj-$(CONFIG_TEST_BLACKHOLE_DEV) += test_blackhole_dev.o
+obj-$(CONFIG_TEST_MEMINIT) += test_meminit.o
 
 obj-$(CONFIG_TEST_LIVEPATCH) += livepatch/
 
diff --git a/lib/ioremap.c b/lib/ioremap.c
index 063213685563..0a2ffadc6d71 100644
--- a/lib/ioremap.c
+++ b/lib/ioremap.c
@@ -30,6 +30,8 @@ early_param("nohugeiomap", set_nohugeiomap);
 void __init ioremap_huge_init(void)
 {
         if (!ioremap_huge_disabled) {
+                if (arch_ioremap_p4d_supported())
+                        ioremap_p4d_capable = 1;
                 if (arch_ioremap_pud_supported())
                         ioremap_pud_capable = 1;
                 if (arch_ioremap_pmd_supported())
@@ -86,6 +88,9 @@ static int ioremap_try_huge_pmd(pmd_t *pmd, unsigned long addr,
         if ((end - addr) != PMD_SIZE)
                 return 0;
 
+        if (!IS_ALIGNED(addr, PMD_SIZE))
+                return 0;
+
         if (!IS_ALIGNED(phys_addr, PMD_SIZE))
                 return 0;
 
@@ -126,6 +131,9 @@ static int ioremap_try_huge_pud(pud_t *pud, unsigned long addr,
         if ((end - addr) != PUD_SIZE)
                 return 0;
 
+        if (!IS_ALIGNED(addr, PUD_SIZE))
+                return 0;
+
         if (!IS_ALIGNED(phys_addr, PUD_SIZE))
                 return 0;
 
@@ -166,6 +174,9 @@ static int ioremap_try_huge_p4d(p4d_t *p4d, unsigned long addr,
         if ((end - addr) != P4D_SIZE)
                 return 0;
 
+        if (!IS_ALIGNED(addr, P4D_SIZE))
+                return 0;
+
         if (!IS_ALIGNED(phys_addr, P4D_SIZE))
                 return 0;
 
diff --git a/lib/mpi/longlong.h b/lib/mpi/longlong.h
index 08c60d10747f..3bb6260d8f42 100644
--- a/lib/mpi/longlong.h
+++ b/lib/mpi/longlong.h
@@ -397,8 +397,8 @@ do { \
 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
         __asm__ ("addl %5,%1\n" \
            "adcl %3,%0" \
-        : "=r" ((USItype)(sh)), \
-             "=&r" ((USItype)(sl)) \
+        : "=r" (sh), \
+             "=&r" (sl) \
         : "%0" ((USItype)(ah)), \
              "g" ((USItype)(bh)), \
              "%1" ((USItype)(al)), \
@@ -406,22 +406,22 @@ do { \
 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
         __asm__ ("subl %5,%1\n" \
            "sbbl %3,%0" \
-        : "=r" ((USItype)(sh)), \
-             "=&r" ((USItype)(sl)) \
+        : "=r" (sh), \
+             "=&r" (sl) \
         : "0" ((USItype)(ah)), \
              "g" ((USItype)(bh)), \
              "1" ((USItype)(al)), \
              "g" ((USItype)(bl)))
 #define umul_ppmm(w1, w0, u, v) \
         __asm__ ("mull %3" \
-        : "=a" ((USItype)(w0)), \
-             "=d" ((USItype)(w1)) \
+        : "=a" (w0), \
+             "=d" (w1) \
         : "%0" ((USItype)(u)), \
              "rm" ((USItype)(v)))
 #define udiv_qrnnd(q, r, n1, n0, d) \
         __asm__ ("divl %4" \
-        : "=a" ((USItype)(q)), \
-             "=d" ((USItype)(r)) \
+        : "=a" (q), \
+             "=d" (r) \
         : "0" ((USItype)(n0)), \
              "1" ((USItype)(n1)), \
              "rm" ((USItype)(d)))
diff --git a/lib/rbtree.c b/lib/rbtree.c
index 1ef6e25d031c..abc86c6a3177 100644
--- a/lib/rbtree.c
+++ b/lib/rbtree.c
@@ -83,14 +83,10 @@ __rb_rotate_set_parents(struct rb_node *old, struct rb_node *new,
 
 static __always_inline void
 __rb_insert(struct rb_node *node, struct rb_root *root,
-            bool newleft, struct rb_node **leftmost,
             void (*augment_rotate)(struct rb_node *old, struct rb_node *new))
 {
         struct rb_node *parent = rb_red_parent(node), *gparent, *tmp;
 
-        if (newleft)
-                *leftmost = node;
-
         while (true) {
                 /*
                  * Loop invariant: node is red.
@@ -437,38 +433,19 @@ static const struct rb_augment_callbacks dummy_callbacks = {
 
 void rb_insert_color(struct rb_node *node, struct rb_root *root)
 {
-        __rb_insert(node, root, false, NULL, dummy_rotate);
+        __rb_insert(node, root, dummy_rotate);
 }
 EXPORT_SYMBOL(rb_insert_color);
 
 void rb_erase(struct rb_node *node, struct rb_root *root)
 {
         struct rb_node *rebalance;
-        rebalance = __rb_erase_augmented(node, root,
-                                         NULL, &dummy_callbacks);
+        rebalance = __rb_erase_augmented(node, root, &dummy_callbacks);
         if (rebalance)
                 ____rb_erase_color(rebalance, root, dummy_rotate);
 }
 EXPORT_SYMBOL(rb_erase);
 
-void rb_insert_color_cached(struct rb_node *node,
-                            struct rb_root_cached *root, bool leftmost)
-{
-        __rb_insert(node, &root->rb_root, leftmost,
-                    &root->rb_leftmost, dummy_rotate);
-}
-EXPORT_SYMBOL(rb_insert_color_cached);
-
-void rb_erase_cached(struct rb_node *node, struct rb_root_cached *root)
-{
-        struct rb_node *rebalance;
-        rebalance = __rb_erase_augmented(node, &root->rb_root,
-                                         &root->rb_leftmost, &dummy_callbacks);
-        if (rebalance)
-                ____rb_erase_color(rebalance, &root->rb_root, dummy_rotate);
-}
-EXPORT_SYMBOL(rb_erase_cached);
-
 /*
  * Augmented rbtree manipulation functions.
  *
@@ -477,10 +454,9 @@ EXPORT_SYMBOL(rb_erase_cached);
  */
 
 void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
-                           bool newleft, struct rb_node **leftmost,
         void (*augment_rotate)(struct rb_node *old, struct rb_node *new))
 {
-        __rb_insert(node, root, newleft, leftmost, augment_rotate);
+        __rb_insert(node, root, augment_rotate);
 }
 EXPORT_SYMBOL(__rb_insert_augmented);
 
@@ -591,16 +567,6 @@ void rb_replace_node(struct rb_node *victim, struct rb_node *new,
 }
 EXPORT_SYMBOL(rb_replace_node);
 
-void rb_replace_node_cached(struct rb_node *victim, struct rb_node *new,
-                            struct rb_root_cached *root)
-{
-        rb_replace_node(victim, new, &root->rb_root);
-
-        if (root->rb_leftmost == victim)
-                root->rb_leftmost = new;
-}
-EXPORT_SYMBOL(rb_replace_node_cached);
-
 void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
                          struct rb_root *root)
 {
diff --git a/lib/string.c b/lib/string.c
index 6016eb3ac73d..461fb620f85f 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -400,6 +400,9 @@ EXPORT_SYMBOL(strncmp);
  * strchr - Find the first occurrence of a character in a string
  * @s: The string to be searched
  * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
  */
 char *strchr(const char *s, int c)
 {
@@ -453,12 +456,18 @@ EXPORT_SYMBOL(strrchr);
  * @s: The string to be searched
  * @count: The number of characters to be searched
  * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
  */
 char *strnchr(const char *s, size_t count, int c)
 {
-        for (; count-- && *s != '\0'; ++s)
+        while (count--) {
                 if (*s == (char)c)
                         return (char *)s;
+                if (*s++ == '\0')
+                        break;
+        }
         return NULL;
 }
 EXPORT_SYMBOL(strnchr);
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 3a90a9e2b94a..963050c0283e 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -231,35 +231,36 @@ static bool unescape_special(char **src, char **dst)
  * @src:        source buffer (escaped)
  * @dst:        destination buffer (unescaped)
  * @size:       size of the destination buffer (0 to unlimit)
- * @flags:      combination of the flags (bitwise OR):
- *      %UNESCAPE_SPACE:
+ * @flags:      combination of the flags.
+ *
+ * Description:
+ * The function unquotes characters in the given string.
+ *
+ * Because the size of the output will be the same as or less than the size of
+ * the input, the transformation may be performed in place.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will always be NULL-terminated. Source string must be
+ * NULL-terminated as well.  The supported flags are::
+ *
+ *      UNESCAPE_SPACE:
  *              '\f' - form feed
  *              '\n' - new line
  *              '\r' - carriage return
  *              '\t' - horizontal tab
  *              '\v' - vertical tab
- *      %UNESCAPE_OCTAL:
+ *      UNESCAPE_OCTAL:
  *              '\NNN' - byte with octal value NNN (1 to 3 digits)
- *      %UNESCAPE_HEX:
+ *      UNESCAPE_HEX:
  *              '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
- *      %UNESCAPE_SPECIAL:
+ *      UNESCAPE_SPECIAL:
  *              '\"' - double quote
  *              '\\' - backslash
  *              '\a' - alert (BEL)
  *              '\e' - escape
- *      %UNESCAPE_ANY:
+ *      UNESCAPE_ANY:
  *              all previous together
  *
- * Description:
- * The function unquotes characters in the given string.
- *
- * Because the size of the output will be the same as or less than the size of
- * the input, the transformation may be performed in place.
- *
- * Caller must provide valid source and destination pointers. Be aware that
- * destination buffer will always be NULL-terminated. Source string must be
- * NULL-terminated as well.
- *
  * Return:
  * The amount of the characters processed to the destination buffer excluding
  * trailing '\0' is returned.
@@ -441,7 +442,29 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
  * @isz:        source buffer size
  * @dst:        destination buffer (escaped)
  * @osz:        destination buffer size
- * @flags:      combination of the flags (bitwise OR):
+ * @flags:      combination of the flags
+ * @only:       NULL-terminated string containing characters used to limit
+ *              the selected escape class. If characters are included in @only
+ *              that would not normally be escaped by the classes selected
+ *              in @flags, they will be copied to @dst unescaped.
+ *
+ * Description:
+ * The process of escaping byte buffer includes several parts. They are applied
+ * in the following sequence.
+ *
+ *      1. The character is matched to the printable class, if asked, and in
+ *         case of match it passes through to the output.
+ *      2. The character is not matched to the one from @only string and thus
+ *         must go as-is to the output.
+ *      3. The character is checked if it falls into the class given by @flags.
+ *         %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
+ *         character. Note that they actually can't go together, otherwise
+ *         %ESCAPE_HEX will be ignored.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will not be NULL-terminated, thus caller have to append
+ * it if needs.   The supported flags are::
+ *
  *      %ESCAPE_SPACE: (special white space, not space itself)
  *              '\f' - form feed
  *              '\n' - new line
@@ -464,26 +487,6 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
  *              all previous together
  *      %ESCAPE_HEX:
  *              '\xHH' - byte with hexadecimal value HH (2 digits)
- * @only:       NULL-terminated string containing characters used to limit
- *              the selected escape class. If characters are included in @only
- *              that would not normally be escaped by the classes selected
- *              in @flags, they will be copied to @dst unescaped.
- *
- * Description:
- * The process of escaping byte buffer includes several parts. They are applied
- * in the following sequence.
- *      1. The character is matched to the printable class, if asked, and in
- *         case of match it passes through to the output.
- *      2. The character is not matched to the one from @only string and thus
- *         must go as-is to the output.
- *      3. The character is checked if it falls into the class given by @flags.
- *         %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
- *         character. Note that they actually can't go together, otherwise
- *         %ESCAPE_HEX will be ignored.
- *
- * Caller must provide valid source and destination pointers. Be aware that
- * destination buffer will not be NULL-terminated, thus caller have to append
- * it if needs.
  *
  * Return:
  * The total size of the escaped output that would be generated for
diff --git a/lib/test_meminit.c b/lib/test_meminit.c
new file mode 100644
index 000000000000..62d19f270cad
--- /dev/null
+++ b/lib/test_meminit.c
@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Test cases for SL[AOU]B/page initialization at alloc/free time.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/vmalloc.h>
+
+#define GARBAGE_INT (0x09A7BA9E)
+#define GARBAGE_BYTE (0x9E)
+
+#define REPORT_FAILURES_IN_FN() \
+        do {    \
+                if (failures)   \
+                        pr_info("%s failed %d out of %d times\n",       \
+                                __func__, failures, num_tests);         \
+                else            \
+                        pr_info("all %d tests in %s passed\n",          \
+                                num_tests, __func__);                   \
+        } while (0)
+
+/* Calculate the number of uninitialized bytes in the buffer. */
+static int __init count_nonzero_bytes(void *ptr, size_t size)
+{
+        int i, ret = 0;
+        unsigned char *p = (unsigned char *)ptr;
+
+        for (i = 0; i < size; i++)
+                if (p[i])
+                        ret++;
+        return ret;
+}
+
+/* Fill a buffer with garbage, skipping |skip| first bytes. */
+static void __init fill_with_garbage_skip(void *ptr, int size, size_t skip)
+{
+        unsigned int *p = (unsigned int *)((char *)ptr + skip);
+        int i = 0;
+
+        WARN_ON(skip > size);
+        size -= skip;
+
+        while (size >= sizeof(*p)) {
+                p[i] = GARBAGE_INT;
+                i++;
+                size -= sizeof(*p);
+        }
+        if (size)
+                memset(&p[i], GARBAGE_BYTE, size);
+}
+
+static void __init fill_with_garbage(void *ptr, size_t size)
+{
+        fill_with_garbage_skip(ptr, size, 0);
+}
+
+static int __init do_alloc_pages_order(int order, int *total_failures)
+{
+        struct page *page;
+        void *buf;
+        size_t size = PAGE_SIZE << order;
+
+        page = alloc_pages(GFP_KERNEL, order);
+        buf = page_address(page);
+        fill_with_garbage(buf, size);
+        __free_pages(page, order);
+
+        page = alloc_pages(GFP_KERNEL, order);
+        buf = page_address(page);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        __free_pages(page, order);
+        return 1;
+}
+
+/* Test the page allocator by calling alloc_pages with different orders. */
+static int __init test_pages(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i;
+
+        for (i = 0; i < 10; i++)
+                num_tests += do_alloc_pages_order(i, &failures);
+
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+
+/* Test kmalloc() with given parameters. */
+static int __init do_kmalloc_size(size_t size, int *total_failures)
+{
+        void *buf;
+
+        buf = kmalloc(size, GFP_KERNEL);
+        fill_with_garbage(buf, size);
+        kfree(buf);
+
+        buf = kmalloc(size, GFP_KERNEL);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        kfree(buf);
+        return 1;
+}
+
+/* Test vmalloc() with given parameters. */
+static int __init do_vmalloc_size(size_t size, int *total_failures)
+{
+        void *buf;
+
+        buf = vmalloc(size);
+        fill_with_garbage(buf, size);
+        vfree(buf);
+
+        buf = vmalloc(size);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        vfree(buf);
+        return 1;
+}
+
+/* Test kmalloc()/vmalloc() by allocating objects of different sizes. */
+static int __init test_kvmalloc(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, size;
+
+        for (i = 0; i < 20; i++) {
+                size = 1 << i;
+                num_tests += do_kmalloc_size(size, &failures);
+                num_tests += do_vmalloc_size(size, &failures);
+        }
+
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+
+#define CTOR_BYTES (sizeof(unsigned int))
+#define CTOR_PATTERN (0x41414141)
+/* Initialize the first 4 bytes of the object. */
+static void test_ctor(void *obj)
+{
+        *(unsigned int *)obj = CTOR_PATTERN;
+}
+
+/*
+ * Check the invariants for the buffer allocated from a slab cache.
+ * If the cache has a test constructor, the first 4 bytes of the object must
+ * always remain equal to CTOR_PATTERN.
+ * If the cache isn't an RCU-typesafe one, or if the allocation is done with
+ * __GFP_ZERO, then the object contents must be zeroed after allocation.
+ * If the cache is an RCU-typesafe one, the object contents must never be
+ * zeroed after the first use. This is checked by memcmp() in
+ * do_kmem_cache_size().
+ */
+static bool __init check_buf(void *buf, int size, bool want_ctor,
+                             bool want_rcu, bool want_zero)
+{
+        int bytes;
+        bool fail = false;
+
+        bytes = count_nonzero_bytes(buf, size);
+        WARN_ON(want_ctor && want_zero);
+        if (want_zero)
+                return bytes;
+        if (want_ctor) {
+                if (*(unsigned int *)buf != CTOR_PATTERN)
+                        fail = 1;
+        } else {
+                if (bytes)
+                        fail = !want_rcu;
+        }
+        return fail;
+}
+
+/*
+ * Test kmem_cache with given parameters:
+ *  want_ctor - use a constructor;
+ *  want_rcu - use SLAB_TYPESAFE_BY_RCU;
+ *  want_zero - use __GFP_ZERO.
+ */
+static int __init do_kmem_cache_size(size_t size, bool want_ctor,
+                                     bool want_rcu, bool want_zero,
+                                     int *total_failures)
+{
+        struct kmem_cache *c;
+        int iter;
+        bool fail = false;
+        gfp_t alloc_mask = GFP_KERNEL | (want_zero ? __GFP_ZERO : 0);
+        void *buf, *buf_copy;
+
+        c = kmem_cache_create("test_cache", size, 1,
+                              want_rcu ? SLAB_TYPESAFE_BY_RCU : 0,
+                              want_ctor ? test_ctor : NULL);
+        for (iter = 0; iter < 10; iter++) {
+                buf = kmem_cache_alloc(c, alloc_mask);
+                /* Check that buf is zeroed, if it must be. */
+                fail = check_buf(buf, size, want_ctor, want_rcu, want_zero);
+                fill_with_garbage_skip(buf, size, want_ctor ? CTOR_BYTES : 0);
+
+                if (!want_rcu) {
+                        kmem_cache_free(c, buf);
+                        continue;
+                }
+
+                /*
+                 * If this is an RCU cache, use a critical section to ensure we
+                 * can touch objects after they're freed.
+                 */
+                rcu_read_lock();
+                /*
+                 * Copy the buffer to check that it's not wiped on
+                 * free().
+                 */
+                buf_copy = kmalloc(size, GFP_KERNEL);
+                if (buf_copy)
+                        memcpy(buf_copy, buf, size);
+
+                kmem_cache_free(c, buf);
+                /*
+                 * Check that |buf| is intact after kmem_cache_free().
+                 * |want_zero| is false, because we wrote garbage to
+                 * the buffer already.
+                 */
+                fail |= check_buf(buf, size, want_ctor, want_rcu,
+                                  false);
+                if (buf_copy) {
+                        fail |= (bool)memcmp(buf, buf_copy, size);
+                        kfree(buf_copy);
+                }
+                rcu_read_unlock();
+        }
+        kmem_cache_destroy(c);
+
+        *total_failures += fail;
+        return 1;
+}
+
+/*
+ * Check that the data written to an RCU-allocated object survives
+ * reallocation.
+ */
+static int __init do_kmem_cache_rcu_persistent(int size, int *total_failures)
+{
+        struct kmem_cache *c;
+        void *buf, *buf_contents, *saved_ptr;
+        void **used_objects;
+        int i, iter, maxiter = 1024;
+        bool fail = false;
+
+        c = kmem_cache_create("test_cache", size, size, SLAB_TYPESAFE_BY_RCU,
+                              NULL);
+        buf = kmem_cache_alloc(c, GFP_KERNEL);
+        saved_ptr = buf;
+        fill_with_garbage(buf, size);
+        buf_contents = kmalloc(size, GFP_KERNEL);
+        if (!buf_contents)
+                goto out;
+        used_objects = kmalloc_array(maxiter, sizeof(void *), GFP_KERNEL);
+        if (!used_objects) {
+                kfree(buf_contents);
+                goto out;
+        }
+        memcpy(buf_contents, buf, size);
+        kmem_cache_free(c, buf);
+        /*
+         * Run for a fixed number of iterations. If we never hit saved_ptr,
+         * assume the test passes.
+         */
+        for (iter = 0; iter < maxiter; iter++) {
+                buf = kmem_cache_alloc(c, GFP_KERNEL);
+                used_objects[iter] = buf;
+                if (buf == saved_ptr) {
+                        fail = memcmp(buf_contents, buf, size);
+                        for (i = 0; i <= iter; i++)
+                                kmem_cache_free(c, used_objects[i]);
+                        goto free_out;
+                }
+        }
+
+free_out:
+        kmem_cache_destroy(c);
+        kfree(buf_contents);
+        kfree(used_objects);
+out:
+        *total_failures += fail;
+        return 1;
+}
+
+/*
+ * Test kmem_cache allocation by creating caches of different sizes, with and
+ * without constructors, with and without SLAB_TYPESAFE_BY_RCU.
+ */
+static int __init test_kmemcache(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, flags, size;
+        bool ctor, rcu, zero;
+
+        for (i = 0; i < 10; i++) {
+                size = 8 << i;
+                for (flags = 0; flags < 8; flags++) {
+                        ctor = flags & 1;
+                        rcu = flags & 2;
+                        zero = flags & 4;
+                        if (ctor & zero)
+                                continue;
+                        num_tests += do_kmem_cache_size(size, ctor, rcu, zero,
+                                                        &failures);
+                }
+        }
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+
+/* Test the behavior of SLAB_TYPESAFE_BY_RCU caches of different sizes. */
+static int __init test_rcu_persistent(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, size;
+
+        for (i = 0; i < 10; i++) {
+                size = 8 << i;
+                num_tests += do_kmem_cache_rcu_persistent(size, &failures);
+        }
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+
+/*
+ * Run the tests. Each test function returns the number of executed tests and
+ * updates |failures| with the number of failed tests.
+ */
+static int __init test_meminit_init(void)
+{
+        int failures = 0, num_tests = 0;
+
+        num_tests += test_pages(&failures);
+        num_tests += test_kvmalloc(&failures);
+        num_tests += test_kmemcache(&failures);
+        num_tests += test_rcu_persistent(&failures);
+
+        if (failures == 0)
+                pr_info("all %d tests passed!\n", num_tests);
+        else
+                pr_info("failures: %d out of %d\n", failures, num_tests);
+
+        return failures ? -EINVAL : 0;
+}
+module_init(test_meminit_init);
+
+MODULE_LICENSE("GPL");
diff --git a/lib/test_overflow.c b/lib/test_overflow.c
index fc680562d8b6..7a4b6f6c5473 100644
--- a/lib/test_overflow.c
+++ b/lib/test_overflow.c
@@ -486,16 +486,17 @@ static int __init test_overflow_shift(void)
  * Deal with the various forms of allocator arguments. See comments above
  * the DEFINE_TEST_ALLOC() instances for mapping of the "bits".
  */
-#define alloc010(alloc, arg, sz) alloc(sz, GFP_KERNEL)
-#define alloc011(alloc, arg, sz) alloc(sz, GFP_KERNEL, NUMA_NO_NODE)
+#define alloc_GFP                (GFP_KERNEL | __GFP_NOWARN)
+#define alloc010(alloc, arg, sz) alloc(sz, alloc_GFP)
+#define alloc011(alloc, arg, sz) alloc(sz, alloc_GFP, NUMA_NO_NODE)
 #define alloc000(alloc, arg, sz) alloc(sz)
 #define alloc001(alloc, arg, sz) alloc(sz, NUMA_NO_NODE)
-#define alloc110(alloc, arg, sz) alloc(arg, sz, GFP_KERNEL)
+#define alloc110(alloc, arg, sz) alloc(arg, sz, alloc_GFP)
 #define free0(free, arg, ptr)    free(ptr)
 #define free1(free, arg, ptr)    free(arg, ptr)
 
-/* Wrap around to 8K */
-#define TEST_SIZE               (9 << PAGE_SHIFT)
+/* Wrap around to 16K */
+#define TEST_SIZE               (5 * 4096)
 
 #define DEFINE_TEST_ALLOC(func, free_func, want_arg, want_gfp, want_node)\
 static int __init test_ ## func (void *arg)                             \
diff --git a/lib/test_string.c b/lib/test_string.c
index bf8def01ed20..7b31f4a505bf 100644
--- a/lib/test_string.c
+++ b/lib/test_string.c
@@ -36,7 +36,7 @@ static __init int memset16_selftest(void)
 fail:
         kfree(p);
         if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
         return 0;
 }
 
@@ -72,7 +72,7 @@ static __init int memset32_selftest(void)
 fail:
         kfree(p);
         if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
         return 0;
 }
 
@@ -108,7 +108,74 @@ static __init int memset64_selftest(void)
 fail:
         kfree(p);
         if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
+        return 0;
+}
+
+static __init int strchr_selftest(void)
+{
+        const char *test_string = "abcdefghijkl";
+        const char *empty_string = "";
+        char *result;
+        int i;
+
+        for (i = 0; i < strlen(test_string) + 1; i++) {
+                result = strchr(test_string, test_string[i]);
+                if (result - test_string != i)
+                        return i + 'a';
+        }
+
+        result = strchr(empty_string, '\0');
+        if (result != empty_string)
+                return 0x101;
+
+        result = strchr(empty_string, 'a');
+        if (result)
+                return 0x102;
+
+        result = strchr(test_string, 'z');
+        if (result)
+                return 0x103;
+
+        return 0;
+}
+
+static __init int strnchr_selftest(void)
+{
+        const char *test_string = "abcdefghijkl";
+        const char *empty_string = "";
+        char *result;
+        int i, j;
+
+        for (i = 0; i < strlen(test_string) + 1; i++) {
+                for (j = 0; j < strlen(test_string) + 2; j++) {
+                        result = strnchr(test_string, j, test_string[i]);
+                        if (j <= i) {
+                                if (!result)
+                                        continue;
+                                return ((i + 'a') << 8) | j;
+                        }
+                        if (result - test_string != i)
+                                return ((i + 'a') << 8) | j;
+                }
+        }
+
+        result = strnchr(empty_string, 0, '\0');
+        if (result)
+                return 0x10001;
+
+        result = strnchr(empty_string, 1, '\0');
+        if (result != empty_string)
+                return 0x10002;
+
+        result = strnchr(empty_string, 1, 'a');
+        if (result)
+                return 0x10003;
+
+        result = strnchr(NULL, 0, '\0');
+        if (result)
+                return 0x10004;
+
         return 0;
 }
 
@@ -131,6 +198,16 @@ static __init int string_selftest_init(void)
         if (subtest)
                 goto fail;
 
+        test = 4;
+        subtest = strchr_selftest();
+        if (subtest)
+                goto fail;
+
+        test = 5;
+        subtest = strnchr_selftest();
+        if (subtest)
+                goto fail;
+
         pr_info("String selftests succeeded\n");
         return 0;
 fail: