16 files changed, 367 insertions, 110 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 c768bcdda1b7..28afa4c5333c 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -7,7 +7,8 @@ config PRINTK_TIME
           included in printk output.  This allows you to measure
           the interval between kernel operations, including bootup
           operations.  This is useful for identifying long delays
-          in kernel startup.
+          in kernel startup.  Or add printk.time=1 at boot-time.
+          See Documentation/kernel-parameters.txt
 
 config DEFAULT_MESSAGE_LOGLEVEL
         int "Default message log level (1-7)"
@@ -238,6 +239,21 @@ config DETECT_HUNG_TASK
           enabled then all held locks will also be reported. This
           feature has negligible overhead.
 
+config DEFAULT_HUNG_TASK_TIMEOUT
+        int "Default timeout for hung task detection (in seconds)"
+        depends on DETECT_HUNG_TASK
+        default 120
+        help
+          This option controls the default timeout (in seconds) used
+          to determine when a task has become non-responsive and should
+          be considered hung.
+
+          It can be adjusted at runtime via the kernel.hung_task_timeout
+          sysctl or by writing a value to /proc/sys/kernel/hung_task_timeout.
+
+          A timeout of 0 disables the check.  The default is two minutes.
+          Keeping the default should be fine in most cases.
+
 config BOOTPARAM_HUNG_TASK_PANIC
         bool "Panic (Reboot) On Hung Tasks"
         depends on DETECT_HUNG_TASK
@@ -337,7 +353,7 @@ config DEBUG_OBJECTS_WORK
 
 config DEBUG_OBJECTS_RCU_HEAD
         bool "Debug RCU callbacks objects"
-        depends on DEBUG_OBJECTS && PREEMPT
+        depends on DEBUG_OBJECTS
         help
           Enable this to turn on debugging of RCU list heads (call_rcu() usage).
 
@@ -398,9 +414,9 @@ config SLUB_STATS
 config DEBUG_KMEMLEAK
         bool "Kernel memory leak detector"
         depends on DEBUG_KERNEL && EXPERIMENTAL && !MEMORY_HOTPLUG && \
-                (X86 || ARM || PPC || S390 || SPARC64 || SUPERH || MICROBLAZE || TILE)
+                (X86 || ARM || PPC || MIPS || S390 || SPARC64 || SUPERH || MICROBLAZE || TILE)
 
-        select DEBUG_FS if SYSFS
+        select DEBUG_FS
         select STACKTRACE if STACKTRACE_SUPPORT
         select KALLSYMS
         select CRC32
@@ -654,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
@@ -875,22 +900,9 @@ config RCU_TORTURE_TEST_RUNNABLE
           Say N here if you want the RCU torture tests to start only
           after being manually enabled via /proc.
 
-config RCU_CPU_STALL_DETECTOR
-        bool "Check for stalled CPUs delaying RCU grace periods"
-        depends on TREE_RCU || TREE_PREEMPT_RCU
-        default y
-        help
-          This option causes RCU to printk information on which
-          CPUs are delaying the current grace period, but only when
-          the grace period extends for excessive time periods.
-
-          Say N if you want to disable such checks.
-
-          Say Y if you are unsure.
-
 config RCU_CPU_STALL_TIMEOUT
         int "RCU CPU stall timeout in seconds"
-        depends on RCU_CPU_STALL_DETECTOR
+        depends on TREE_RCU || TREE_PREEMPT_RCU
         range 3 300
         default 60
         help
@@ -899,22 +911,9 @@ config RCU_CPU_STALL_TIMEOUT
           RCU grace period persists, additional CPU stall warnings are
           printed at more widely spaced intervals.
 
-config RCU_CPU_STALL_DETECTOR_RUNNABLE
-        bool "RCU CPU stall checking starts automatically at boot"
-        depends on RCU_CPU_STALL_DETECTOR
-        default y
-        help
-          If set, start checking for RCU CPU stalls immediately on
-          boot.  Otherwise, RCU CPU stall checking must be manually
-          enabled.
-
-          Say Y if you are unsure.
-
-          Say N if you wish to suppress RCU CPU stall checking during boot.
-
 config RCU_CPU_STALL_VERBOSE
         bool "Print additional per-task information for RCU_CPU_STALL_DETECTOR"
-        depends on RCU_CPU_STALL_DETECTOR && TREE_PREEMPT_RCU
+        depends on TREE_PREEMPT_RCU
         default y
         help
           This option causes RCU to printk detailed per-task information
@@ -993,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 ef0f28571156..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
@@ -21,7 +21,8 @@ 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
+         string_helpers.o gcd.o lcm.o list_sort.o uuid.o flex_array.o \
+         bsearch.o find_last_bit.o
 obj-y += kstrtox.o
 obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
 
