9 files changed, 61 insertions, 48 deletions

diff --git a/lib/dma-direct.c b/lib/dma-direct.c
index c0bba30fef0a..bbfb229aa067 100644
--- a/lib/dma-direct.c
+++ b/lib/dma-direct.c
@@ -84,7 +84,8 @@ again:
                 __free_pages(page, page_order);
                 page = NULL;
 
-                if (dev->coherent_dma_mask < DMA_BIT_MASK(32) &&
+                if (IS_ENABLED(CONFIG_ZONE_DMA) &&
+                    dev->coherent_dma_mask < DMA_BIT_MASK(32) &&
                     !(gfp & GFP_DMA)) {
                         gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
                         goto again;
diff --git a/lib/errseq.c b/lib/errseq.c
index df782418b333..81f9e33aa7e7 100644
--- a/lib/errseq.c
+++ b/lib/errseq.c
@@ -111,27 +111,22 @@ EXPORT_SYMBOL(errseq_set);
  * errseq_sample() - Grab current errseq_t value.
  * @eseq: Pointer to errseq_t to be sampled.
  *
- * This function allows callers to sample an errseq_t value, marking it as
- * "seen" if required.
+ * This function allows callers to initialise their errseq_t variable.
+ * If the error has been "seen", new callers will not see an old error.
+ * If there is an unseen error in @eseq, the caller of this function will
+ * see it the next time it checks for an error.
  *
+ * Context: Any context.
  * Return: The current errseq value.
  */
 errseq_t errseq_sample(errseq_t *eseq)
 {
         errseq_t old = READ_ONCE(*eseq);
-        errseq_t new = old;
 
-        /*
-         * For the common case of no errors ever having been set, we can skip
-         * marking the SEEN bit. Once an error has been set, the value will
-         * never go back to zero.
-         */
-        if (old != 0) {
-                new |= ERRSEQ_SEEN;
-                if (old != new)
-                        cmpxchg(eseq, old, new);
-        }
-        return new;
+        /* If nobody has seen this error yet, then we can be the first. */
+        if (!(old & ERRSEQ_SEEN))
+                old = 0;
+        return old;
 }
 EXPORT_SYMBOL(errseq_sample);
 
diff --git a/lib/find_bit_benchmark.c b/lib/find_bit_benchmark.c
index 5985a25e6cbc..5367ffa5c18f 100644
--- a/lib/find_bit_benchmark.c
+++ b/lib/find_bit_benchmark.c
@@ -132,7 +132,12 @@ static int __init find_bit_test(void)
         test_find_next_bit(bitmap, BITMAP_LEN);
         test_find_next_zero_bit(bitmap, BITMAP_LEN);
         test_find_last_bit(bitmap, BITMAP_LEN);
-        test_find_first_bit(bitmap, BITMAP_LEN);
+
+        /*
+         * test_find_first_bit() may take some time, so
+         * traverse only part of bitmap to avoid soft lockup.
+         */
+        test_find_first_bit(bitmap, BITMAP_LEN / 10);
         test_find_next_and_bit(bitmap, bitmap2, BITMAP_LEN);
 
         pr_err("\nStart testing find_bit() with sparse bitmap\n");
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/kobject.c b/lib/kobject.c
index e1d1f290bf35..18989b5b3b56 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -233,13 +233,12 @@ static int kobject_add_internal(struct kobject *kobj)
 
                 /* be noisy on error issues */
                 if (error == -EEXIST)
-                        WARN(1,
-                             "%s failed for %s with -EEXIST, don't try to register things with the same name in the same directory.\n",
-                             __func__, kobject_name(kobj));
+                        pr_err("%s failed for %s with -EEXIST, don't try to register things with the same name in the same directory.\n",
+                               __func__, kobject_name(kobj));
                 else
-                        WARN(1, "%s failed for %s (error: %d parent: %s)\n",
-                             __func__, kobject_name(kobj), error,
-                             parent ? kobject_name(parent) : "'none'");
+                        pr_err("%s failed for %s (error: %d parent: %s)\n",
+                               __func__, kobject_name(kobj), error,
+                               parent ? kobject_name(parent) : "'none'");
         } else
                 kobj->state_in_sysfs = 1;
 
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/swiotlb.c b/lib/swiotlb.c
index fece57566d45..cc640588f145 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -714,7 +714,7 @@ swiotlb_alloc_buffer(struct device *dev, size_t size, dma_addr_t *dma_handle,
 
         phys_addr = swiotlb_tbl_map_single(dev,
                         __phys_to_dma(dev, io_tlb_start),
-                        0, size, DMA_FROM_DEVICE, 0);
+                        0, size, DMA_FROM_DEVICE, attrs);
         if (phys_addr == SWIOTLB_MAP_ERROR)
                 goto out_warn;
 
@@ -737,7 +737,7 @@ out_unmap:
         swiotlb_tbl_unmap_single(dev, phys_addr, size, DMA_TO_DEVICE,
                         DMA_ATTR_SKIP_CPU_SYNC);
 out_warn:
-        if ((attrs & DMA_ATTR_NO_WARN) && printk_ratelimit()) {
+        if (!(attrs & DMA_ATTR_NO_WARN) && printk_ratelimit()) {
                 dev_warn(dev,
                         "swiotlb: coherent allocation failed, size=%zu\n",
                         size);
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);