14 files changed, 248 insertions, 69 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 9c10e38fc609..830181cc7a83 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -19,16 +19,6 @@ config RATIONAL
 config GENERIC_FIND_FIRST_BIT
         bool
 
-config GENERIC_FIND_NEXT_BIT
-        bool
-
-config GENERIC_FIND_BIT_LE
-        bool
-
-config GENERIC_FIND_LAST_BIT
-        bool
-        default y
-
 config CRC_CCITT
         tristate "CRC-CCITT functions"
         help
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 0efcdca9751a..dd373c8ee943 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -670,6 +670,15 @@ config STACKTRACE
         bool
         depends on STACKTRACE_SUPPORT
 
+config DEBUG_STACK_USAGE
+        bool "Stack utilization instrumentation"
+        depends on DEBUG_KERNEL
+        help
+          Enables the display of the minimum amount of free stack which each
+          task has ever had available in the sysrq-T and sysrq-P debug output.
+
+          This option will slow down process creation somewhat.
+
 config DEBUG_KOBJECT
         bool "kobject debugging"
         depends on DEBUG_KERNEL
@@ -688,7 +697,7 @@ config DEBUG_BUGVERBOSE
         bool "Verbose BUG() reporting (adds 70K)" if DEBUG_KERNEL && EXPERT
         depends on BUG
         depends on ARM || AVR32 || M32R || M68K || SPARC32 || SPARC64 || \
-                   FRV || SUPERH || GENERIC_BUG || BLACKFIN || MN10300
+                   FRV || SUPERH || GENERIC_BUG || BLACKFIN || MN10300 || TILE
         default y
         help
           Say Y here to make BUG() panics output the file name and line number
@@ -983,6 +992,17 @@ config DEBUG_FORCE_WEAK_PER_CPU
           To ensure that generic code follows the above rules, this
           option forces all percpu variables to be defined as weak.
 
+config DEBUG_PER_CPU_MAPS
+        bool "Debug access to per_cpu maps"
+        depends on DEBUG_KERNEL
+        depends on SMP
+        help
+          Say Y to verify that the per_cpu map being accessed has
+          been set up. This adds a fair amount of code to kernel memory
+          and decreases performance.
+
+          Say N if unsure.
+
 config LKDTM
         tristate "Linux Kernel Dump Test Tool Module"
         depends on DEBUG_FS
diff --git a/lib/Makefile b/lib/Makefile
index 4b49a249064b..6b597fdb1898 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -12,7 +12,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          idr.o int_sqrt.o extable.o prio_tree.o \
          sha1.o irq_regs.o reciprocal_div.o argv_split.o \
          proportions.o prio_heap.o ratelimit.o show_mem.o \
-         is_single_threaded.o plist.o decompress.o
+         is_single_threaded.o plist.o decompress.o find_next_bit.o
 
 lib-$(CONFIG_MMU) += ioremap.o
 lib-$(CONFIG_SMP) += cpumask.o
@@ -22,7 +22,7 @@ lib-y	+= kobject.o kref.o klist.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 \
          string_helpers.o gcd.o lcm.o list_sort.o uuid.o flex_array.o \
-         bsearch.o
+         bsearch.o find_last_bit.o
 obj-y += kstrtox.o
 obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
 
@@ -39,10 +39,6 @@ obj-$(CONFIG_DEBUG_LOCKING_API_SELFTESTS) += locking-selftest.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock_debug.o
 lib-$(CONFIG_RWSEM_GENERIC_SPINLOCK) += rwsem-spinlock.o
 lib-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem.o
-lib-$(CONFIG_GENERIC_FIND_FIRST_BIT) += find_next_bit.o
-lib-$(CONFIG_GENERIC_FIND_NEXT_BIT) += find_next_bit.o
-lib-$(CONFIG_GENERIC_FIND_BIT_LE) += find_next_bit.o
-obj-$(CONFIG_GENERIC_FIND_LAST_BIT) += find_last_bit.o
 
 CFLAGS_hweight.o = $(subst $(quote),,$(CONFIG_ARCH_HWEIGHT_CFLAGS))
 obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o