@@ -38,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/bsearch.c b/lib/bsearch.c
new file mode 100644
index 000000000000..5b54758e2afb
--- /dev/null
+++ b/lib/bsearch.c
@@ -0,0 +1,53 @@
+/*
+ * A generic implementation of binary search for the Linux kernel
+ *
+ * Copyright (C) 2008-2009 Ksplice, Inc.
+ * Author: Tim Abbott <tabbott@ksplice.com>
+ *
+ * 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; version 2.
+ */
+
+#include <linux/module.h>
+#include <linux/bsearch.h>
+
+/*
+ * bsearch - binary search an array of elements
+ * @key: pointer to item being searched for
+ * @base: pointer to first element to search
+ * @num: number of elements
+ * @size: size of each element
+ * @cmp: pointer to comparison function
+ *
+ * This function does a binary search on the given array.  The
+ * contents of the array should already be in ascending sorted order
+ * under the provided comparison function.
+ *
+ * Note that the key need not have the same type as the elements in
+ * the array, e.g. key could be a string and the comparison function
+ * could compare the string with the struct's name field.  However, if
+ * the key and elements in the array are of the same type, you can use
+ * the same comparison function for both sort() and bsearch().
+ */
+void *bsearch(const void *key, const void *base, size_t num, size_t size,
+              int (*cmp)(const void *key, const void *elt))
+{
+        size_t start = 0, end = num;
+        int result;
+
+        while (start < end) {
+                size_t mid = start + (end - start) / 2;
+
+                result = cmp(key, base + mid * size);
+                if (result < 0)
+                        end = mid;
+                else if (result > 0)
+                        start = mid + 1;
+                else
+                        return (void *)base + mid * size;
+        }
+
+        return NULL;
+}
+EXPORT_SYMBOL(bsearch);
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index 4bfb0471f106..db07bfd9298e 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -649,7 +649,7 @@ out_err:
         return -ENOMEM;
 }
 
-static int device_dma_allocations(struct device *dev)
+static int device_dma_allocations(struct device *dev, struct dma_debug_entry **out_entry)
 {
         struct dma_debug_entry *entry;
         unsigned long flags;
@@ -660,8 +660,10 @@ static int device_dma_allocations(struct device *dev)
         for (i = 0; i < HASH_SIZE; ++i) {
                 spin_lock(&dma_entry_hash[i].lock);
                 list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
-                        if (entry->dev == dev)
+                        if (entry->dev == dev) {
                                 count += 1;
+                                *out_entry = entry;
+                        }
                 }
                 spin_unlock(&dma_entry_hash[i].lock);
         }
@@ -674,6 +676,7 @@ static int device_dma_allocations(struct device *dev)
 static int dma_debug_device_change(struct notifier_block *nb, unsigned long action, void *data)
 {
         struct device *dev = data;
+        struct dma_debug_entry *uninitialized_var(entry);
         int count;
 
         if (global_disable)
@@ -681,12 +684,17 @@ static int dma_debug_device_change(struct notifier_block *nb, unsigned long acti
 
         switch (action) {
         case BUS_NOTIFY_UNBOUND_DRIVER:
-                count = device_dma_allocations(dev);
+                count = device_dma_allocations(dev, &entry);
                 if (count == 0)
                         break;
-                err_printk(dev, NULL, "DMA-API: device driver has pending "
+                err_printk(dev, entry, "DMA-API: device driver has pending "
                                 "DMA allocations while released from device "
-                                "[count=%d]\n", count);
+                                "[count=%d]\n"
+                                "One of leaked entries details: "
+                                "[device address=0x%016llx] [size=%llu bytes] "
+                                "[mapped with %s] [mapped as %s]\n",
+                        count, entry->dev_addr, entry->size,
+                        dir2name[entry->direction], type2name[entry->type]);
                 break;
         default:
                 break;
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/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/string.c b/lib/string.c
index f71bead1be3e..01fad9b203e1 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -535,6 +535,35 @@ bool sysfs_streq(const char *s1, const char *s2)
 }
 EXPORT_SYMBOL(sysfs_streq);
 
+/**
+ * strtobool - convert common user inputs into boolean values
+ * @s: input string
+ * @res: result
+ *
+ * This routine returns 0 iff the first character is one of 'Yy1Nn0'.
+ * Otherwise it will return -EINVAL.  Value pointed to by res is
+ * updated upon finding a match.
+ */
+int strtobool(const char *s, bool *res)
+{
+        switch (s[0]) {
+        case 'y':
+        case 'Y':
+        case '1':
+                *res = true;
+                break;
+        case 'n':
+        case 'N':
+        case '0':
+                *res = false;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strtobool);
+
 #ifndef __HAVE_ARCH_MEMSET
 /**
  * memset - Fill a region of memory with the given value
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index dfd60192bc2e..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':
@@ -1161,8 +1161,7 @@ qualifier:
  * return is greater than or equal to @size, the resulting
  * string is truncated.
  *
- * Call this function if you are already dealing with a va_list.
- * You probably want snprintf() instead.
+ * If you're not already dealing with a va_list consider using snprintf().
  */
 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 {
@@ -1336,8 +1335,7 @@ EXPORT_SYMBOL(vsnprintf);
  * the @buf not including the trailing '\0'. If @size is == 0 the function
  * returns 0.
  *
- * Call this function if you are already dealing with a va_list.
- * You probably want scnprintf() instead.
+ * If you're not already dealing with a va_list consider using scnprintf().
  *
  * See the vsnprintf() documentation for format string extensions over C99.
  */
@@ -1416,8 +1414,7 @@ EXPORT_SYMBOL(scnprintf);
  * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
  * buffer overflows.
  *
- * Call this function if you are already dealing with a va_list.
- * You probably want sprintf() instead.
+ * If you're not already dealing with a va_list consider using sprintf().
  *
  * See the vsnprintf() documentation for format string extensions over C99.
  */