7 files changed, 101 insertions, 45 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 30df5865ecbe..a79c4d0407ab 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -392,7 +392,7 @@ config DEBUG_KMEMLEAK_TEST
 
 config DEBUG_PREEMPT
         bool "Debug preemptible kernel"
-        depends on DEBUG_KERNEL && PREEMPT && (TRACE_IRQFLAGS_SUPPORT || PPC64)
+        depends on DEBUG_KERNEL && PREEMPT && TRACE_IRQFLAGS_SUPPORT
         default y
         help
           If you say Y here then the kernel will use a debug variant of the
@@ -750,7 +750,7 @@ config RCU_TORTURE_TEST_RUNNABLE
 config RCU_CPU_STALL_DETECTOR
         bool "Check for stalled CPUs delaying RCU grace periods"
         depends on TREE_RCU || TREE_PREEMPT_RCU
-        default n
+        default y
         help
           This option causes RCU to printk information on which
           CPUs are delaying the current grace period, but only when
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index 58a9f9fc609a..ce6b7eabf674 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -819,9 +819,11 @@ static void check_unmap(struct dma_debug_entry *ref)
                 err_printk(ref->dev, entry, "DMA-API: device driver frees "
                            "DMA memory with different CPU address "
                            "[device address=0x%016llx] [size=%llu bytes] "
-                           "[cpu alloc address=%p] [cpu free address=%p]",
+                           "[cpu alloc address=0x%016llx] "
+                           "[cpu free address=0x%016llx]",
                            ref->dev_addr, ref->size,
-                           (void *)entry->paddr, (void *)ref->paddr);
+                           (unsigned long long)entry->paddr,
+                           (unsigned long long)ref->paddr);
         }
 
         if (ref->sg_call_ents && ref->type == dma_debug_sg &&
diff --git a/lib/kernel_lock.c b/lib/kernel_lock.c
index 39f1029e3525..4ebfa5a164d7 100644
--- a/lib/kernel_lock.c
+++ b/lib/kernel_lock.c
@@ -5,10 +5,13 @@
  * relegated to obsolescence, but used by various less
  * important (or lazy) subsystems.
  */
-#include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include <linux/semaphore.h>
+#include <linux/smp_lock.h>
+
+#define CREATE_TRACE_POINTS
+#include <trace/events/bkl.h>
 
 /*
  * The 'big kernel lock'
@@ -113,21 +116,26 @@ static inline void __unlock_kernel(void)
  * This cannot happen asynchronously, so we only need to
  * worry about other CPU's.
  */
-void __lockfunc lock_kernel(void)
+void __lockfunc _lock_kernel(const char *func, const char *file, int line)
 {
-        int depth = current->lock_depth+1;
+        int depth = current->lock_depth + 1;
+
+        trace_lock_kernel(func, file, line);
+
         if (likely(!depth))
                 __lock_kernel();
         current->lock_depth = depth;
 }
 
-void __lockfunc unlock_kernel(void)
+void __lockfunc _unlock_kernel(const char *func, const char *file, int line)
 {
         BUG_ON(current->lock_depth < 0);
         if (likely(--current->lock_depth < 0))
                 __unlock_kernel();
+
+        trace_unlock_kernel(func, file, line);
 }
 
-EXPORT_SYMBOL(lock_kernel);
-EXPORT_SYMBOL(unlock_kernel);
+EXPORT_SYMBOL(_lock_kernel);
+EXPORT_SYMBOL(_unlock_kernel);
 
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 23abbd93cae1..92cdd9936e3d 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -200,6 +200,9 @@ radix_tree_node_free(struct radix_tree_node *node)
  * ensure that the addition of a single element in the tree cannot fail.  On
  * success, return zero, with preemption disabled.  On error, return -ENOMEM
  * with preemption not disabled.
+ *
+ * To make use of this facility, the radix tree must be initialised without
+ * __GFP_WAIT being passed to INIT_RADIX_TREE().
  */
 int radix_tree_preload(gfp_t gfp_mask)
 {
@@ -543,7 +546,6 @@ out:
 }
 EXPORT_SYMBOL(radix_tree_tag_clear);
 
-#ifndef __KERNEL__      /* Only the test harness uses this at present */
 /**
  * radix_tree_tag_get - get a tag on a radix tree node
  * @root:               radix tree root
@@ -606,7 +608,6 @@ int radix_tree_tag_get(struct radix_tree_root *root,
         }
 }
 EXPORT_SYMBOL(radix_tree_tag_get);
-#endif
 
 /**
  *      radix_tree_next_hole    -    find the next hole (not-present entry)
diff --git a/lib/ratelimit.c b/lib/ratelimit.c
index 26187edcc7ea..09f5ce1810dc 100644
--- a/lib/ratelimit.c
+++ b/lib/ratelimit.c
@@ -7,15 +7,12 @@
  * parameter. Now every user can use their own standalone ratelimit_state.
  *
  * This file is released under the GPLv2.
- *
  */
 
-#include <linux/kernel.h>
+#include <linux/ratelimit.h>
 #include <linux/jiffies.h>
 #include <linux/module.h>
 
-static DEFINE_SPINLOCK(ratelimit_lock);
-
 /*
  * __ratelimit - rate limiting
  * @rs: ratelimit_state data
@@ -23,35 +20,43 @@ static DEFINE_SPINLOCK(ratelimit_lock);
  * This enforces a rate limit: not more than @rs->ratelimit_burst callbacks
  * in every @rs->ratelimit_jiffies
  */
-int __ratelimit(struct ratelimit_state *rs)
+int ___ratelimit(struct ratelimit_state *rs, const char *func)
 {
         unsigned long flags;
+        int ret;
 
         if (!rs->interval)
                 return 1;
 
-        spin_lock_irqsave(&ratelimit_lock, flags);
+        /*
+         * If we contend on this state's lock then almost
+         * by definition we are too busy to print a message,
+         * in addition to the one that will be printed by
+         * the entity that is holding the lock already:
+         */
+        if (!spin_trylock_irqsave(&rs->lock, flags))
+                return 1;
+
         if (!rs->begin)
                 rs->begin = jiffies;
 
         if (time_is_before_jiffies(rs->begin + rs->interval)) {
                 if (rs->missed)
                         printk(KERN_WARNING "%s: %d callbacks suppressed\n",
-                                __func__, rs->missed);
-                rs->begin = 0;
+                                func, rs->missed);
+                rs->begin   = 0;
                 rs->printed = 0;
-                rs->missed = 0;
+                rs->missed  = 0;
         }
-        if (rs->burst && rs->burst > rs->printed)
-                goto print;
-
-        rs->missed++;
-        spin_unlock_irqrestore(&ratelimit_lock, flags);
-        return 0;
+        if (rs->burst && rs->burst > rs->printed) {
+                rs->printed++;
+                ret = 1;
+        } else {
+                rs->missed++;
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&rs->lock, flags);
 
-print:
-        rs->printed++;
-        spin_unlock_irqrestore(&ratelimit_lock, flags);
-        return 1;
+        return ret;
 }
