8 files changed, 126 insertions, 75 deletions

diff --git a/lib/assoc_array.c b/lib/assoc_array.c
index c6659cb37033..59875eb278ea 100644
--- a/lib/assoc_array.c
+++ b/lib/assoc_array.c
@@ -768,9 +768,11 @@ all_leaves_cluster_together:
                 new_s0->index_key[i] =
                         ops->get_key_chunk(index_key, i * ASSOC_ARRAY_KEY_CHUNK_SIZE);
 
-        blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
-        pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
-        new_s0->index_key[keylen - 1] &= ~blank;
+        if (level & ASSOC_ARRAY_KEY_CHUNK_MASK) {
+                blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
+                pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
+                new_s0->index_key[keylen - 1] &= ~blank;
+        }
 
         /* This now reduces to a node splitting exercise for which we'll need
          * to regenerate the disparity table.
diff --git a/lib/crc32.c b/lib/crc32.c
index 45b1d67a1767..4a20455d1f61 100644
--- a/lib/crc32.c
+++ b/lib/crc32.c
@@ -206,8 +206,8 @@ u32 __pure __weak __crc32c_le(u32 crc, unsigned char const *p, size_t len)
 EXPORT_SYMBOL(crc32_le);
 EXPORT_SYMBOL(__crc32c_le);
 
-u32 crc32_le_base(u32, unsigned char const *, size_t) __alias(crc32_le);
-u32 __crc32c_le_base(u32, unsigned char const *, size_t) __alias(__crc32c_le);
+u32 __pure crc32_le_base(u32, unsigned char const *, size_t) __alias(crc32_le);
+u32 __pure __crc32c_le_base(u32, unsigned char const *, size_t) __alias(__crc32c_le);
 
 /*
  * This multiplies the polynomials x and y modulo the given modulus.
diff --git a/lib/int_sqrt.c b/lib/int_sqrt.c
index 14436f4ca6bd..30e0f9770f88 100644
--- a/lib/int_sqrt.c
+++ b/lib/int_sqrt.c
@@ -52,7 +52,7 @@ u32 int_sqrt64(u64 x)
         if (x <= ULONG_MAX)
                 return int_sqrt((unsigned long) x);
 
-        m = 1ULL << (fls64(x) & ~1ULL);
+        m = 1ULL << ((fls64(x) - 1) & ~1ULL);
         while (m != 0) {
                 b = y + m;
                 y >>= 1;
diff --git a/lib/sbitmap.c b/lib/sbitmap.c
index 65c2d06250a6..5b382c1244ed 100644
--- a/lib/sbitmap.c
+++ b/lib/sbitmap.c
@@ -26,14 +26,10 @@
 static inline bool sbitmap_deferred_clear(struct sbitmap *sb, int index)
 {
         unsigned long mask, val;
-        unsigned long __maybe_unused flags;
         bool ret = false;
+        unsigned long flags;
 
-        /* Silence bogus lockdep warning */
-#if defined(CONFIG_LOCKDEP)
-        local_irq_save(flags);
-#endif
-        spin_lock(&sb->map[index].swap_lock);
+        spin_lock_irqsave(&sb->map[index].swap_lock, flags);
 
         if (!sb->map[index].cleared)
                 goto out_unlock;
@@ -54,10 +50,7 @@ static inline bool sbitmap_deferred_clear(struct sbitmap *sb, int index)
 
         ret = true;
 out_unlock:
-        spin_unlock(&sb->map[index].swap_lock);
-#if defined(CONFIG_LOCKDEP)
-        local_irq_restore(flags);
-#endif
+        spin_unlock_irqrestore(&sb->map[index].swap_lock, flags);
         return ret;
 }
 
diff --git a/lib/test_kmod.c b/lib/test_kmod.c
index d82d022111e0..9cf77628fc91 100644
--- a/lib/test_kmod.c
+++ b/lib/test_kmod.c
@@ -632,7 +632,7 @@ static void __kmod_config_free(struct test_config *config)
         config->test_driver = NULL;
 
         kfree_const(config->test_fs);
