15 files changed, 598 insertions, 130 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 0e25c03939e3..a9e15403434e 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -16,6 +16,12 @@ config BITREVERSE
 config RATIONAL
         boolean
 
+config GENERIC_STRNCPY_FROM_USER
+        bool
+
+config GENERIC_STRNLEN_USER
+        bool
+
 config GENERIC_FIND_FIRST_BIT
         bool
 
@@ -33,6 +39,9 @@ config GENERIC_IO
         boolean
         default n
 
+config STMP_DEVICE
+        bool
+
 config CRC_CCITT
         tristate "CRC-CCITT functions"
         help
diff --git a/lib/Makefile b/lib/Makefile
index 74290c9e2864..8c31a0cb75e9 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -125,6 +125,11 @@ obj-$(CONFIG_CLZ_TAB) += clz_tab.o
 
 obj-$(CONFIG_DDR) += jedec_ddr_data.o
 
+obj-$(CONFIG_GENERIC_STRNCPY_FROM_USER) += strncpy_from_user.o
+obj-$(CONFIG_GENERIC_STRNLEN_USER) += strnlen_user.o
+
+obj-$(CONFIG_STMP_DEVICE) += stmp_device.o
+
 hostprogs-y     := gen_crc32table
 clean-files     := crc32table.h
 
diff --git a/lib/bitmap.c b/lib/bitmap.c
index b5a8b6ad2454..06fdfa1aeba7 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -369,7 +369,8 @@ EXPORT_SYMBOL(bitmap_find_next_zero_area);
  * @nmaskbits: size of bitmap, in bits
  *
  * Exactly @nmaskbits bits are displayed.  Hex digits are grouped into
- * comma-separated sets of eight digits per set.
+ * comma-separated sets of eight digits per set.  Returns the number of
+ * characters which were written to *buf, excluding the trailing \0.
  */
 int bitmap_scnprintf(char *buf, unsigned int buflen,
         const unsigned long *maskp, int nmaskbits)
@@ -517,8 +518,8 @@ EXPORT_SYMBOL(bitmap_parse_user);
  *
  * Helper routine for bitmap_scnlistprintf().  Write decimal number
  * or range to buf, suppressing output past buf+buflen, with optional
- * comma-prefix.  Return len of what would be written to buf, if it
- * all fit.
+ * comma-prefix.  Return len of what was written to *buf, excluding the
+ * trailing \0.
  */
 static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len)
 {
@@ -544,9 +545,8 @@ static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len)
  * the range.  Output format is compatible with the format
  * accepted as input by bitmap_parselist().
  *
- * The return value is the number of characters which would be
- * generated for the given input, excluding the trailing '\0', as
- * per ISO C99.
+ * The return value is the number of characters which were written to *buf
+ * excluding the trailing '\0', as per ISO C99's scnprintf.
  */
 int bitmap_scnlistprintf(char *buf, unsigned int buflen,
         const unsigned long *maskp, int nmaskbits)
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index 13ef2338be41..518aea714d21 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -430,7 +430,7 @@ static struct dma_debug_entry *__dma_entry_alloc(void)
  */
 static struct dma_debug_entry *dma_entry_alloc(void)
 {
-        struct dma_debug_entry *entry = NULL;
+        struct dma_debug_entry *entry;
         unsigned long flags;
 
         spin_lock_irqsave(&free_entries_lock, flags);
@@ -438,11 +438,14 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         if (list_empty(&free_entries)) {
                 pr_err("DMA-API: debugging out of memory - disabling\n");
                 global_disable = true;
-                goto out;
+                spin_unlock_irqrestore(&free_entries_lock, flags);
+                return NULL;
         }
 
         entry = __dma_entry_alloc();
 
+        spin_unlock_irqrestore(&free_entries_lock, flags);
+
 #ifdef CONFIG_STACKTRACE
         entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;
         entry->stacktrace.entries = entry->st_entries;
@@ -450,9 +453,6 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         save_stack_trace(&entry->stacktrace);
 #endif
 
-out:
-        spin_unlock_irqrestore(&free_entries_lock, flags);
-
         return entry;
 }
 