-EXPORT_SYMBOL(__ratelimit);
+EXPORT_SYMBOL(___ratelimit);
diff --git a/lib/string.c b/lib/string.c
index b19b87af65a3..e96421ab9a9a 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -246,13 +246,17 @@ EXPORT_SYMBOL(strlcat);
 #undef strcmp
 int strcmp(const char *cs, const char *ct)
 {
-        signed char __res;
+        unsigned char c1, c2;
 
         while (1) {
-                if ((__res = *cs - *ct++) != 0 || !*cs++)
+                c1 = *cs++;
+                c2 = *ct++;
+                if (c1 != c2)
+                        return c1 < c2 ? -1 : 1;
+                if (!c1)
                         break;
         }
-        return __res;
+        return 0;
 }
 EXPORT_SYMBOL(strcmp);
 #endif
@@ -266,14 +270,18 @@ EXPORT_SYMBOL(strcmp);
  */
 int strncmp(const char *cs, const char *ct, size_t count)
 {
-        signed char __res = 0;
+        unsigned char c1, c2;
 
         while (count) {
-                if ((__res = *cs - *ct++) != 0 || !*cs++)
+                c1 = *cs++;
+                c2 = *ct++;
+                if (c1 != c2)
+                        return c1 < c2 ? -1 : 1;
+                if (!c1)
                         break;
                 count--;
         }
-        return __res;
+        return 0;
 }
 EXPORT_SYMBOL(strncmp);
 #endif
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index ac25cd28e807..795472d8ae24 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -97,6 +97,8 @@ static phys_addr_t *io_tlb_orig_addr;
  */
 static DEFINE_SPINLOCK(io_tlb_lock);
 