diff --git a/lib/audit.c b/lib/audit.c
index 8e7dc1c63aa9..76bbed4a20e5 100644
--- a/lib/audit.c
+++ b/lib/audit.c
@@ -36,8 +36,10 @@ int audit_classify_arch(int arch)
 int audit_classify_syscall(int abi, unsigned syscall)
 {
         switch(syscall) {
+#ifdef __NR_open
         case __NR_open:
                 return 2;
+#endif
 #ifdef __NR_openat
         case __NR_openat:
                 return 3;
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 91e0ccfdb424..41baf02924e6 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -571,8 +571,11 @@ int bitmap_scnlistprintf(char *buf, unsigned int buflen,
 EXPORT_SYMBOL(bitmap_scnlistprintf);
 
 /**
- * bitmap_parselist - convert list format ASCII string to bitmap
+ * __bitmap_parselist - convert list format ASCII string to bitmap
  * @bp: read nul-terminated user string from this buffer
+ * @buflen: buffer size in bytes.  If string is smaller than this
+ *    then it must be terminated with a \0.
+ * @is_user: location of buffer, 0 indicates kernel space
  * @maskp: write resulting mask here
  * @nmaskbits: number of bits in mask to be written
  *
@@ -587,20 +590,63 @@ EXPORT_SYMBOL(bitmap_scnlistprintf);
  *    %-EINVAL: invalid character in string
  *    %-ERANGE: bit number specified too large for mask
  */
-int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
+static int __bitmap_parselist(const char *buf, unsigned int buflen,
+                int is_user, unsigned long *maskp,
+                int nmaskbits)
 {
         unsigned a, b;
+        int c, old_c, totaldigits;
+        const char __user *ubuf = buf;
+        int exp_digit, in_range;
 
+        totaldigits = c = 0;
         bitmap_zero(maskp, nmaskbits);
         do {
-                if (!isdigit(*bp))
-                        return -EINVAL;
-                b = a = simple_strtoul(bp, (char **)&bp, BASEDEC);
-                if (*bp == '-') {
-                        bp++;
-                        if (!isdigit(*bp))
+                exp_digit = 1;
+                in_range = 0;
+                a = b = 0;
+
+                /* Get the next cpu# or a range of cpu#'s */
+                while (buflen) {
+                        old_c = c;
+                        if (is_user) {
+                                if (__get_user(c, ubuf++))
+                                        return -EFAULT;
+                        } else
+                                c = *buf++;
+                        buflen--;
+                        if (isspace(c))
+                                continue;
+
+                        /*
+                         * If the last character was a space and the current
+                         * character isn't '\0', we've got embedded whitespace.
+                         * This is a no-no, so throw an error.
+                         */
+                        if (totaldigits && c && isspace(old_c))
+                                return -EINVAL;
+
+                        /* A '\0' or a ',' signal the end of a cpu# or range */
+                        if (c == '\0' || c == ',')
+                                break;
+
+                        if (c == '-') {
+                                if (exp_digit || in_range)
+                                        return -EINVAL;
+                                b = 0;
+                                in_range = 1;
+                                exp_digit = 1;
+                                continue;
+                        }
+
+                        if (!isdigit(c))
                                 return -EINVAL;
-                        b = simple_strtoul(bp, (char **)&bp, BASEDEC);
+
+                        b = b * 10 + (c - '0');
+                        if (!in_range)
+                                a = b;
+                        exp_digit = 0;
+                        totaldigits++;
                 }
                 if (!(a <= b))
                         return -EINVAL;
@@ -610,13 +656,52 @@ int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
                         set_bit(a, maskp);
                         a++;
                 }
-                if (*bp == ',')
-                        bp++;
-        } while (*bp != '\0' && *bp != '\n');
+        } while (buflen && c == ',');
         return 0;
 }
+
+int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
+{
+        char *nl  = strchr(bp, '\n');
+        int len;
+
+        if (nl)
+                len = nl - bp;
+        else
+                len = strlen(bp);
+
+        return __bitmap_parselist(bp, len, 0, maskp, nmaskbits);
+}
 EXPORT_SYMBOL(bitmap_parselist);
 
+
+/**
+ * bitmap_parselist_user()
+ *
+ * @ubuf: pointer to user buffer containing string.
+ * @ulen: buffer size in bytes.  If string is smaller than this
+ *    then it must be terminated with a \0.
+ * @maskp: pointer to bitmap array that will contain result.
+ * @nmaskbits: size of bitmap, in bits.
+ *
+ * Wrapper for bitmap_parselist(), providing it with user buffer.
+ *
+ * We cannot have this as an inline function in bitmap.h because it needs
+ * linux/uaccess.h to get the access_ok() declaration and this causes
+ * cyclic dependencies.
+ */
+int bitmap_parselist_user(const char __user *ubuf,
+                        unsigned int ulen, unsigned long *maskp,
+                        int nmaskbits)
+{
+        if (!access_ok(VERIFY_READ, ubuf, ulen))
+                return -EFAULT;
+        return __bitmap_parselist((const char *)ubuf,
+                                        ulen, 1, maskp, nmaskbits);
+}
+EXPORT_SYMBOL(bitmap_parselist_user);
+
+
 /**
  * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
  *      @buf: pointer to a bitmap
diff --git a/lib/find_last_bit.c b/lib/find_last_bit.c
index 5d202e36bdd8..d903959ad695 100644
--- a/lib/find_last_bit.c
+++ b/lib/find_last_bit.c
@@ -15,6 +15,8 @@
 #include <asm/types.h>
 #include <asm/byteorder.h>
 
+#ifndef find_last_bit
+
 unsigned long find_last_bit(const unsigned long *addr, unsigned long size)
 {
         unsigned long words;
@@ -43,3 +45,5 @@ found:
         return size;
 }
 EXPORT_SYMBOL(find_last_bit);
+
+#endif
diff --git a/lib/find_next_bit.c b/lib/find_next_bit.c
index b0a8767282bf..4bd75a73ba00 100644
--- a/lib/find_next_bit.c
+++ b/lib/find_next_bit.c
@@ -16,7 +16,7 @@
 
 #define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
 
-#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
+#ifndef find_next_bit
 /*
  * Find the next set bit in a memory region.
  */
@@ -59,7 +59,9 @@ found_middle:
         return result + __ffs(tmp);
 }
 EXPORT_SYMBOL(find_next_bit);
+#endif
 
+#ifndef find_next_zero_bit
 /*
  * This implementation of find_{first,next}_zero_bit was stolen from
  * Linus' asm-alpha/bitops.h.
@@ -103,9 +105,9 @@ found_middle:
         return result + ffz(tmp);
 }
 EXPORT_SYMBOL(find_next_zero_bit);
-#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
+#endif
 
-#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
+#ifndef find_first_bit
 /*
  * Find the first set bit in a memory region.
  */
@@ -131,7 +133,9 @@ found:
         return result + __ffs(tmp);
 }
 EXPORT_SYMBOL(find_first_bit);