-        config->test_driver = NULL;
+        config->test_fs = NULL;
 }
 
 static void kmod_config_free(struct kmod_test_device *test_dev)
diff --git a/lib/test_rhashtable.c b/lib/test_rhashtable.c
index 6a8ac7626797..e52f8cafe227 100644
--- a/lib/test_rhashtable.c
+++ b/lib/test_rhashtable.c
@@ -541,38 +541,45 @@ static unsigned int __init print_ht(struct rhltable *rhlt)
 static int __init test_insert_dup(struct test_obj_rhl *rhl_test_objects,
                                   int cnt, bool slow)
 {
-        struct rhltable rhlt;
+        struct rhltable *rhlt;
         unsigned int i, ret;
         const char *key;
         int err = 0;
 
-        err = rhltable_init(&rhlt, &test_rht_params_dup);
-        if (WARN_ON(err))
+        rhlt = kmalloc(sizeof(*rhlt), GFP_KERNEL);
+        if (WARN_ON(!rhlt))
+                return -EINVAL;
+
+        err = rhltable_init(rhlt, &test_rht_params_dup);
+        if (WARN_ON(err)) {
+                kfree(rhlt);
                 return err;
+        }
 
         for (i = 0; i < cnt; i++) {
                 rhl_test_objects[i].value.tid = i;
-                key = rht_obj(&rhlt.ht, &rhl_test_objects[i].list_node.rhead);
+                key = rht_obj(&rhlt->ht, &rhl_test_objects[i].list_node.rhead);
                 key += test_rht_params_dup.key_offset;
 
                 if (slow) {
-                        err = PTR_ERR(rhashtable_insert_slow(&rhlt.ht, key,
+                        err = PTR_ERR(rhashtable_insert_slow(&rhlt->ht, key,
                                                              &rhl_test_objects[i].list_node.rhead));
                         if (err == -EAGAIN)
                                 err = 0;
                 } else
-                        err = rhltable_insert(&rhlt,
+                        err = rhltable_insert(rhlt,
                                               &rhl_test_objects[i].list_node,
                                               test_rht_params_dup);
                 if (WARN(err, "error %d on element %d/%d (%s)\n", err, i, cnt, slow? "slow" : "fast"))
                         goto skip_print;
         }
 
-        ret = print_ht(&rhlt);
+        ret = print_ht(rhlt);
         WARN(ret != cnt, "missing rhltable elements (%d != %d, %s)\n", ret, cnt, slow? "slow" : "fast");
 
 skip_print:
-        rhltable_destroy(&rhlt);
+        rhltable_destroy(rhlt);
+        kfree(rhlt);
 
         return 0;
 }
diff --git a/lib/test_xarray.c b/lib/test_xarray.c
index 4676c0a1eeca..c596a957f764 100644
--- a/lib/test_xarray.c
+++ b/lib/test_xarray.c
@@ -199,7 +199,7 @@ static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
                 XA_BUG_ON(xa, xa_store_index(xa, index + 1, GFP_KERNEL));
                 xa_set_mark(xa, index + 1, XA_MARK_0);
                 XA_BUG_ON(xa, xa_store_index(xa, index + 2, GFP_KERNEL));
-                xa_set_mark(xa, index + 2, XA_MARK_1);
+                xa_set_mark(xa, index + 2, XA_MARK_2);
                 XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL));
                 xa_store_order(xa, index, order, xa_mk_index(index),
                                 GFP_KERNEL);
@@ -209,8 +209,8 @@ static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
                         void *entry;
 
                         XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
-                        XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_1));
-                        XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_2));
+                        XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_1));
+                        XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_2));
 
                         /* We should see two elements in the array */
                         rcu_read_lock();