+static int late_alloc;
+
 static int __init
 setup_io_tlb_npages(char *str)
 {
@@ -109,6 +111,7 @@ setup_io_tlb_npages(char *str)
                 ++str;
         if (!strcmp(str, "force"))
                 swiotlb_force = 1;
+
         return 1;
 }
 __setup("swiotlb=", setup_io_tlb_npages);
@@ -121,8 +124,9 @@ static dma_addr_t swiotlb_virt_to_bus(struct device *hwdev,
         return phys_to_dma(hwdev, virt_to_phys(address));
 }
 
-static void swiotlb_print_info(unsigned long bytes)
+void swiotlb_print_info(void)
 {
+        unsigned long bytes = io_tlb_nslabs << IO_TLB_SHIFT;
         phys_addr_t pstart, pend;
 
         pstart = virt_to_phys(io_tlb_start);
@@ -140,7 +144,7 @@ static void swiotlb_print_info(unsigned long bytes)
  * structures for the software IO TLB used to implement the DMA API.
  */
 void __init
-swiotlb_init_with_default_size(size_t default_size)
+swiotlb_init_with_default_size(size_t default_size, int verbose)
 {
         unsigned long i, bytes;
 
@@ -176,14 +180,14 @@ swiotlb_init_with_default_size(size_t default_size)
         io_tlb_overflow_buffer = alloc_bootmem_low(io_tlb_overflow);
         if (!io_tlb_overflow_buffer)
                 panic("Cannot allocate SWIOTLB overflow buffer!\n");
-
-        swiotlb_print_info(bytes);
+        if (verbose)
+                swiotlb_print_info();
 }
 
 void __init
-swiotlb_init(void)
+swiotlb_init(int verbose)
 {
-        swiotlb_init_with_default_size(64 * (1<<20));   /* default to 64MB */
+        swiotlb_init_with_default_size(64 * (1<<20), verbose);  /* default to 64MB */
 }
 
 /*
@@ -260,7 +264,9 @@ swiotlb_late_init_with_default_size(size_t default_size)
         if (!io_tlb_overflow_buffer)
                 goto cleanup4;
 
-        swiotlb_print_info(bytes);
+        swiotlb_print_info();
+
+        late_alloc = 1;
 
         return 0;
 
@@ -281,6 +287,32 @@ cleanup1:
         return -ENOMEM;
 }
 
+void __init swiotlb_free(void)
+{
+        if (!io_tlb_overflow_buffer)
+                return;
+
+        if (late_alloc) {
+                free_pages((unsigned long)io_tlb_overflow_buffer,
+                           get_order(io_tlb_overflow));
+                free_pages((unsigned long)io_tlb_orig_addr,
+                           get_order(io_tlb_nslabs * sizeof(phys_addr_t)));
+                free_pages((unsigned long)io_tlb_list, get_order(io_tlb_nslabs *
+                                                                 sizeof(int)));
+                free_pages((unsigned long)io_tlb_start,
+                           get_order(io_tlb_nslabs << IO_TLB_SHIFT));
+        } else {
+                free_bootmem_late(__pa(io_tlb_overflow_buffer),
+                                  io_tlb_overflow);
+                free_bootmem_late(__pa(io_tlb_orig_addr),
+                                  io_tlb_nslabs * sizeof(phys_addr_t));
+                free_bootmem_late(__pa(io_tlb_list),
+                                  io_tlb_nslabs * sizeof(int));
+                free_bootmem_late(__pa(io_tlb_start),
+                                  io_tlb_nslabs << IO_TLB_SHIFT);
+        }
+}
+
 static int is_swiotlb_buffer(phys_addr_t paddr)
 {
         return paddr >= virt_to_phys(io_tlb_start) &&