diff --git a/lib/dynamic_queue_limits.c b/lib/dynamic_queue_limits.c
index 6ab4587d052b..0777c5a45fa0 100644
--- a/lib/dynamic_queue_limits.c
+++ b/lib/dynamic_queue_limits.c
@@ -10,23 +10,27 @@
 #include <linux/jiffies.h>
 #include <linux/dynamic_queue_limits.h>
 
-#define POSDIFF(A, B) ((A) > (B) ? (A) - (B) : 0)
+#define POSDIFF(A, B) ((int)((A) - (B)) > 0 ? (A) - (B) : 0)
+#define AFTER_EQ(A, B) ((int)((A) - (B)) >= 0)
 
 /* Records completed count and recalculates the queue limit */
 void dql_completed(struct dql *dql, unsigned int count)
 {
         unsigned int inprogress, prev_inprogress, limit;
-        unsigned int ovlimit, all_prev_completed, completed;
+        unsigned int ovlimit, completed, num_queued;
+        bool all_prev_completed;
+
+        num_queued = ACCESS_ONCE(dql->num_queued);
 
         /* Can't complete more than what's in queue */
-        BUG_ON(count > dql->num_queued - dql->num_completed);
+        BUG_ON(count > num_queued - dql->num_completed);
 
         completed = dql->num_completed + count;
         limit = dql->limit;
-        ovlimit = POSDIFF(dql->num_queued - dql->num_completed, limit);
-        inprogress = dql->num_queued - completed;
+        ovlimit = POSDIFF(num_queued - dql->num_completed, limit);
+        inprogress = num_queued - completed;
         prev_inprogress = dql->prev_num_queued - dql->num_completed;
-        all_prev_completed = POSDIFF(completed, dql->prev_num_queued);
+        all_prev_completed = AFTER_EQ(completed, dql->prev_num_queued);
 
         if ((ovlimit && !inprogress) ||
             (dql->prev_ovlimit && all_prev_completed)) {
@@ -104,7 +108,7 @@ void dql_completed(struct dql *dql, unsigned int count)
         dql->prev_ovlimit = ovlimit;
         dql->prev_last_obj_cnt = dql->last_obj_cnt;
         dql->num_completed = completed;
-        dql->prev_num_queued = dql->num_queued;
+        dql->prev_num_queued = num_queued;
 }
 EXPORT_SYMBOL(dql_completed);
 
diff --git a/lib/list_debug.c b/lib/list_debug.c
index 3810b481f940..23a5e031cd8b 100644
--- a/lib/list_debug.c
+++ b/lib/list_debug.c
@@ -31,6 +31,9 @@ void __list_add(struct list_head *new,
                 "list_add corruption. prev->next should be "
                 "next (%p), but was %p. (prev=%p).\n",
                 next, prev->next, prev);
+        WARN(new == prev || new == next,
+             "list_add double add: new=%p, prev=%p, next=%p.\n",
+             new, prev, next);
         next->prev = new;
         new->next = next;
         new->prev = prev;
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 86516f5588e3..d7c878cc006c 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -73,11 +73,24 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH + 1] __read_mostly;
 static struct kmem_cache *radix_tree_node_cachep;
 
 /*
+ * The radix tree is variable-height, so an insert operation not only has
+ * to build the branch to its corresponding item, it also has to build the
+ * branch to existing items if the size has to be increased (by
+ * radix_tree_extend).
+ *
+ * The worst case is a zero height tree with just a single item at index 0,
+ * and then inserting an item at index ULONG_MAX. This requires 2 new branches
+ * of RADIX_TREE_MAX_PATH size to be created, with only the root node shared.
+ * Hence:
+ */
+#define RADIX_TREE_PRELOAD_SIZE (RADIX_TREE_MAX_PATH * 2 - 1)
+
+/*
  * Per-cpu pool of preloaded nodes
  */
 struct radix_tree_preload {
         int nr;
-        struct radix_tree_node *nodes[RADIX_TREE_MAX_PATH];
+        struct radix_tree_node *nodes[RADIX_TREE_PRELOAD_SIZE];
 };
 static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };
 
diff --git a/lib/spinlock_debug.c b/lib/spinlock_debug.c
index 525d160d44f0..d0ec4f3d1593 100644
--- a/lib/spinlock_debug.c
+++ b/lib/spinlock_debug.c
@@ -58,7 +58,7 @@ static void spin_dump(raw_spinlock_t *lock, const char *msg)
         printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
                 msg, raw_smp_processor_id(),
                 current->comm, task_pid_nr(current));