@@ -357,7 +357,7 @@ static noinline void check_cmpxchg(struct xarray *xa)
 static noinline void check_reserve(struct xarray *xa)
 {
         void *entry;
-        unsigned long index = 0;
+        unsigned long index;
 
         /* An array with a reserved entry is not empty */
         XA_BUG_ON(xa, !xa_empty(xa));
@@ -382,10 +382,12 @@ static noinline void check_reserve(struct xarray *xa)
         xa_erase_index(xa, 12345678);
         XA_BUG_ON(xa, !xa_empty(xa));
 
-        /* And so does xa_insert */
+        /* But xa_insert does not */
         xa_reserve(xa, 12345678, GFP_KERNEL);
-        XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) != 0);
-        xa_erase_index(xa, 12345678);
+        XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) !=
+                        -EEXIST);
+        XA_BUG_ON(xa, xa_empty(xa));
+        XA_BUG_ON(xa, xa_erase(xa, 12345678) != NULL);
         XA_BUG_ON(xa, !xa_empty(xa));
 
         /* Can iterate through a reserved entry */
@@ -393,7 +395,7 @@ static noinline void check_reserve(struct xarray *xa)
         xa_reserve(xa, 6, GFP_KERNEL);
         xa_store_index(xa, 7, GFP_KERNEL);
 
