4 files changed, 37 insertions, 24 deletions

diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index 970212670b6a..fdae394172fa 100644
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -1012,7 +1012,7 @@ unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
 }
 EXPORT_SYMBOL(iov_iter_gap_alignment);
 
-static inline size_t __pipe_get_pages(struct iov_iter *i,
+static inline ssize_t __pipe_get_pages(struct iov_iter *i,
                                 size_t maxsize,
                                 struct page **pages,
                                 int idx,
@@ -1102,7 +1102,7 @@ static ssize_t pipe_get_pages_alloc(struct iov_iter *i,
                    size_t *start)
 {
         struct page **p;
-        size_t n;
+        ssize_t n;
         int idx;
         int npages;
 
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index da9e10c827df..a9e41aed6de4 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -1612,11 +1612,9 @@ static void set_iter_tags(struct radix_tree_iter *iter,
 static void __rcu **skip_siblings(struct radix_tree_node **nodep,
                         void __rcu **slot, struct radix_tree_iter *iter)
 {
-        void *sib = node_to_entry(slot - 1);
-
         while (iter->index < iter->next_index) {
                 *nodep = rcu_dereference_raw(*slot);
-                if (*nodep && *nodep != sib)
+                if (*nodep && !is_sibling_entry(iter->node, *nodep))
                         return slot;
                 slot++;
                 iter->index = __radix_tree_iter_add(iter, 1);
@@ -1631,7 +1629,7 @@ void __rcu **__radix_tree_next_slot(void __rcu **slot,
                                 struct radix_tree_iter *iter, unsigned flags)
 {
         unsigned tag = flags & RADIX_TREE_ITER_TAG_MASK;
-        struct radix_tree_node *node = rcu_dereference_raw(*slot);
+        struct radix_tree_node *node;
 
         slot = skip_siblings(&node, slot, iter);
 
@@ -2036,10 +2034,12 @@ void *radix_tree_delete_item(struct radix_tree_root *root,
                              unsigned long index, void *item)
 {
         struct radix_tree_node *node = NULL;
-        void __rcu **slot;
+        void __rcu **slot = NULL;
         void *entry;
 
         entry = __radix_tree_lookup(root, index, &node, &slot);
+        if (!slot)
+                return NULL;
         if (!entry && (!is_idr(root) || node_tag_get(root, node, IDR_FREE,
                                                 get_slot_offset(node, slot))))
                 return NULL;
diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
index de16f7869fb1..6cd7d0740005 100644
--- a/lib/test_bitmap.c
+++ b/lib/test_bitmap.c
@@ -331,23 +331,32 @@ static void noinline __init test_mem_optimisations(void)
         unsigned int start, nbits;
 
         for (start = 0; start < 1024; start += 8) {
-                memset(bmap1, 0x5a, sizeof(bmap1));
-                memset(bmap2, 0x5a, sizeof(bmap2));
                 for (nbits = 0; nbits < 1024 - start; nbits += 8) {
+                        memset(bmap1, 0x5a, sizeof(bmap1));
+                        memset(bmap2, 0x5a, sizeof(bmap2));
+
                         bitmap_set(bmap1, start, nbits);
                         __bitmap_set(bmap2, start, nbits);
-                        if (!bitmap_equal(bmap1, bmap2, 1024))
+                        if (!bitmap_equal(bmap1, bmap2, 1024)) {
                                 printk("set not equal %d %d\n", start, nbits);
-                        if (!__bitmap_equal(bmap1, bmap2, 1024))
+                                failed_tests++;
+                        }
+                        if (!__bitmap_equal(bmap1, bmap2, 1024)) {
                                 printk("set not __equal %d %d\n", start, nbits);
+                                failed_tests++;
+                        }
 
                         bitmap_clear(bmap1, start, nbits);
                         __bitmap_clear(bmap2, start, nbits);
-                        if (!bitmap_equal(bmap1, bmap2, 1024))
+                        if (!bitmap_equal(bmap1, bmap2, 1024)) {
                                 printk("clear not equal %d %d\n", start, nbits);
-                        if (!__bitmap_equal(bmap1, bmap2, 1024))
+                                failed_tests++;
+                        }
+                        if (!__bitmap_equal(bmap1, bmap2, 1024)) {
                                 printk("clear not __equal %d %d\n", start,
                                                                         nbits);
+                                failed_tests++;
+                        }
                 }
         }
 }
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 30c0cb8cc9bc..23920c5ff728 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1669,19 +1669,22 @@ char *pointer_string(char *buf, char *end, const void *ptr,
         return number(buf, end, (unsigned long int)ptr, spec);
 }
 
-static bool have_filled_random_ptr_key __read_mostly;
+static DEFINE_STATIC_KEY_TRUE(not_filled_random_ptr_key);
 static siphash_key_t ptr_key __read_mostly;
 
-static void fill_random_ptr_key(struct random_ready_callback *unused)
+static void enable_ptr_key_workfn(struct work_struct *work)
 {
         get_random_bytes(&ptr_key, sizeof(ptr_key));
-        /*
-         * have_filled_random_ptr_key==true is dependent on get_random_bytes().
-         * ptr_to_id() needs to see have_filled_random_ptr_key==true
-         * after get_random_bytes() returns.
-         */
-        smp_mb();
-        WRITE_ONCE(have_filled_random_ptr_key, true);
+        /* Needs to run from preemptible context */
+        static_branch_disable(&not_filled_random_ptr_key);
+}
+
+static DECLARE_WORK(enable_ptr_key_work, enable_ptr_key_workfn);
+
+static void fill_random_ptr_key(struct random_ready_callback *unused)
+{
+        /* This may be in an interrupt handler. */
+        queue_work(system_unbound_wq, &enable_ptr_key_work);
 }
 
 static struct random_ready_callback random_ready = {
@@ -1695,7 +1698,8 @@ static int __init initialize_ptr_random(void)
         if (!ret) {
                 return 0;
         } else if (ret == -EALREADY) {
-                fill_random_ptr_key(&random_ready);
+                /* This is in preemptible context */
+                enable_ptr_key_workfn(&enable_ptr_key_work);
                 return 0;
         }
 
@@ -1709,7 +1713,7 @@ static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
         unsigned long hashval;
         const int default_width = 2 * sizeof(ptr);
 
-        if (unlikely(!have_filled_random_ptr_key)) {
+        if (static_branch_unlikely(&not_filled_random_ptr_key)) {
                 spec.field_width = default_width;
                 /* string length must be less than default_width */
                 return string(buf, end, "(ptrval)", spec);