Merge branch 'akpm' (patches from Andrew)

Merge third set of updates from Andrew Morton:

 - the rest of MM

   [ This includes getting rid of the numa hinting bits, in favor of
     just generic protnone logic.  Yay.     - Linus ]

 - core kernel

 - procfs

 - some of lib/ (lots of lib/ material this time)

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (104 commits)
  lib/lcm.c: replace include
  lib/percpu_ida.c: remove redundant includes
  lib/strncpy_from_user.c: replace module.h include
  lib/stmp_device.c: replace module.h include
  lib/sort.c: move include inside #if 0
  lib/show_mem.c: remove redundant include
  lib/radix-tree.c: change to simpler include
  lib/plist.c: remove redundant include
  lib/nlattr.c: remove redundant include
  lib/kobject_uevent.c: remove redundant include
  lib/llist.c: remove redundant include
  lib/md5.c: simplify include
  lib/list_sort.c: rearrange includes
  lib/genalloc.c: remove redundant include
  lib/idr.c: remove redundant include
  lib/halfmd4.c: simplify includes
  lib/dynamic_queue_limits.c: simplify includes
  lib/sort.c: use simpler includes
  lib/interval_tree.c: simplify includes
  hexdump: make it return number of bytes placed in buffer
  ...

26 files changed, 320 insertions, 145 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index e5ea3ab856bf..79a9bb67aeaf 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1580,6 +1580,9 @@ config ASYNC_RAID6_TEST
 
           If unsure, say N.
 
+config TEST_HEXDUMP
+        tristate "Test functions located in the hexdump module at runtime"
+
 config TEST_STRING_HELPERS
         tristate "Test functions located in the string_helpers module at runtime"
 
diff --git a/lib/Makefile b/lib/Makefile
index 25c061f77df7..e456defd1021 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -23,12 +23,14 @@ lib-y	+= kobject.o klist.o
 obj-y   += lockref.o
 
 obj-y += bcd.o div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \
-         bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o \
+         bust_spinlocks.o kasprintf.o bitmap.o scatterlist.o \
          gcd.o lcm.o list_sort.o uuid.o flex_array.o clz_ctz.o \
          bsearch.o find_last_bit.o find_next_bit.o llist.o memweight.o kfifo.o \
          percpu-refcount.o percpu_ida.o rhashtable.o reciprocal_div.o
 obj-y += string_helpers.o
 obj-$(CONFIG_TEST_STRING_HELPERS) += test-string_helpers.o
+obj-y += hexdump.o
+obj-$(CONFIG_TEST_HEXDUMP) += test-hexdump.o
 obj-y += kstrtox.o
 obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
 obj-$(CONFIG_TEST_LKM) += test_module.o
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 324ea9eab8c1..ad161a6c82db 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -744,10 +744,10 @@ EXPORT_SYMBOL(bitmap_parselist_user);
 /**
  * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
  *      @buf: pointer to a bitmap
- *      @pos: a bit position in @buf (0 <= @pos < @bits)
- *      @bits: number of valid bit positions in @buf
+ *      @pos: a bit position in @buf (0 <= @pos < @nbits)
+ *      @nbits: number of valid bit positions in @buf
  *
- * Map the bit at position @pos in @buf (of length @bits) to the
+ * Map the bit at position @pos in @buf (of length @nbits) to the
  * ordinal of which set bit it is.  If it is not set or if @pos
  * is not a valid bit position, map to -1.
  *
@@ -759,56 +759,40 @@ EXPORT_SYMBOL(bitmap_parselist_user);
  *
  * The bit positions 0 through @bits are valid positions in @buf.
  */