-        xa_for_each(xa, entry, index, ULONG_MAX, XA_PRESENT) {
+        xa_for_each(xa, index, entry) {
                 XA_BUG_ON(xa, index != 5 && index != 7);
         }
         xa_destroy(xa);
@@ -812,17 +814,16 @@ static noinline void check_find_1(struct xarray *xa)
 static noinline void check_find_2(struct xarray *xa)
 {
         void *entry;
-        unsigned long i, j, index = 0;
+        unsigned long i, j, index;
 
-        xa_for_each(xa, entry, index, ULONG_MAX, XA_PRESENT) {
+        xa_for_each(xa, index, entry) {
                 XA_BUG_ON(xa, true);
         }
 
         for (i = 0; i < 1024; i++) {
                 xa_store_index(xa, index, GFP_KERNEL);
                 j = 0;
-                index = 0;
-                xa_for_each(xa, entry, index, ULONG_MAX, XA_PRESENT) {
+                xa_for_each(xa, index, entry) {
                         XA_BUG_ON(xa, xa_mk_index(index) != entry);
                         XA_BUG_ON(xa, index != j++);
                 }
@@ -839,6 +840,7 @@ static noinline void check_find_3(struct xarray *xa)
 
         for (i = 0; i < 100; i++) {
                 for (j = 0; j < 100; j++) {
+                        rcu_read_lock();
                         for (k = 0; k < 100; k++) {
                                 xas_set(&xas, j);
                                 xas_for_each_marked(&xas, entry, k, XA_MARK_0)
@@ -847,6 +849,7 @@ static noinline void check_find_3(struct xarray *xa)
                                         XA_BUG_ON(xa,
                                                 xas.xa_node != XAS_RESTART);
                         }
+                        rcu_read_unlock();
                 }
                 xa_store_index(xa, i, GFP_KERNEL);
                 xa_set_mark(xa, i, XA_MARK_0);
@@ -1183,6 +1186,35 @@ static noinline void check_store_range(struct xarray *xa)
         }
 }
 
+static void check_align_1(struct xarray *xa, char *name)
+{
+        int i;
+        unsigned int id;
+        unsigned long index;
+        void *entry;
+
+        for (i = 0; i < 8; i++) {
+                id = 0;
+                XA_BUG_ON(xa, xa_alloc(xa, &id, UINT_MAX, name + i, GFP_KERNEL)
+                                != 0);
+                XA_BUG_ON(xa, id != i);
+        }
+        xa_for_each(xa, index, entry)
+                XA_BUG_ON(xa, xa_is_err(entry));
+        xa_destroy(xa);
+}
+
+static noinline void check_align(struct xarray *xa)
+{
+        char name[] = "Motorola 68000";
+
+        check_align_1(xa, name);
+        check_align_1(xa, name + 1);
+        check_align_1(xa, name + 2);
+        check_align_1(xa, name + 3);
+//      check_align_2(xa, name);
+}
+
 static LIST_HEAD(shadow_nodes);
 
 static void test_update_node(struct xa_node *node)
@@ -1332,6 +1364,7 @@ static int xarray_checks(void)
         check_create_range(&array);
         check_store_range(&array);
         check_store_iter(&array);
+        check_align(&xa0);
 
         check_workingset(&array, 0);
         check_workingset(&array, 64);
diff --git a/lib/xarray.c b/lib/xarray.c
index 5f3f9311de89..81c3171ddde9 100644
--- a/lib/xarray.c
+++ b/lib/xarray.c
@@ -232,6 +232,8 @@ void *xas_load(struct xa_state *xas)
                 if (xas->xa_shift > node->shift)
                         break;
                 entry = xas_descend(xas, node);
+                if (node->shift == 0)
+                        break;
         }
         return entry;
 }
@@ -506,7 +508,7 @@ static void xas_free_nodes(struct xa_state *xas, struct xa_node *top)
         for (;;) {
                 void *entry = xa_entry_locked(xas->xa, node, offset);
 
-                if (xa_is_node(entry)) {
+                if (node->shift && xa_is_node(entry)) {
                         node = xa_to_node(entry);
                         offset = 0;
                         continue;
@@ -604,6 +606,7 @@ static int xas_expand(struct xa_state *xas, void *head)
 /*
  * xas_create() - Create a slot to store an entry in.
  * @xas: XArray operation state.
+ * @allow_root: %true if we can store the entry in the root directly
  *
  * Most users will not need to call this function directly, as it is called
  * by xas_store().  It is useful for doing conditional store operations
@@ -613,7 +616,7 @@ static int xas_expand(struct xa_state *xas, void *head)
  * If the slot was newly created, returns %NULL.  If it failed to create the
  * slot, returns %NULL and indicates the error in @xas.
  */
-static void *xas_create(struct xa_state *xas)
+static void *xas_create(struct xa_state *xas, bool allow_root)
 {
         struct xarray *xa = xas->xa;
         void *entry;
@@ -628,6 +631,8 @@ static void *xas_create(struct xa_state *xas)
                 shift = xas_expand(xas, entry);
                 if (shift < 0)
                         return NULL;
+                if (!shift && !allow_root)
+                        shift = XA_CHUNK_SHIFT;
                 entry = xa_head_locked(xa);
                 slot = &xa->xa_head;
         } else if (xas_error(xas)) {
@@ -687,7 +692,7 @@ void xas_create_range(struct xa_state *xas)
         xas->xa_sibs = 0;
 
         for (;;) {
-                xas_create(xas);
+                xas_create(xas, true);
                 if (xas_error(xas))
                         goto restore;
                 if (xas->xa_index <= (index | XA_CHUNK_MASK))
@@ -754,7 +759,7 @@ void *xas_store(struct xa_state *xas, void *entry)
         bool value = xa_is_value(entry);
 
         if (entry)
-                first = xas_create(xas);
+                first = xas_create(xas, !xa_is_node(entry));
         else
                 first = xas_load(xas);
 
@@ -1251,35 +1256,6 @@ void *xas_find_conflict(struct xa_state *xas)
 EXPORT_SYMBOL_GPL(xas_find_conflict);
 
 /**
- * xa_init_flags() - Initialise an empty XArray with flags.
- * @xa: XArray.
- * @flags: XA_FLAG values.
- *
- * If you need to initialise an XArray with special flags (eg you need
- * to take the lock from interrupt context), use this function instead
- * of xa_init().
- *
- * Context: Any context.
- */
-void xa_init_flags(struct xarray *xa, gfp_t flags)
-{
-        unsigned int lock_type;
-        static struct lock_class_key xa_lock_irq;
-        static struct lock_class_key xa_lock_bh;
-
-        spin_lock_init(&xa->xa_lock);
-        xa->xa_flags = flags;
-        xa->xa_head = NULL;
-
-        lock_type = xa_lock_type(xa);
-        if (lock_type == XA_LOCK_IRQ)
-                lockdep_set_class(&xa->xa_lock, &xa_lock_irq);
-        else if (lock_type == XA_LOCK_BH)
-                lockdep_set_class(&xa->xa_lock, &xa_lock_bh);
-}
-EXPORT_SYMBOL(xa_init_flags);
-
-/**
  * xa_load() - Load an entry from an XArray.
  * @xa: XArray.
  * @index: index into array.
@@ -1308,7 +1284,6 @@ static void *xas_result(struct xa_state *xas, void *curr)
 {
         if (xa_is_zero(curr))
                 return NULL;
-        XA_NODE_BUG_ON(xas->xa_node, xa_is_internal(curr));
         if (xas_error(xas))
                 curr = xas->xa_node;
         return curr;
@@ -1378,7 +1353,7 @@ void *__xa_store(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp)
         XA_STATE(xas, xa, index);
         void *curr;
 
-        if (WARN_ON_ONCE(xa_is_internal(entry)))
+        if (WARN_ON_ONCE(xa_is_advanced(entry)))
                 return XA_ERROR(-EINVAL);
         if (xa_track_free(xa) && !entry)
                 entry = XA_ZERO_ENTRY;
@@ -1444,7 +1419,7 @@ void *__xa_cmpxchg(struct xarray *xa, unsigned long index,
         XA_STATE(xas, xa, index);
         void *curr;
 
-        if (WARN_ON_ONCE(xa_is_internal(entry)))
+        if (WARN_ON_ONCE(xa_is_advanced(entry)))
                 return XA_ERROR(-EINVAL);
         if (xa_track_free(xa) && !entry)
                 entry = XA_ZERO_ENTRY;
@@ -1465,6 +1440,47 @@ void *__xa_cmpxchg(struct xarray *xa, unsigned long index,
 EXPORT_SYMBOL(__xa_cmpxchg);
 
 /**
+ * __xa_insert() - Store this entry in the XArray if no entry is present.
+ * @xa: XArray.
+ * @index: Index into array.
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * Inserting a NULL entry will store a reserved entry (like xa_reserve())
+ * if no entry is present.  Inserting will fail if a reserved entry is
+ * present, even though loading from this index will return NULL.
+ *
+ * Context: Any context.  Expects xa_lock to be held on entry.  May
+ * release and reacquire xa_lock if @gfp flags permit.
+ * Return: 0 if the store succeeded.  -EEXIST if another entry was present.
+ * -ENOMEM if memory could not be allocated.
+ */
+int __xa_insert(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp)
+{
+        XA_STATE(xas, xa, index);
+        void *curr;
+
+        if (WARN_ON_ONCE(xa_is_advanced(entry)))
+                return -EINVAL;
+        if (!entry)
+                entry = XA_ZERO_ENTRY;
+
+        do {
+                curr = xas_load(&xas);
+                if (!curr) {
+                        xas_store(&xas, entry);
+                        if (xa_track_free(xa))
+                                xas_clear_mark(&xas, XA_FREE_MARK);
+                } else {
+                        xas_set_err(&xas, -EEXIST);
+                }
+        } while (__xas_nomem(&xas, gfp));
+
+        return xas_error(&xas);
+}
+EXPORT_SYMBOL(__xa_insert);
+
+/**
  * __xa_reserve() - Reserve this index in the XArray.
  * @xa: XArray.
  * @index: Index into array.
@@ -1567,7 +1583,7 @@ void *xa_store_range(struct xarray *xa, unsigned long first,
                         if (last + 1)
                                 order = __ffs(last + 1);
                         xas_set_order(&xas, last, order);
-                        xas_create(&xas);
+                        xas_create(&xas, true);
                         if (xas_error(&xas))
                                 goto unlock;
                 }
@@ -1609,7 +1625,7 @@ int __xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry, gfp_t gfp)
         XA_STATE(xas, xa, 0);
         int err;
 
-        if (WARN_ON_ONCE(xa_is_internal(entry)))
+        if (WARN_ON_ONCE(xa_is_advanced(entry)))
                 return -EINVAL;
         if (WARN_ON_ONCE(!xa_track_free(xa)))
                 return -EINVAL;