-        printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, "
+        printk(KERN_EMERG " lock: %ps, .magic: %08x, .owner: %s/%d, "
                         ".owner_cpu: %d\n",
                 lock, lock->magic,
                 owner ? owner->comm : "<none>",
diff --git a/lib/stmp_device.c b/lib/stmp_device.c
new file mode 100644
index 000000000000..8ac9bcc4289a
--- /dev/null
+++ b/lib/stmp_device.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 1999 ARM Limited
+ * Copyright (C) 2000 Deep Blue Solutions Ltd
+ * Copyright 2006-2007,2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
+ * Copyright 2009 Ilya Yanok, Emcraft Systems Ltd, yanok@emcraft.com
+ * Copyright (C) 2011 Wolfram Sang, Pengutronix e.K.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/io.h>
+#include <linux/errno.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/stmp_device.h>
+
+#define STMP_MODULE_CLKGATE     (1 << 30)
+#define STMP_MODULE_SFTRST      (1 << 31)
+
+/*
+ * Clear the bit and poll it cleared.  This is usually called with
+ * a reset address and mask being either SFTRST(bit 31) or CLKGATE
+ * (bit 30).
+ */
+static int stmp_clear_poll_bit(void __iomem *addr, u32 mask)
+{
+        int timeout = 0x400;
+
+        writel(mask, addr + STMP_OFFSET_REG_CLR);
+        udelay(1);
+        while ((readl(addr) & mask) && --timeout)
+                /* nothing */;
+
+        return !timeout;
+}
+
+int stmp_reset_block(void __iomem *reset_addr)
+{
+        int ret;
+        int timeout = 0x400;
+
+        /* clear and poll SFTRST */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_SFTRST);
+        if (unlikely(ret))
+                goto error;
+
+        /* clear CLKGATE */
+        writel(STMP_MODULE_CLKGATE, reset_addr + STMP_OFFSET_REG_CLR);
+
+        /* set SFTRST to reset the block */
+        writel(STMP_MODULE_SFTRST, reset_addr + STMP_OFFSET_REG_SET);
+        udelay(1);
+
+        /* poll CLKGATE becoming set */
+        while ((!(readl(reset_addr) & STMP_MODULE_CLKGATE)) && --timeout)
+                /* nothing */;
+        if (unlikely(!timeout))
+                goto error;
+
+        /* clear and poll SFTRST */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_SFTRST);
+        if (unlikely(ret))
+                goto error;
+
+        /* clear and poll CLKGATE */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_CLKGATE);
+        if (unlikely(ret))
+                goto error;
+
+        return 0;
+
+error:
+        pr_err("%s(%p): module reset timeout\n", __func__, reset_addr);
+        return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(stmp_reset_block);
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index dd4ece372699..1cffc223bff5 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -23,15 +23,15 @@
 int string_get_size(u64 size, const enum string_size_units units,
                     char *buf, int len)
 {
-        const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
+        static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
                                    "EB", "ZB", "YB", NULL};
-        const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
+        static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
                                  "EiB", "ZiB", "YiB", NULL };