-static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)
+static int bitmap_pos_to_ord(const unsigned long *buf, unsigned int pos, unsigned int nbits)
 {
-        int i, ord;
-
-        if (pos < 0 || pos >= bits || !test_bit(pos, buf))
+        if (pos >= nbits || !test_bit(pos, buf))
                 return -1;
 
-        i = find_first_bit(buf, bits);
-        ord = 0;
-        while (i < pos) {
-                i = find_next_bit(buf, bits, i + 1);
-                ord++;
-        }
-        BUG_ON(i != pos);
-
-        return ord;
+        return __bitmap_weight(buf, pos);
 }
 
 /**
  * bitmap_ord_to_pos - find position of n-th set bit in bitmap
  *      @buf: pointer to bitmap
  *      @ord: ordinal bit position (n-th set bit, n >= 0)
- *      @bits: number of valid bit positions in @buf
+ *      @nbits: number of valid bit positions in @buf
  *
  * Map the ordinal offset of bit @ord in @buf to its position in @buf.
- * Value of @ord should be in range 0 <= @ord < weight(buf), else
- * results are undefined.
+ * Value of @ord should be in range 0 <= @ord < weight(buf). If @ord
+ * >= weight(buf), returns @nbits.
  *
  * If for example, just bits 4 through 7 are set in @buf, then @ord
  * values 0 through 3 will get mapped to 4 through 7, respectively,
- * and all other @ord values return undefined values.  When @ord value 3
+ * and all other @ord values returns @nbits.  When @ord value 3
  * gets mapped to (returns) @pos value 7 in this example, that means
  * that the 3rd set bit (starting with 0th) is at position 7 in @buf.
  *
- * The bit positions 0 through @bits are valid positions in @buf.
+ * The bit positions 0 through @nbits-1 are valid positions in @buf.
  */
-int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
+unsigned int bitmap_ord_to_pos(const unsigned long *buf, unsigned int ord, unsigned int nbits)
 {
-        int pos = 0;
-
-        if (ord >= 0 && ord < bits) {
-                int i;
+        unsigned int pos;
 
-                for (i = find_first_bit(buf, bits);
-                     i < bits && ord > 0;
-                     i = find_next_bit(buf, bits, i + 1))
-                        ord--;
-                if (i < bits && ord == 0)
-                        pos = i;
-        }
+        for (pos = find_first_bit(buf, nbits);
+             pos < nbits && ord;
+             pos = find_next_bit(buf, nbits, pos + 1))
+                ord--;
 
         return pos;
 }
@@ -819,7 +803,7 @@ int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
  *      @src: subset to be remapped
  *      @old: defines domain of map
  *      @new: defines range of map
- *      @bits: number of bits in each of these bitmaps
+ *      @nbits: number of bits in each of these bitmaps
  *
  * Let @old and @new define a mapping of bit positions, such that
  * whatever position is held by the n-th set bit in @old is mapped
@@ -847,22 +831,22 @@ int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
  */
 void bitmap_remap(unsigned long *dst, const unsigned long *src,
                 const unsigned long *old, const unsigned long *new,
-                int bits)
+                unsigned int nbits)
 {
-        int oldbit, w;
+        unsigned int oldbit, w;
 
         if (dst == src)         /* following doesn't handle inplace remaps */
                 return;
-        bitmap_zero(dst, bits);
+        bitmap_zero(dst, nbits);
 
-        w = bitmap_weight(new, bits);
-        for_each_set_bit(oldbit, src, bits) {
-                int n = bitmap_pos_to_ord(old, oldbit, bits);
+        w = bitmap_weight(new, nbits);
+        for_each_set_bit(oldbit, src, nbits) {
+                int n = bitmap_pos_to_ord(old, oldbit, nbits);
 
                 if (n < 0 || w == 0)
                         set_bit(oldbit, dst);   /* identity map */
                 else
-                        set_bit(bitmap_ord_to_pos(new, n % w, bits), dst);
+                        set_bit(bitmap_ord_to_pos(new, n % w, nbits), dst);
         }
 }
 EXPORT_SYMBOL(bitmap_remap);
@@ -1006,9 +990,9 @@ EXPORT_SYMBOL(bitmap_bitremap);
  * All bits in @dst not set by the above rule are cleared.
  */
 void bitmap_onto(unsigned long *dst, const unsigned long *orig,
-                        const unsigned long *relmap, int bits)
+                        const unsigned long *relmap, unsigned int bits)
 {
-        int n, m;               /* same meaning as in above comment */
+        unsigned int n, m;      /* same meaning as in above comment */
 
         if (dst == orig)        /* following doesn't handle inplace mappings */
                 return;
@@ -1039,22 +1023,22 @@ EXPORT_SYMBOL(bitmap_onto);
  *      @dst: resulting smaller bitmap
  *      @orig: original larger bitmap
  *      @sz: specified size
- *      @bits: number of bits in each of these bitmaps
+ *      @nbits: number of bits in each of these bitmaps
  *
  * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst.
  * Clear all other bits in @dst.  See further the comment and
  * Example [2] for bitmap_onto() for why and how to use this.
  */
 void bitmap_fold(unsigned long *dst, const unsigned long *orig,
-                        int sz, int bits)
+                        unsigned int sz, unsigned int nbits)
 {
-        int oldbit;
+        unsigned int oldbit;
 
         if (dst == orig)        /* following doesn't handle inplace mappings */
                 return;
-        bitmap_zero(dst, bits);
+        bitmap_zero(dst, nbits);
 
-        for_each_set_bit(oldbit, orig, bits)
+        for_each_set_bit(oldbit, orig, nbits)
                 set_bit(oldbit % sz, dst);
 }
 EXPORT_SYMBOL(bitmap_fold);