+#endif
 
+#ifndef find_first_zero_bit
 /*
  * Find the first cleared bit in a memory region.
  */
@@ -157,10 +161,9 @@ found:
         return result + ffz(tmp);
 }
 EXPORT_SYMBOL(find_first_zero_bit);
-#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
+#endif
 
 #ifdef __BIG_ENDIAN
-#ifdef CONFIG_GENERIC_FIND_BIT_LE
 
 /* include/linux/byteorder does not support "unsigned long" type */
 static inline unsigned long ext2_swabp(const unsigned long * x)
@@ -186,6 +189,7 @@ static inline unsigned long ext2_swab(const unsigned long y)
 #endif
 }
 
+#ifndef find_next_zero_bit_le
 unsigned long find_next_zero_bit_le(const void *addr, unsigned
                 long size, unsigned long offset)
 {
@@ -229,7 +233,9 @@ found_middle_swap:
         return result + ffz(ext2_swab(tmp));
 }
 EXPORT_SYMBOL(find_next_zero_bit_le);
+#endif
 
+#ifndef find_next_bit_le
 unsigned long find_next_bit_le(const void *addr, unsigned
                 long size, unsigned long offset)
 {
@@ -274,6 +280,6 @@ found_middle_swap:
         return result + __ffs(ext2_swab(tmp));
 }
 EXPORT_SYMBOL(find_next_bit_le);
+#endif
 
-#endif /* CONFIG_GENERIC_FIND_BIT_LE */
 #endif /* __BIG_ENDIAN */
diff --git a/lib/flex_array.c b/lib/flex_array.c
index 854b57bd7d9d..9b8b89458c4c 100644
--- a/lib/flex_array.c
+++ b/lib/flex_array.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/stddef.h>
 #include <linux/module.h>