-        const char **units_str[] = {
+        static const char **units_str[] = {
                 [STRING_UNITS_10] =  units_10,
                 [STRING_UNITS_2] = units_2,
         };
-        const unsigned int divisor[] = {
+        static const unsigned int divisor[] = {
                 [STRING_UNITS_10] = 1000,
                 [STRING_UNITS_2] = 1024,
         };
diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c
new file mode 100644
index 000000000000..bb2b201d6ad0
--- /dev/null
+++ b/lib/strncpy_from_user.c
@@ -0,0 +1,113 @@
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+
+#include <asm/byteorder.h>
+#include <asm/word-at-a-time.h>
+
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+#define IS_UNALIGNED(src, dst)  0
+#else
+#define IS_UNALIGNED(src, dst)  \
+        (((long) dst | (long) src) & (sizeof(long) - 1))
+#endif
+
+/*
+ * Do a strncpy, return length of string without final '\0'.
+ * 'count' is the user-supplied count (return 'count' if we
+ * hit it), 'max' is the address space maximum (and we return
+ * -EFAULT if we hit it).
+ */
+static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)
+{
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+        long res = 0;
+
+        /*
+         * Truncate 'max' to the user-specified limit, so that
+         * we only have one limit we need to check in the loop
+         */
+        if (max > count)
+                max = count;
+
+        if (IS_UNALIGNED(src, dst))
+                goto byte_at_a_time;
+
+        while (max >= sizeof(unsigned long)) {
+                unsigned long c, data;
+
+                /* Fall back to byte-at-a-time if we get a page fault */
+                if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
+                        break;
+                *(unsigned long *)(dst+res) = c;
+                if (has_zero(c, &data, &constants)) {
+                        data = prep_zero_mask(c, data, &constants);
+                        data = create_zero_mask(data);
+                        return res + find_zero(data);
+                }
+                res += sizeof(unsigned long);
+                max -= sizeof(unsigned long);
+        }
+
+byte_at_a_time:
+        while (max) {
+                char c;
+
+                if (unlikely(__get_user(c,src+res)))
+                        return -EFAULT;
+                dst[res] = c;
+                if (!c)
+                        return res;
+                res++;
+                max--;
+        }
+
+        /*
+         * Uhhuh. We hit 'max'. But was that the user-specified maximum
+         * too? If so, that's ok - we got as much as the user asked for.
+         */
+        if (res >= count)
+                return res;
+
+        /*
+         * Nope: we hit the address space limit, and we still had more
+         * characters the caller would have wanted. That's an EFAULT.
+         */
+        return -EFAULT;
+}
+
+/**
+ * strncpy_from_user: - Copy a NUL terminated string from userspace.
+ * @dst:   Destination address, in kernel space.  This buffer must be at
+ *         least @count bytes long.
+ * @src:   Source address, in user space.
+ * @count: Maximum number of bytes to copy, including the trailing NUL.
+ *
+ * Copies a NUL-terminated string from userspace to kernel space.
+ *
+ * On success, returns the length of the string (not including the trailing
+ * NUL).
+ *
+ * If access to userspace fails, returns -EFAULT (some data may have been
+ * copied).
+ *
+ * If @count is smaller than the length of the string, copies @count bytes
+ * and returns @count.
+ */
+long strncpy_from_user(char *dst, const char __user *src, long count)
+{
+        unsigned long max_addr, src_addr;
+
+        if (unlikely(count <= 0))
+                return 0;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)src;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strncpy_from_user(dst, src, count, max);
+        }
+        return -EFAULT;
+}
+EXPORT_SYMBOL(strncpy_from_user);
diff --git a/lib/strnlen_user.c b/lib/strnlen_user.c
new file mode 100644
index 000000000000..a28df5206d95
--- /dev/null
+++ b/lib/strnlen_user.c
@@ -0,0 +1,138 @@
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <linux/uaccess.h>
+
+#include <asm/word-at-a-time.h>
+
+/* Set bits in the first 'n' bytes when loaded from memory */
+#ifdef __LITTLE_ENDIAN
+#  define aligned_byte_mask(n) ((1ul << 8*(n))-1)
+#else
+#  define aligned_byte_mask(n) (~0xfful << (BITS_PER_LONG - 8 - 8*(n)))
+#endif
+
+/*
+ * Do a strnlen, return length of string *with* final '\0'.
+ * 'count' is the user-supplied count, while 'max' is the
+ * address space maximum.
+ *
+ * Return 0 for exceptions (which includes hitting the address
+ * space maximum), or 'count+1' if hitting the user-supplied
+ * maximum count.
+ *
+ * NOTE! We can sometimes overshoot the user-supplied maximum
+ * if it fits in a aligned 'long'. The caller needs to check
+ * the return value against "> max".
+ */
+static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)
+{
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+        long align, res = 0;
+        unsigned long c;
+
+        /*
+         * Truncate 'max' to the user-specified limit, so that
+         * we only have one limit we need to check in the loop
+         */
+        if (max > count)
+                max = count;
+
+        /*
+         * Do everything aligned. But that means that we
+         * need to also expand the maximum..
+         */
+        align = (sizeof(long) - 1) & (unsigned long)src;
+        src -= align;
+        max += align;
+
+        if (unlikely(__get_user(c,(unsigned long __user *)src)))
+                return 0;
+        c |= aligned_byte_mask(align);
+
+        for (;;) {
+                unsigned long data;
+                if (has_zero(c, &data, &constants)) {
+                        data = prep_zero_mask(c, data, &constants);
+                        data = create_zero_mask(data);
+                        return res + find_zero(data) + 1 - align;
+                }
+                res += sizeof(unsigned long);
+                if (unlikely(max < sizeof(unsigned long)))
+                        break;
+                max -= sizeof(unsigned long);
+                if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
+                        return 0;
+        }
+        res -= align;
+
+        /*
+         * Uhhuh. We hit 'max'. But was that the user-specified maximum
+         * too? If so, return the marker for "too long".
+         */
+        if (res >= count)
+                return count+1;
+
+        /*
+         * Nope: we hit the address space limit, and we still had more
+         * characters the caller would have wanted. That's 0.
+         */
+        return 0;
+}
+
+/**
+ * strnlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ * @count: Maximum count (including NUL character)
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * If the string is too long, returns 'count+1'.
+ * On exception (or invalid count), returns 0.
+ */
+long strnlen_user(const char __user *str, long count)
+{
+        unsigned long max_addr, src_addr;
+
+        if (unlikely(count <= 0))
+                return 0;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, count, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strnlen_user);
+
+/**
+ * strlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * On exception, returns 0.
+ *
+ * If there is a limit on the length of a valid string, you may wish to
+ * consider using strnlen_user() instead.
+ */
+long strlen_user(const char __user *str)
+{
+        unsigned long max_addr, src_addr;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, ~0ul, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strlen_user);
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 414f46ed1dcd..45bc1f83a5ad 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -130,11 +130,9 @@ void swiotlb_print_info(void)
         pstart = virt_to_phys(io_tlb_start);
         pend = virt_to_phys(io_tlb_end);
 