diff --git a/lib/dynamic_queue_limits.c b/lib/dynamic_queue_limits.c
index 0777c5a45fa0..f346715e2255 100644
--- a/lib/dynamic_queue_limits.c
+++ b/lib/dynamic_queue_limits.c
@@ -3,12 +3,12 @@
  *
  * Copyright (c) 2011, Tom Herbert <therbert@google.com>
  */
-#include <linux/module.h>
 #include <linux/types.h>
-#include <linux/ctype.h>
 #include <linux/kernel.h>
 #include <linux/jiffies.h>
 #include <linux/dynamic_queue_limits.h>
+#include <linux/compiler.h>
+#include <linux/export.h>
 
 #define POSDIFF(A, B) ((int)((A) - (B)) > 0 ? (A) - (B) : 0)
 #define AFTER_EQ(A, B) ((int)((A) - (B)) >= 0)
diff --git a/lib/genalloc.c b/lib/genalloc.c
index 2e65d206b01c..0fe1cbe87700 100644
--- a/lib/genalloc.c
+++ b/lib/genalloc.c
@@ -34,7 +34,6 @@
 #include <linux/rculist.h>
 #include <linux/interrupt.h>
 #include <linux/genalloc.h>
-#include <linux/of_address.h>
 #include <linux/of_device.h>
 
 static inline size_t chunk_size(const struct gen_pool_chunk *chunk)