+#include <linux/reciprocal_div.h>
 
 struct flex_array_part {
         char elements[FLEX_ARRAY_PART_SIZE];
@@ -70,15 +71,15 @@ static inline int elements_fit_in_base(struct flex_array *fa)
  * Element size | Objects | Objects |
  * PAGE_SIZE=4k |  32-bit |  64-bit |
  * ---------------------------------|
- *      1 bytes | 4186112 | 2093056 |
- *      2 bytes | 2093056 | 1046528 |
- *      3 bytes | 1395030 |  697515 |
- *      4 bytes | 1046528 |  523264 |
- *     32 bytes |  130816 |   65408 |
- *     33 bytes |  126728 |   63364 |
- *   2048 bytes |    2044 |    1022 |
- *   2049 bytes |    1022 |     511 |
- *       void * | 1046528 |  261632 |
+ *      1 bytes | 4177920 | 2088960 |
+ *      2 bytes | 2088960 | 1044480 |
+ *      3 bytes | 1392300 |  696150 |
+ *      4 bytes | 1044480 |  522240 |
+ *     32 bytes |  130560 |   65408 |
+ *     33 bytes |  126480 |   63240 |
+ *   2048 bytes |    2040 |    1020 |
+ *   2049 bytes |    1020 |     510 |
+ *       void * | 1044480 |  261120 |
  *
  * Since 64-bit pointers are twice the size, we lose half the
  * capacity in the base structure.  Also note that no effort is made
@@ -88,8 +89,15 @@ struct flex_array *flex_array_alloc(int element_size, unsigned int total,
                                         gfp_t flags)
 {
         struct flex_array *ret;
-        int max_size = FLEX_ARRAY_NR_BASE_PTRS *
-                                FLEX_ARRAY_ELEMENTS_PER_PART(element_size);
+        int elems_per_part = 0;
+        int reciprocal_elems = 0;
+        int max_size = 0;
+
+        if (element_size) {
+                elems_per_part = FLEX_ARRAY_ELEMENTS_PER_PART(element_size);
+                reciprocal_elems = reciprocal_value(elems_per_part);
+                max_size = FLEX_ARRAY_NR_BASE_PTRS * elems_per_part;
+        }
 
         /* max_size will end up 0 if element_size > PAGE_SIZE */
         if (total > max_size)
@@ -99,6 +107,8 @@ struct flex_array *flex_array_alloc(int element_size, unsigned int total,
                 return NULL;
         ret->element_size = element_size;
         ret->total_nr_elements = total;
+        ret->elems_per_part = elems_per_part;
+        ret->reciprocal_elems = reciprocal_elems;
         if (elements_fit_in_base(ret) && !(flags & __GFP_ZERO))
                 memset(&ret->parts[0], FLEX_ARRAY_FREE,
                                                 FLEX_ARRAY_BASE_BYTES_LEFT);
@@ -109,7 +119,7 @@ EXPORT_SYMBOL(flex_array_alloc);
 static int fa_element_to_part_nr(struct flex_array *fa,
                                         unsigned int element_nr)
 {
-        return element_nr / FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
+        return reciprocal_divide(element_nr, fa->reciprocal_elems);
 }
 
 /**
@@ -138,12 +148,12 @@ void flex_array_free(struct flex_array *fa)
 EXPORT_SYMBOL(flex_array_free);
 
 static unsigned int index_inside_part(struct flex_array *fa,
-                                        unsigned int element_nr)
+                                        unsigned int element_nr,
+                                        unsigned int part_nr)
 {
         unsigned int part_offset;
 
-        part_offset = element_nr %
-                                FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
+        part_offset = element_nr - part_nr * fa->elems_per_part;
         return part_offset * fa->element_size;
 }
 
@@ -183,20 +193,23 @@ __fa_get_part(struct flex_array *fa, int part_nr, gfp_t flags)
 int flex_array_put(struct flex_array *fa, unsigned int element_nr, void *src,
                         gfp_t flags)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
         void *dst;
 
         if (element_nr >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = __fa_get_part(fa, part_nr, flags);
                 if (!part)
                         return -ENOMEM;
         }
-        dst = &part->elements[index_inside_part(fa, element_nr)];
+        dst = &part->elements[index_inside_part(fa, element_nr, part_nr)];
         memcpy(dst, src, fa->element_size);
         return 0;
 }
@@ -211,20 +224,23 @@ EXPORT_SYMBOL(flex_array_put);
  */
 int flex_array_clear(struct flex_array *fa, unsigned int element_nr)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
         void *dst;
 
         if (element_nr >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = fa->parts[part_nr];
                 if (!part)
                         return -EINVAL;
         }
-        dst = &part->elements[index_inside_part(fa, element_nr)];
+        dst = &part->elements[index_inside_part(fa, element_nr, part_nr)];
         memset(dst, FLEX_ARRAY_FREE, fa->element_size);
         return 0;
 }
@@ -264,6 +280,8 @@ int flex_array_prealloc(struct flex_array *fa, unsigned int start,
 
         if (end >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 return 0;
         start_part = fa_element_to_part_nr(fa, start);
@@ -291,19 +309,22 @@ EXPORT_SYMBOL(flex_array_prealloc);
  */
 void *flex_array_get(struct flex_array *fa, unsigned int element_nr)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
 
+        if (!fa->element_size)
+                return NULL;
         if (element_nr >= fa->total_nr_elements)
                 return NULL;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = fa->parts[part_nr];
                 if (!part)
                         return NULL;
         }
-        return &part->elements[index_inside_part(fa, element_nr)];
+        return &part->elements[index_inside_part(fa, element_nr, part_nr)];
 }
 EXPORT_SYMBOL(flex_array_get);
 
@@ -353,7 +374,7 @@ int flex_array_shrink(struct flex_array *fa)
         int part_nr;
         int ret = 0;
 
-        if (!fa->total_nr_elements)
+        if (!fa->total_nr_elements || !fa->element_size)
                 return 0;
         if (elements_fit_in_base(fa))
                 return ret;
diff --git a/lib/genalloc.c b/lib/genalloc.c
index 1923f1490e72..577ddf805975 100644
--- a/lib/genalloc.c
+++ b/lib/genalloc.c
@@ -39,17 +39,20 @@ struct gen_pool *gen_pool_create(int min_alloc_order, int nid)
 EXPORT_SYMBOL(gen_pool_create);
 
 /**
- * gen_pool_add - add a new chunk of special memory to the pool
+ * gen_pool_add_virt - add a new chunk of special memory to the pool
  * @pool: pool to add new memory chunk to
- * @addr: starting address of memory chunk to add to pool
+ * @virt: virtual starting address of memory chunk to add to pool
+ * @phys: physical starting address of memory chunk to add to pool
  * @size: size in bytes of the memory chunk to add to pool
  * @nid: node id of the node the chunk structure and bitmap should be
  *       allocated on, or -1
  *
  * Add a new chunk of special memory to the specified pool.
+ *
+ * Returns 0 on success or a -ve errno on failure.
  */
-int gen_pool_add(struct gen_pool *pool, unsigned long addr, size_t size,
-                 int nid)
+int gen_pool_add_virt(struct gen_pool *pool, unsigned long virt, phys_addr_t phys,
+                 size_t size, int nid)
 {
         struct gen_pool_chunk *chunk;
         int nbits = size >> pool->min_alloc_order;
@@ -58,11 +61,12 @@ int gen_pool_add(struct gen_pool *pool, unsigned long addr, size_t size,
 
         chunk = kmalloc_node(nbytes, GFP_KERNEL | __GFP_ZERO, nid);
         if (unlikely(chunk == NULL))
-                return -1;
+                return -ENOMEM;
 
         spin_lock_init(&chunk->lock);
-        chunk->start_addr = addr;
-        chunk->end_addr = addr + size;
+        chunk->phys_addr = phys;
+        chunk->start_addr = virt;
+        chunk->end_addr = virt + size;
 
         write_lock(&pool->lock);
         list_add(&chunk->next_chunk, &pool->chunks);
@@ -70,7 +74,32 @@ int gen_pool_add(struct gen_pool *pool, unsigned long addr, size_t size,
 
         return 0;
 }
-EXPORT_SYMBOL(gen_pool_add);
+EXPORT_SYMBOL(gen_pool_add_virt);
+
+/**
+ * gen_pool_virt_to_phys - return the physical address of memory
+ * @pool: pool to allocate from
+ * @addr: starting address of memory
+ *
+ * Returns the physical address on success, or -1 on error.
+ */
+phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long addr)
+{
+        struct list_head *_chunk;
+        struct gen_pool_chunk *chunk;
+
+        read_lock(&pool->lock);
+        list_for_each(_chunk, &pool->chunks) {
+                chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk);
+
+                if (addr >= chunk->start_addr && addr < chunk->end_addr)
+                        return chunk->phys_addr + addr - chunk->start_addr;
+        }
+        read_unlock(&pool->lock);
+
+        return -1;
+}
+EXPORT_SYMBOL(gen_pool_virt_to_phys);
 
 /**
  * gen_pool_destroy - destroy a special memory pool
diff --git a/lib/kstrtox.c b/lib/kstrtox.c
index a235f3cc471c..2dbae88090ac 100644
--- a/lib/kstrtox.c
+++ b/lib/kstrtox.c
@@ -17,6 +17,7 @@
 #include <linux/math64.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <asm/uaccess.h>
 
 static inline char _tolower(const char c)
 {
@@ -222,3 +223,28 @@ int kstrtos8(const char *s, unsigned int base, s8 *res)
         return 0;
 }
 EXPORT_SYMBOL(kstrtos8);
+
+#define kstrto_from_user(f, g, type)                                    \
+int f(const char __user *s, size_t count, unsigned int base, type *res) \
+{                                                                       \
+        /* sign, base 2 representation, newline, terminator */          \
+        char buf[1 + sizeof(type) * 8 + 1 + 1];                         \
+                                                                        \
+        count = min(count, sizeof(buf) - 1);                            \
+        if (copy_from_user(buf, s, count))                              \
+                return -EFAULT;                                         \
+        buf[count] = '\0';                                              \
+        return g(buf, base, res);                                       \
+}                                                                       \
+EXPORT_SYMBOL(f)
+
+kstrto_from_user(kstrtoull_from_user,   kstrtoull,      unsigned long long);
+kstrto_from_user(kstrtoll_from_user,    kstrtoll,       long long);
+kstrto_from_user(kstrtoul_from_user,    kstrtoul,       unsigned long);
+kstrto_from_user(kstrtol_from_user,     kstrtol,        long);
+kstrto_from_user(kstrtouint_from_user,  kstrtouint,     unsigned int);
+kstrto_from_user(kstrtoint_from_user,   kstrtoint,      int);
+kstrto_from_user(kstrtou16_from_user,   kstrtou16,      u16);
+kstrto_from_user(kstrtos16_from_user,   kstrtos16,      s16);
+kstrto_from_user(kstrtou8_from_user,    kstrtou8,       u8);
+kstrto_from_user(kstrtos8_from_user,    kstrtos8,       s8);
diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index 619313ed6c46..507a22fab738 100644
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -144,7 +144,7 @@ static void init_shared_classes(void)
 
 #define HARDIRQ_ENTER()                         \
         local_irq_disable();                    \
-        irq_enter();                            \
+        __irq_enter();                          \
         WARN_ON(!in_irq());
 
 #define HARDIRQ_EXIT()                          \
diff --git a/lib/lru_cache.c b/lib/lru_cache.c
index 270de9d31b8c..a07e7268d7ed 100644
--- a/lib/lru_cache.c
+++ b/lib/lru_cache.c
@@ -84,7 +84,7 @@ struct lru_cache *lc_create(const char *name, struct kmem_cache *cache,
         if (e_count > LC_MAX_ACTIVE)
                 return NULL;
 
-        slot = kzalloc(e_count * sizeof(struct hlist_head*), GFP_KERNEL);
+        slot = kcalloc(e_count, sizeof(struct hlist_head), GFP_KERNEL);
         if (!slot)
                 goto out_fail;
         element = kzalloc(e_count * sizeof(struct lc_element *), GFP_KERNEL);
diff --git a/lib/show_mem.c b/lib/show_mem.c
index 90cbe4bb5960..4407f8c9b1f7 100644
--- a/lib/show_mem.c
+++ b/lib/show_mem.c
@@ -16,7 +16,7 @@ void show_mem(unsigned int filter)
                 nonshared = 0, highmem = 0;
 
         printk("Mem-Info:\n");
-        __show_free_areas(filter);
+        show_free_areas(filter);
 
         for_each_online_pgdat(pgdat) {
                 unsigned long i, flags;
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 1d659d7bb0f8..c11205688fb4 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -898,7 +898,7 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         case 'U':
                 return uuid_string(buf, end, ptr, spec, fmt);
         case 'V':
-                return buf + vsnprintf(buf, end - buf,
+                return buf + vsnprintf(buf, end > buf ? end - buf : 0,
                                        ((struct va_format *)ptr)->fmt,
                                        *(((struct va_format *)ptr)->va));
         case 'K':