-        printk(KERN_INFO "Placing %luMB software IO TLB between %p - %p\n",
-               bytes >> 20, io_tlb_start, io_tlb_end);
-        printk(KERN_INFO "software IO TLB at phys %#llx - %#llx\n",
-               (unsigned long long)pstart,
-               (unsigned long long)pend);
+        printk(KERN_INFO "software IO TLB [mem %#010llx-%#010llx] (%luMB) mapped at [%p-%p]\n",
+               (unsigned long long)pstart, (unsigned long long)pend - 1,
+               bytes >> 20, io_tlb_start, io_tlb_end - 1);
 }
 
 void __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose)
diff --git a/lib/test-kstrtox.c b/lib/test-kstrtox.c
index d55769d63cb8..bea3f3fa3f02 100644
--- a/lib/test-kstrtox.c
+++ b/lib/test-kstrtox.c
@@ -11,7 +11,7 @@ struct test_fail {
 };
 
 #define DEFINE_TEST_FAIL(test)  \
-        const struct test_fail test[] __initdata
+        const struct test_fail test[] __initconst
 
 #define DECLARE_TEST_OK(type, test_type)        \
         test_type {                             \
@@ -21,7 +21,7 @@ struct test_fail {
         }
 
 #define DEFINE_TEST_OK(type, test)      \
-        const type test[] __initdata
+        const type test[] __initconst
 
 #define TEST_FAIL(fn, type, fmt, test)                                  \
 {                                                                       \
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index abbabec9720a..c3f36d415bdf 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -112,106 +112,199 @@ int skip_atoi(const char **s)
 /* Decimal conversion is by far the most typical, and is used
  * for /proc and /sys data. This directly impacts e.g. top performance
  * with many processes running. We optimize it for speed
- * using code from
- * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
- * (with permission from the author, Douglas W. Jones). */
+ * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
+ * (with permission from the author, Douglas W. Jones).
+ */
 
-/* Formats correctly any integer in [0,99999].
- * Outputs from one to five digits depending on input.
- * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
+#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
+/* Formats correctly any integer in [0, 999999999] */
 static noinline_for_stack
-char *put_dec_trunc(char *buf, unsigned q)
+char *put_dec_full9(char *buf, unsigned q)
 {
-        unsigned d3, d2, d1, d0;
-        d1 = (q>>4) & 0xf;
-        d2 = (q>>8) & 0xf;
-        d3 = (q>>12);
-
-        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
-        q = (d0 * 0xcd) >> 11;
-        d0 = d0 - 10*q;
-        *buf++ = d0 + '0'; /* least significant digit */
-        d1 = q + 9*d3 + 5*d2 + d1;
-        if (d1 != 0) {
-                q = (d1 * 0xcd) >> 11;
-                d1 = d1 - 10*q;
-                *buf++ = d1 + '0'; /* next digit */
-
-                d2 = q + 2*d2;
-                if ((d2 != 0) || (d3 != 0)) {
-                        q = (d2 * 0xd) >> 7;
-                        d2 = d2 - 10*q;
-                        *buf++ = d2 + '0'; /* next digit */
-
-                        d3 = q + 4*d3;
-                        if (d3 != 0) {
-                                q = (d3 * 0xcd) >> 11;
-                                d3 = d3 - 10*q;
-                                *buf++ = d3 + '0';  /* next digit */
-                                if (q != 0)
-                                        *buf++ = q + '0'; /* most sign. digit */
-                        }
-                }
-        }
+        unsigned r;
 
+        /*
+         * Possible ways to approx. divide by 10
+         * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
+         * (x * 0xcccd) >> 19     x <      81920 (x < 262149 when 64-bit mul)
+         * (x * 0x6667) >> 18     x <      43699
+         * (x * 0x3334) >> 17     x <      16389
+         * (x * 0x199a) >> 16     x <      16389
+         * (x * 0x0ccd) >> 15     x <      16389
+         * (x * 0x0667) >> 14     x <       2739
+         * (x * 0x0334) >> 13     x <       1029
+         * (x * 0x019a) >> 12     x <       1029
+         * (x * 0x00cd) >> 11     x <       1029 shorter code than * 0x67 (on i386)
+         * (x * 0x0067) >> 10     x <        179
+         * (x * 0x0034) >>  9     x <         69 same
+         * (x * 0x001a) >>  8     x <         69 same
+         * (x * 0x000d) >>  7     x <         69 same, shortest code (on i386)
+         * (x * 0x0007) >>  6     x <         19
+         * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
+         */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 1 */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 2 */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 3 */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 4 */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 5 */
+        /* Now value is under 10000, can avoid 64-bit multiply */
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0'; /* 6 */
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0'; /* 7 */
+        q      = (r * 0xcd) >> 11;
+        *buf++ = (r - 10 * q) + '0'; /* 8 */
+        *buf++ = q + '0'; /* 9 */
         return buf;
 }
-/* Same with if's removed. Always emits five digits */
+#endif
+
+/* Similar to above but do not pad with zeros.
+ * Code can be easily arranged to print 9 digits too, but our callers
+ * always call put_dec_full9() instead when the number has 9 decimal digits.
+ */
 static noinline_for_stack
-char *put_dec_full(char *buf, unsigned q)
+char *put_dec_trunc8(char *buf, unsigned r)
 {
-        /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
-        /* but anyway, gcc produces better code with full-sized ints */
-        unsigned d3, d2, d1, d0;
-        d1 = (q>>4) & 0xf;
-        d2 = (q>>8) & 0xf;
-        d3 = (q>>12);
+        unsigned q;
+
+        /* Copy of previous function's body with added early returns */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 2 */
+        if (q == 0)
+                return buf;
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 3 */
+        if (r == 0)
+                return buf;
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 4 */
+        if (q == 0)
+                return buf;
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 5 */
+        if (r == 0)
+                return buf;
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0'; /* 6 */
+        if (q == 0)
+                return buf;
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0'; /* 7 */
+        if (r == 0)
+                return buf;
+        q      = (r * 0xcd) >> 11;
+        *buf++ = (r - 10 * q) + '0'; /* 8 */
+        if (q == 0)
+                return buf;
+        *buf++ = q + '0'; /* 9 */
+        return buf;
+}
 
-        /*
-         * Possible ways to approx. divide by 10
-         * gcc -O2 replaces multiply with shifts and adds
-         * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
-         * (x * 0x67) >> 10:  1100111
-         * (x * 0x34) >> 9:    110100 - same
-         * (x * 0x1a) >> 8:     11010 - same
-         * (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
-         */
-        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
-        q = (d0 * 0xcd) >> 11;
-        d0 = d0 - 10*q;
-        *buf++ = d0 + '0';
-        d1 = q + 9*d3 + 5*d2 + d1;
-                q = (d1 * 0xcd) >> 11;
-                d1 = d1 - 10*q;
-                *buf++ = d1 + '0';
-
-                d2 = q + 2*d2;
-                        q = (d2 * 0xd) >> 7;
-                        d2 = d2 - 10*q;
-                        *buf++ = d2 + '0';
-
-                        d3 = q + 4*d3;
-                                q = (d3 * 0xcd) >> 11; /* - shorter code */
-                                /* q = (d3 * 0x67) >> 10; - would also work */
-                                d3 = d3 - 10*q;
-                                *buf++ = d3 + '0';
-                                        *buf++ = q + '0';
+/* There are two algorithms to print larger numbers.
+ * One is generic: divide by 1000000000 and repeatedly print
+ * groups of (up to) 9 digits. It's conceptually simple,
+ * but requires a (unsigned long long) / 1000000000 division.
+ *
+ * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
+ * manipulates them cleverly and generates groups of 4 decimal digits.
+ * It so happens that it does NOT require long long division.
+ *
+ * If long is > 32 bits, division of 64-bit values is relatively easy,
+ * and we will use the first algorithm.
+ * If long long is > 64 bits (strange architecture with VERY large long long),
+ * second algorithm can't be used, and we again use the first one.
+ *
+ * Else (if long is 32 bits and long long is 64 bits) we use second one.
+ */
 
-        return buf;
+#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
+
+/* First algorithm: generic */
+
+static
+char *put_dec(char *buf, unsigned long long n)
+{
+        if (n >= 100*1000*1000) {
+                while (n >= 1000*1000*1000)
+                        buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
+                if (n >= 100*1000*1000)
+                        return put_dec_full9(buf, n);
+        }
+        return put_dec_trunc8(buf, n);
 }
-/* No inlining helps gcc to use registers better */
+
+#else
+
+/* Second algorithm: valid only for 64-bit long longs */
+
 static noinline_for_stack
-char *put_dec(char *buf, unsigned long long num)
+char *put_dec_full4(char *buf, unsigned q)
 {
-        while (1) {
-                unsigned rem;
-                if (num < 100000)
-                        return put_dec_trunc(buf, num);
-                rem = do_div(num, 100000);
-                buf = put_dec_full(buf, rem);
-        }
+        unsigned r;
+        r      = (q * 0xcccd) >> 19;
+        *buf++ = (q - 10 * r) + '0';
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0';
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0';
+        *buf++ = r + '0';
+        return buf;
+}
+
+/* Based on code by Douglas W. Jones found at
+ * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
+ * (with permission from the author).
+ * Performs no 64-bit division and hence should be fast on 32-bit machines.
+ */
+static
+char *put_dec(char *buf, unsigned long long n)
+{
+        uint32_t d3, d2, d1, q, h;
+
+        if (n < 100*1000*1000)
+                return put_dec_trunc8(buf, n);
+
+        d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
+        h   = (n >> 32);
+        d2  = (h      ) & 0xffff;
+        d3  = (h >> 16); /* implicit "& 0xffff" */
+
+        q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
+
+        buf = put_dec_full4(buf, q % 10000);
+        q   = q / 10000;
+
+        d1  = q + 7671 * d3 + 9496 * d2 + 6 * d1;
+        buf = put_dec_full4(buf, d1 % 10000);
+        q   = d1 / 10000;
+
+        d2  = q + 4749 * d3 + 42 * d2;
+        buf = put_dec_full4(buf, d2 % 10000);
+        q   = d2 / 10000;
+
+        d3  = q + 281 * d3;
+        if (!d3)
+                goto done;
+        buf = put_dec_full4(buf, d3 % 10000);
+        q   = d3 / 10000;
+        if (!q)
+                goto done;
+        buf = put_dec_full4(buf, q);
+ done:
+        while (buf[-1] == '0')
+                --buf;
+
+        return buf;
 }
 
+#endif
+
 /*
  * Convert passed number to decimal string.
  * Returns the length of string.  On buffer overflow, returns 0.
@@ -220,16 +313,22 @@ char *put_dec(char *buf, unsigned long long num)
  */
 int num_to_str(char *buf, int size, unsigned long long num)
 {
-        char tmp[21];           /* Enough for 2^64 in decimal */
+        char tmp[sizeof(num) * 3];
         int idx, len;
 
-        len = put_dec(tmp, num) - tmp;
+        /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
+        if (num <= 9) {
+                tmp[0] = '0' + num;
+                len = 1;
+        } else {
+                len = put_dec(tmp, num) - tmp;
+        }
 
         if (len > size)
                 return 0;
         for (idx = 0; idx < len; ++idx)
                 buf[idx] = tmp[len - idx - 1];
-        return  len;
+        return len;
 }
 
 #define ZEROPAD 1               /* pad with zero */
@@ -284,6 +383,7 @@ char *number(char *buf, char *end, unsigned long long num,
         char locase;
         int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
         int i;
+        bool is_zero = num == 0LL;
 
         /* locase = 0 or 0x20. ORing digits or letters with 'locase'
          * produces same digits or (maybe lowercased) letters */
@@ -305,15 +405,16 @@ char *number(char *buf, char *end, unsigned long long num,
                 }
         }
         if (need_pfx) {
-                spec.field_width--;
                 if (spec.base == 16)
+                        spec.field_width -= 2;
+                else if (!is_zero)
                         spec.field_width--;
         }
 
         /* generate full string in tmp[], in reverse order */
         i = 0;
-        if (num == 0)
-                tmp[i++] = '0';
+        if (num < spec.base)
+                tmp[i++] = digits[num] | locase;
         /* Generic code, for any base:
         else do {
                 tmp[i++] = (digits[do_div(num,base)] | locase);
@@ -353,9 +454,11 @@ char *number(char *buf, char *end, unsigned long long num,
         }
         /* "0x" / "0" prefix */
         if (need_pfx) {
-                if (buf < end)
-                        *buf = '0';
-                ++buf;
+                if (spec.base == 16 || !is_zero) {
+                        if (buf < end)
+                                *buf = '0';
+                        ++buf;
+                }
                 if (spec.base == 16) {
                         if (buf < end)
                                 *buf = ('X' | locase);
@@ -436,7 +539,7 @@ char *symbol_string(char *buf, char *end, void *ptr,
         else if (ext != 'f' && ext != 's')
                 sprint_symbol(sym, value);
         else
-                kallsyms_lookup(value, NULL, NULL, NULL, sym);
+                sprint_symbol_no_offset(sym, value);
 
         return string(buf, end, sym, spec);
 #else
@@ -607,7 +710,7 @@ char *ip4_string(char *p, const u8 *addr, const char *fmt)
         }
         for (i = 0; i < 4; i++) {
                 char temp[3];   /* hold each IP quad in reverse order */
-                int digits = put_dec_trunc(temp, addr[index]) - temp;
+                int digits = put_dec_trunc8(temp, addr[index]) - temp;
                 if (leading_zeros) {
                         if (digits < 3)
                                 *p++ = '0';
@@ -866,13 +969,15 @@ static noinline_for_stack
 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
               struct printf_spec spec)
 {
+        int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
+
         if (!ptr && *fmt != 'K') {
                 /*
                  * Print (null) with the same width as a pointer so it makes
                  * tabular output look nice.
                  */
                 if (spec.field_width == -1)
-                        spec.field_width = 2 * sizeof(void *);
+                        spec.field_width = default_width;
                 return string(buf, end, "(null)", spec);
         }
 
@@ -927,7 +1032,7 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
                  */
                 if (in_irq() || in_serving_softirq() || in_nmi()) {
                         if (spec.field_width == -1)
-                                spec.field_width = 2 * sizeof(void *);
+                                spec.field_width = default_width;
                         return string(buf, end, "pK-error", spec);
                 }
                 if (!((kptr_restrict == 0) ||
@@ -944,7 +1049,7 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         }
         spec.flags |= SMALL;
         if (spec.field_width == -1) {
-                spec.field_width = 2 * sizeof(void *);
+                spec.field_width = default_width;
                 spec.flags |= ZEROPAD;
         }
         spec.base = 16;