@@ -415,7 +414,7 @@ bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start,
                         size_t size)
 {
         bool found = false;
-        unsigned long end = start + size;
+        unsigned long end = start + size - 1;
         struct gen_pool_chunk *chunk;
 
         rcu_read_lock();
diff --git a/lib/halfmd4.c b/lib/halfmd4.c
index 66d0ee8b7776..a8fe6274a13c 100644
--- a/lib/halfmd4.c
+++ b/lib/halfmd4.c
@@ -1,4 +1,4 @@
-#include <linux/kernel.h>
+#include <linux/compiler.h>
 #include <linux/export.h>
 #include <linux/cryptohash.h>
 
diff --git a/lib/hexdump.c b/lib/hexdump.c
index 270773b91923..7ea09699855d 100644
--- a/lib/hexdump.c
+++ b/lib/hexdump.c
@@ -97,63 +97,79 @@ EXPORT_SYMBOL(bin2hex);
  *
  * example output buffer:
  * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
+ *
+ * Return:
+ * The amount of bytes placed in the buffer without terminating NUL. If the
+ * output was truncated, then the return value is the number of bytes
+ * (excluding the terminating NUL) which would have been written to the final
+ * string if enough space had been available.
  */
-void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
-                        int groupsize, char *linebuf, size_t linebuflen,
-                        bool ascii)
+int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
+                       char *linebuf, size_t linebuflen, bool ascii)
 {
         const u8 *ptr = buf;
+        int ngroups;
         u8 ch;
         int j, lx = 0;
         int ascii_column;
+        int ret;
 
         if (rowsize != 16 && rowsize != 32)
                 rowsize = 16;
 
-        if (!len)
-                goto nil;
         if (len > rowsize)              /* limit to one line at a time */
                 len = rowsize;
+        if (!is_power_of_2(groupsize) || groupsize > 8)
+                groupsize = 1;
         if ((len % groupsize) != 0)     /* no mixed size output */
                 groupsize = 1;
 
-        switch (groupsize) {
-        case 8: {
-                const u64 *ptr8 = buf;
-                int ngroups = len / groupsize;
+        ngroups = len / groupsize;
+        ascii_column = rowsize * 2 + rowsize / groupsize + 1;
 
-                for (j = 0; j < ngroups; j++)
-                        lx += scnprintf(linebuf + lx, linebuflen - lx,
-                                        "%s%16.16llx", j ? " " : "",
-                                        (unsigned long long)*(ptr8 + j));
-                ascii_column = 17 * ngroups + 2;
-                break;
-        }
+        if (!linebuflen)
+                goto overflow1;
 
-        case 4: {
-                const u32 *ptr4 = buf;
-                int ngroups = len / groupsize;
+        if (!len)
+                goto nil;
 
-                for (j = 0; j < ngroups; j++)
-                        lx += scnprintf(linebuf + lx, linebuflen - lx,
-                                        "%s%8.8x", j ? " " : "", *(ptr4 + j));
-                ascii_column = 9 * ngroups + 2;
-                break;
-        }
+        if (groupsize == 8) {
+                const u64 *ptr8 = buf;
 
-        case 2: {
-                const u16 *ptr2 = buf;
-                int ngroups = len / groupsize;
+                for (j = 0; j < ngroups; j++) {
+                        ret = snprintf(linebuf + lx, linebuflen - lx,
+                                       "%s%16.16llx", j ? " " : "",
+                                       (unsigned long long)*(ptr8 + j));
+                        if (ret >= linebuflen - lx)
+                                goto overflow1;
+                        lx += ret;
+                }
+        } else if (groupsize == 4) {
+                const u32 *ptr4 = buf;
 
-                for (j = 0; j < ngroups; j++)
-                        lx += scnprintf(linebuf + lx, linebuflen - lx,
-                                        "%s%4.4x", j ? " " : "", *(ptr2 + j));
-                ascii_column = 5 * ngroups + 2;
-                break;
-        }
+                for (j = 0; j < ngroups; j++) {
+                        ret = snprintf(linebuf + lx, linebuflen - lx,
+                                       "%s%8.8x", j ? " " : "",
+                                       *(ptr4 + j));
+                        if (ret >= linebuflen - lx)
+                                goto overflow1;
+                        lx += ret;
+                }
+        } else if (groupsize == 2) {
+                const u16 *ptr2 = buf;
 
-        default:
-                for (j = 0; (j < len) && (lx + 3) <= linebuflen; j++) {
+                for (j = 0; j < ngroups; j++) {
+                        ret = snprintf(linebuf + lx, linebuflen - lx,
+                                       "%s%4.4x", j ? " " : "",
+                                       *(ptr2 + j));
+                        if (ret >= linebuflen - lx)
+                                goto overflow1;
+                        lx += ret;
+                }
+        } else {
+                for (j = 0; j < len; j++) {
+                        if (linebuflen < lx + 3)
+                                goto overflow2;
                         ch = ptr[j];
                         linebuf[lx++] = hex_asc_hi(ch);
                         linebuf[lx++] = hex_asc_lo(ch);
@@ -161,21 +177,28 @@ void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
                 }
                 if (j)
                         lx--;
-
-                ascii_column = 3 * rowsize + 2;
-                break;
         }
         if (!ascii)
                 goto nil;
 
-        while (lx < (linebuflen - 1) && lx < (ascii_column - 1))
+        while (lx < ascii_column) {
+                if (linebuflen < lx + 2)
+                        goto overflow2;
                 linebuf[lx++] = ' ';
-        for (j = 0; (j < len) && (lx + 2) < linebuflen; j++) {
+        }
+        for (j = 0; j < len; j++) {
+                if (linebuflen < lx + 2)
+                        goto overflow2;
                 ch = ptr[j];
                 linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
         }
 nil:
+        linebuf[lx] = '\0';
+        return lx;
+overflow2:
         linebuf[lx++] = '\0';
+overflow1:
+        return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
 }
 EXPORT_SYMBOL(hex_dump_to_buffer);
 
diff --git a/lib/idr.c b/lib/idr.c
index e654aebd5f80..5335c43adf46 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -30,7 +30,6 @@
 #include <linux/idr.h>
 #include <linux/spinlock.h>
 #include <linux/percpu.h>
-#include <linux/hardirq.h>
 
 #define MAX_IDR_SHIFT           (sizeof(int) * 8 - 1)
 #define MAX_IDR_BIT             (1U << MAX_IDR_SHIFT)
diff --git a/lib/interval_tree.c b/lib/interval_tree.c
index f367f9ad544c..c85f6600a5f8 100644
--- a/lib/interval_tree.c
+++ b/lib/interval_tree.c
@@ -1,7 +1,7 @@
-#include <linux/init.h>
 #include <linux/interval_tree.h>
 #include <linux/interval_tree_generic.h>
-#include <linux/module.h>
+#include <linux/compiler.h>
+#include <linux/export.h>
 
 #define START(node) ((node)->start)
 #define LAST(node)  ((node)->last)
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 9ebf9e20de53..f6c2c1e7779c 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -20,7 +20,6 @@
 #include <linux/export.h>
 #include <linux/kmod.h>
 #include <linux/slab.h>
-#include <linux/user_namespace.h>
 #include <linux/socket.h>
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
diff --git a/lib/lcm.c b/lib/lcm.c
index 51cc6b13cd52..e97dbd51e756 100644
--- a/lib/lcm.c
+++ b/lib/lcm.c
@@ -1,4 +1,4 @@
-#include <linux/kernel.h>
+#include <linux/compiler.h>
 #include <linux/gcd.h>
 #include <linux/export.h>
 #include <linux/lcm.h>
diff --git a/lib/list_sort.c b/lib/list_sort.c
index 12bcba1c8612..b29015102698 100644
--- a/lib/list_sort.c
+++ b/lib/list_sort.c
@@ -2,9 +2,11 @@
 #define pr_fmt(fmt) "list_sort_test: " fmt
 
 #include <linux/kernel.h>
-#include <linux/module.h>
+#include <linux/bug.h>
+#include <linux/compiler.h>
+#include <linux/export.h>
+#include <linux/string.h>
 #include <linux/list_sort.h>
-#include <linux/slab.h>
 #include <linux/list.h>
 
 #define MAX_LIST_LENGTH_BITS 20
@@ -146,6 +148,7 @@ EXPORT_SYMBOL(list_sort);
 
 #ifdef CONFIG_TEST_LIST_SORT
 
+#include <linux/slab.h>
 #include <linux/random.h>
 
 /*
diff --git a/lib/llist.c b/lib/llist.c
index f76196d07409..0b0e9779d675 100644
--- a/lib/llist.c
+++ b/lib/llist.c
@@ -24,7 +24,6 @@
  */
 #include <linux/kernel.h>
 #include <linux/export.h>
-#include <linux/interrupt.h>
 #include <linux/llist.h>
 
 
diff --git a/lib/md5.c b/lib/md5.c
index 958a3c15923c..bb0cd01d356d 100644
--- a/lib/md5.c
+++ b/lib/md5.c
@@ -1,4 +1,4 @@
-#include <linux/kernel.h>
+#include <linux/compiler.h>
 #include <linux/export.h>
 #include <linux/cryptohash.h>
 
diff --git a/lib/nlattr.c b/lib/nlattr.c
index 9c3e85ff0a6c..76a1b59523ab 100644
--- a/lib/nlattr.c
+++ b/lib/nlattr.c
@@ -9,7 +9,6 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/jiffies.h>
-#include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <linux/string.h>
 #include <linux/types.h>
diff --git a/lib/percpu_ida.c b/lib/percpu_ida.c
index 93d145e5539c..f75715131f20 100644
--- a/lib/percpu_ida.c
+++ b/lib/percpu_ida.c
@@ -19,13 +19,10 @@
 #include <linux/bug.h>
 #include <linux/err.h>
 #include <linux/export.h>
-#include <linux/hardirq.h>
-#include <linux/idr.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
 #include <linux/percpu_ida.h>
diff --git a/lib/plist.c b/lib/plist.c
index d408e774b746..3a30c53db061 100644
--- a/lib/plist.c
+++ b/lib/plist.c
@@ -25,7 +25,6 @@
 
 #include <linux/bug.h>
 #include <linux/plist.h>
-#include <linux/spinlock.h>
 
 #ifdef CONFIG_DEBUG_PI_LIST
 
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 3291a8e37490..3d2aa27b845b 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -33,7 +33,7 @@
 #include <linux/string.h>
 #include <linux/bitops.h>
 #include <linux/rcupdate.h>
-#include <linux/hardirq.h>              /* in_interrupt() */
+#include <linux/preempt_mask.h>         /* in_interrupt() */
 
 
 /*
diff --git a/lib/show_mem.c b/lib/show_mem.c
index 7de89f4a36cf..adc98e1825ba 100644
--- a/lib/show_mem.c
+++ b/lib/show_mem.c
@@ -6,7 +6,6 @@
  */
 
 #include <linux/mm.h>
-#include <linux/nmi.h>
 #include <linux/quicklist.h>
 #include <linux/cma.h>
 
diff --git a/lib/sort.c b/lib/sort.c
index 926d00429ed2..43c9fe73ae2e 100644
--- a/lib/sort.c
+++ b/lib/sort.c
@@ -4,10 +4,9 @@
  * Jan 23 2005  Matt Mackall <mpm@selenic.com>
  */
 
-#include <linux/kernel.h>
-#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/export.h>
 #include <linux/sort.h>
-#include <linux/slab.h>
 
 static void u32_swap(void *a, void *b, int size)
 {
@@ -85,6 +84,7 @@ void sort(void *base, size_t num, size_t size,
 EXPORT_SYMBOL(sort);
 
 #if 0
+#include <linux/slab.h>
 /* a simple boot-time regression test */
 
 int cmpint(const void *a, const void *b)
diff --git a/lib/stmp_device.c b/lib/stmp_device.c
index 8ac9bcc4289a..a904656f4fd7 100644
--- a/lib/stmp_device.c
+++ b/lib/stmp_device.c
@@ -15,7 +15,8 @@
 #include <linux/io.h>
 #include <linux/errno.h>
 #include <linux/delay.h>
-#include <linux/module.h>
+#include <linux/compiler.h>
+#include <linux/export.h>
 #include <linux/stmp_device.h>
 
 #define STMP_MODULE_CLKGATE     (1 << 30)
diff --git a/lib/string.c b/lib/string.c
index 10063300b830..3206d0178296 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -58,14 +58,6 @@ int strncasecmp(const char *s1, const char *s2, size_t len)
 }
 EXPORT_SYMBOL(strncasecmp);
 #endif
-#ifndef __HAVE_ARCH_STRNICMP
-#undef strnicmp
-int strnicmp(const char *s1, const char *s2, size_t len)
-{
-        return strncasecmp(s1, s2, len);
-}
-EXPORT_SYMBOL(strnicmp);
-#endif
 
 #ifndef __HAVE_ARCH_STRCASECMP
 int strcasecmp(const char *s1, const char *s2)
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 58b78ba57439..8f8c4417f228 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -20,19 +20,18 @@
  * @len:        length of buffer
  *
  * This function returns a string formatted to 3 significant figures
- * giving the size in the required units.  Returns 0 on success or
- * error on failure.  @buf is always zero terminated.
+ * giving the size in the required units.  @buf should have room for
+ * at least 9 bytes and will always be zero terminated.
  *
  */
-int string_get_size(u64 size, const enum string_size_units units,
-                    char *buf, int len)
+void string_get_size(u64 size, const enum string_size_units units,
+                     char *buf, int len)
 {
         static const char *const units_10[] = {
-                "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL
+                "B", "kB", "MB", "GB", "TB", "PB", "EB"
         };
         static const char *const units_2[] = {
-                "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB",
-                NULL
+                "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
         };
         static const char *const *const units_str[] = {
                 [STRING_UNITS_10] = units_10,
@@ -43,13 +42,13 @@ int string_get_size(u64 size, const enum string_size_units units,
                 [STRING_UNITS_2] = 1024,
         };
         int i, j;
-        u64 remainder = 0, sf_cap;
+        u32 remainder = 0, sf_cap;
         char tmp[8];
 
         tmp[0] = '\0';
         i = 0;
         if (size >= divisor[units]) {
-                while (size >= divisor[units] && units_str[units][i]) {
+                while (size >= divisor[units]) {
                         remainder = do_div(size, divisor[units]);
                         i++;
                 }
@@ -60,17 +59,14 @@ int string_get_size(u64 size, const enum string_size_units units,
 
                 if (j) {
                         remainder *= 1000;
-                        do_div(remainder, divisor[units]);
-                        snprintf(tmp, sizeof(tmp), ".%03lld",
-                                 (unsigned long long)remainder);
+                        remainder /= divisor[units];
+                        snprintf(tmp, sizeof(tmp), ".%03u", remainder);
                         tmp[j+1] = '\0';
                 }
         }
 
-        snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
+        snprintf(buf, len, "%u%s %s", (u32)size,
                  tmp, units_str[units][i]);
-
-        return 0;
 }
 EXPORT_SYMBOL(string_get_size);
 
diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c
index bb2b201d6ad0..e0af6ff73d14 100644
--- a/lib/strncpy_from_user.c
+++ b/lib/strncpy_from_user.c
@@ -1,4 +1,5 @@
-#include <linux/module.h>
+#include <linux/compiler.h>
+#include <linux/export.h>
 #include <linux/uaccess.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/lib/test-hexdump.c b/lib/test-hexdump.c
new file mode 100644
index 000000000000..daf29a390a89
--- /dev/null
+++ b/lib/test-hexdump.c
@@ -0,0 +1,180 @@
+/*
+ * Test cases for lib/hexdump.c module.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/random.h>
+#include <linux/string.h>
+
+static const unsigned char data_b[] = {
+        '\xbe', '\x32', '\xdb', '\x7b', '\x0a', '\x18', '\x93', '\xb2', /* 00 - 07 */
+        '\x70', '\xba', '\xc4', '\x24', '\x7d', '\x83', '\x34', '\x9b', /* 08 - 0f */
+        '\xa6', '\x9c', '\x31', '\xad', '\x9c', '\x0f', '\xac', '\xe9', /* 10 - 17 */
+        '\x4c', '\xd1', '\x19', '\x99', '\x43', '\xb1', '\xaf', '\x0c', /* 18 - 1f */
+};
+
+static const unsigned char data_a[] = ".2.{....p..$}.4...1.....L...C...";
+
+static const char *test_data_1_le[] __initconst = {
+        "be", "32", "db", "7b", "0a", "18", "93", "b2",
+        "70", "ba", "c4", "24", "7d", "83", "34", "9b",
+        "a6", "9c", "31", "ad", "9c", "0f", "ac", "e9",
+        "4c", "d1", "19", "99", "43", "b1", "af", "0c",
+};
+
+static const char *test_data_2_le[] __initconst = {
+        "32be", "7bdb", "180a", "b293",
+        "ba70", "24c4", "837d", "9b34",
+        "9ca6", "ad31", "0f9c", "e9ac",
+        "d14c", "9919", "b143", "0caf",
+};
+
+static const char *test_data_4_le[] __initconst = {
+        "7bdb32be", "b293180a", "24c4ba70", "9b34837d",
+        "ad319ca6", "e9ac0f9c", "9919d14c", "0cafb143",
+};
+
+static const char *test_data_8_le[] __initconst = {
+        "b293180a7bdb32be", "9b34837d24c4ba70",
+        "e9ac0f9cad319ca6", "0cafb1439919d14c",
+};
+
+static void __init test_hexdump(size_t len, int rowsize, int groupsize,
+                                bool ascii)
+{
+        char test[32 * 3 + 2 + 32 + 1];
+        char real[32 * 3 + 2 + 32 + 1];
+        char *p;
+        const char **result;
+        size_t l = len;
+        int gs = groupsize, rs = rowsize;
+        unsigned int i;
+
+        hex_dump_to_buffer(data_b, l, rs, gs, real, sizeof(real), ascii);
+
+        if (rs != 16 && rs != 32)
+                rs = 16;
+
+        if (l > rs)
+                l = rs;
+
+        if (!is_power_of_2(gs) || gs > 8 || (len % gs != 0))
+                gs = 1;
+
+        if (gs == 8)
+                result = test_data_8_le;
+        else if (gs == 4)
+                result = test_data_4_le;
+        else if (gs == 2)
+                result = test_data_2_le;
+        else
+                result = test_data_1_le;
+
+        memset(test, ' ', sizeof(test));
+
+        /* hex dump */
+        p = test;
+        for (i = 0; i < l / gs; i++) {
+                const char *q = *result++;
+                size_t amount = strlen(q);
+
+                strncpy(p, q, amount);
+                p += amount + 1;
+        }
+        if (i)
+                p--;
+
+        /* ASCII part */
+        if (ascii) {
+                p = test + rs * 2 + rs / gs + 1;
+                strncpy(p, data_a, l);
+                p += l;
+        }
+
+        *p = '\0';
+
+        if (strcmp(test, real)) {
+                pr_err("Len: %zu row: %d group: %d\n", len, rowsize, groupsize);
+                pr_err("Result: '%s'\n", real);
+                pr_err("Expect: '%s'\n", test);
+        }
+}
+
+static void __init test_hexdump_set(int rowsize, bool ascii)
+{
+        size_t d = min_t(size_t, sizeof(data_b), rowsize);
+        size_t len = get_random_int() % d + 1;
+
+        test_hexdump(len, rowsize, 4, ascii);
+        test_hexdump(len, rowsize, 2, ascii);
+        test_hexdump(len, rowsize, 8, ascii);
+        test_hexdump(len, rowsize, 1, ascii);
+}
+
+static void __init test_hexdump_overflow(bool ascii)
+{
+        char buf[56];
+        const char *t = test_data_1_le[0];
+        size_t l = get_random_int() % sizeof(buf);
+        bool a;
+        int e, r;
+
+        memset(buf, ' ', sizeof(buf));
+
+        r = hex_dump_to_buffer(data_b, 1, 16, 1, buf, l, ascii);
+
+        if (ascii)
+                e = 50;
+        else
+                e = 2;
+        buf[e + 2] = '\0';
+
+        if (!l) {
+                a = r == e && buf[0] == ' ';
+        } else if (l < 3) {
+                a = r == e && buf[0] == '\0';
+        } else if (l < 4) {
+                a = r == e && !strcmp(buf, t);
+        } else if (ascii) {
+                if (l < 51)
+                        a = r == e && buf[l - 1] == '\0' && buf[l - 2] == ' ';
+                else
+                        a = r == e && buf[50] == '\0' && buf[49] == '.';
+        } else {
+                a = r == e && buf[e] == '\0';
+        }
+
+        if (!a) {
+                pr_err("Len: %zu rc: %u strlen: %zu\n", l, r, strlen(buf));
+                pr_err("Result: '%s'\n", buf);
+        }
+}
+
+static int __init test_hexdump_init(void)
+{
+        unsigned int i;
+        int rowsize;
+
+        pr_info("Running tests...\n");
+
+        rowsize = (get_random_int() % 2 + 1) * 16;
+        for (i = 0; i < 16; i++)
+                test_hexdump_set(rowsize, false);
+
+        rowsize = (get_random_int() % 2 + 1) * 16;
+        for (i = 0; i < 16; i++)
+                test_hexdump_set(rowsize, true);
+
+        for (i = 0; i < 16; i++)
+                test_hexdump_overflow(false);
+
+        for (i = 0; i < 16; i++)
+                test_hexdump_overflow(true);
+
+        return -EINVAL;
+}
+module_init(test_hexdump_init);
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index ec337f64f52d..602d2081e713 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -114,8 +114,9 @@ int skip_atoi(const char **s)
 {
         int i = 0;
 
-        while (isdigit(**s))
+        do {
                 i = i*10 + *((*s)++) - '0';
+        } while (isdigit(**s));
 
         return i;
 }
@@ -1604,8 +1605,7 @@ qualifier:
 
         case 'p':
                 spec->type = FORMAT_TYPE_PTR;
-                return fmt - start;
-                /* skip alnum */
+                return ++fmt - start;
 
         case '%':
                 spec->type = FORMAT_TYPE_PERCENT_CHAR;
@@ -1728,7 +1728,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 
         /* Reject out-of-range values early.  Large positive sizes are
            used for unknown buffer sizes. */
-        if (WARN_ON_ONCE((int) size < 0))
+        if (WARN_ON_ONCE(size > INT_MAX))
                 return 0;
 
         str = buf;
@@ -1794,7 +1794,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                         break;
 
                 case FORMAT_TYPE_PTR:
-                        str = pointer(fmt+1, str, end, va_arg(args, void *),
+                        str = pointer(fmt, str, end, va_arg(args, void *),
                                       spec);
                         while (isalnum(*fmt))
                                 fmt++;
@@ -2232,7 +2232,7 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
                 }
 
                 case FORMAT_TYPE_PTR:
-                        str = pointer(fmt+1, str, end, get_arg(void *), spec);
+                        str = pointer(fmt, str, end, get_arg(void *), spec);
                         while (isalnum(*fmt))
                                 fmt++;
                         break;