66 files changed, 2348 insertions, 2421 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 4a8aba2e5cc0..bb94c1ba616a 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -16,6 +16,12 @@ config BITREVERSE
 config RATIONAL
         boolean
 
+config GENERIC_STRNCPY_FROM_USER
+        bool
+
+config GENERIC_STRNLEN_USER
+        bool
+
 config GENERIC_FIND_FIRST_BIT
         bool
 
@@ -33,6 +39,9 @@ config GENERIC_IO
         boolean
         default n
 
+config STMP_DEVICE
+        bool
+
 config CRC_CCITT
         tristate "CRC-CCITT functions"
         help
@@ -331,6 +340,9 @@ config NLATTR
 config GENERIC_ATOMIC64
        bool
 
+config ARCH_HAS_ATOMIC64_DEC_IF_POSITIVE
+        def_bool y if GENERIC_ATOMIC64
+
 config LRU_CACHE
         tristate
 
@@ -353,6 +365,14 @@ config CORDIC
           This option provides an implementation of the CORDIC algorithm;
           calculations are in fixed point. Module will be called cordic.
 
+config DDR
+        bool "JEDEC DDR data"
+        help
+          Data from JEDEC specs for DDR SDRAM memories,
+          particularly the AC timing parameters and addressing
+          information. This data is useful for drivers handling
+          DDR SDRAM controllers.
+
 config MPILIB
         tristate
         select CLZ_TAB
@@ -361,14 +381,6 @@ config MPILIB
           It is used to implement RSA digital signature verification,
           which is used by IMA/EVM digital signature extension.
 
-config MPILIB_EXTRA
-        bool
-        depends on MPILIB
-        help
-          Additional sources of multiprecision maths library from GnuPG.
-          This code is unnecessary for RSA digital signature verification,
-          but can be compiled if needed.
-
 config SIGNATURE
         tristate
         depends on KEYS && CRYPTO
@@ -378,4 +390,10 @@ config SIGNATURE
           Digital signature verification. Currently only RSA is supported.
           Implementation is done using GnuPG MPI library
 
+#
+# libfdt files, only selected if needed.
+#
+config LIBFDT
+        bool
+
 endmenu
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 6777153f18f3..2403a63b5da5 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -3,12 +3,16 @@ config PRINTK_TIME
         bool "Show timing information on printks"
         depends on PRINTK
         help
-          Selecting this option causes timing information to be
-          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.  Or add printk.time=1 at boot-time.
-          See Documentation/kernel-parameters.txt
+          Selecting this option causes time stamps of the printk()
+          messages to be added to the output of the syslog() system
+          call and at the console.
+
+          The timestamp is always recorded internally, and exported
+          to /dev/kmsg. This flag just specifies if the timestamp should
+          be included, not that the timestamp is recorded.
+
+          The behavior is also controlled by the kernel command line
+          parameter printk.time=1. See Documentation/kernel-parameters.txt
 
 config DEFAULT_MESSAGE_LOGLEVEL
         int "Default message log level (1-7)"
@@ -70,6 +74,15 @@ config STRIP_ASM_SYMS
           that look like '.Lxxx') so they don't pollute the output of
           get_wchan() and suchlike.
 
+config READABLE_ASM
+        bool "Generate readable assembler code"
+        depends on DEBUG_KERNEL
+        help
+          Disable some compiler optimizations that tend to generate human unreadable
+          assembler output. This may make the kernel slightly slower, but it helps
+          to keep kernel developers who have to stare a lot at assembler listings
+          sane.
+
 config UNUSED_SYMBOLS
         bool "Enable unused/obsolete exported symbols"
         default y if X86
@@ -228,6 +241,26 @@ config BOOTPARAM_SOFTLOCKUP_PANIC_VALUE
         default 0 if !BOOTPARAM_SOFTLOCKUP_PANIC
         default 1 if BOOTPARAM_SOFTLOCKUP_PANIC
 
+config PANIC_ON_OOPS
+        bool "Panic on Oops" if EXPERT
+        default n
+        help
+          Say Y here to enable the kernel to panic when it oopses. This
+          has the same effect as setting oops=panic on the kernel command
+          line.
+
+          This feature is useful to ensure that the kernel does not do
+          anything erroneous after an oops which could result in data
+          corruption or other issues.
+
+          Say N if unsure.
+
+config PANIC_ON_OOPS_VALUE
+        int
+        range 0 1
+        default 0 if !PANIC_ON_OOPS
+        default 1 if PANIC_ON_OOPS
+
 config DETECT_HUNG_TASK
         bool "Detect Hung Tasks"
         depends on DEBUG_KERNEL
@@ -681,7 +714,7 @@ config STACKTRACE
 
 config DEBUG_STACK_USAGE
         bool "Stack utilization instrumentation"
-        depends on DEBUG_KERNEL
+        depends on DEBUG_KERNEL && !IA64 && !PARISC
         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.
@@ -1051,18 +1084,105 @@ config LKDTM
         Documentation on how to use the module can be found in
         Documentation/fault-injection/provoke-crashes.txt
 
+config NOTIFIER_ERROR_INJECTION
+        tristate "Notifier error injection"
+        depends on DEBUG_KERNEL
+        select DEBUG_FS
+        help
+          This option provides the ability to inject artifical errors to
+          specified notifier chain callbacks. It is useful to test the error
+          handling of notifier call chain failures.
+
+          Say N if unsure.
+
 config CPU_NOTIFIER_ERROR_INJECT
         tristate "CPU notifier error injection module"
-        depends on HOTPLUG_CPU && DEBUG_KERNEL
+        depends on HOTPLUG_CPU && NOTIFIER_ERROR_INJECTION
         help
           This option provides a kernel module that can be used to test
-          the error handling of the cpu notifiers
+          the error handling of the cpu notifiers by injecting artifical
+          errors to CPU notifier chain callbacks.  It is controlled through
+          debugfs interface under /sys/kernel/debug/notifier-error-inject/cpu
+
+          If the notifier call chain should be failed with some events
+          notified, write the error code to "actions/<notifier event>/error".
+
+          Example: Inject CPU offline error (-1 == -EPERM)
+
+          # cd /sys/kernel/debug/notifier-error-inject/cpu
+          # echo -1 > actions/CPU_DOWN_PREPARE/error
+          # echo 0 > /sys/devices/system/cpu/cpu1/online
+          bash: echo: write error: Operation not permitted
 
           To compile this code as a module, choose M here: the module will
           be called cpu-notifier-error-inject.
 
           If unsure, say N.
 
+config PM_NOTIFIER_ERROR_INJECT
+        tristate "PM notifier error injection module"
+        depends on PM && NOTIFIER_ERROR_INJECTION
+        default m if PM_DEBUG
+        help
+          This option provides the ability to inject artifical errors to
+          PM notifier chain callbacks.  It is controlled through debugfs
+          interface /sys/kernel/debug/notifier-error-inject/pm
+
+          If the notifier call chain should be failed with some events
+          notified, write the error code to "actions/<notifier event>/error".
+
+          Example: Inject PM suspend error (-12 = -ENOMEM)
+
+          # cd /sys/kernel/debug/notifier-error-inject/pm/
+          # echo -12 > actions/PM_SUSPEND_PREPARE/error
+          # echo mem > /sys/power/state
+          bash: echo: write error: Cannot allocate memory
+
+          To compile this code as a module, choose M here: the module will
+          be called pm-notifier-error-inject.
+
+          If unsure, say N.
+
+config MEMORY_NOTIFIER_ERROR_INJECT
+        tristate "Memory hotplug notifier error injection module"
+        depends on MEMORY_HOTPLUG_SPARSE && NOTIFIER_ERROR_INJECTION
+        help
+          This option provides the ability to inject artifical errors to
+          memory hotplug notifier chain callbacks.  It is controlled through
+          debugfs interface under /sys/kernel/debug/notifier-error-inject/memory
+
+          If the notifier call chain should be failed with some events
+          notified, write the error code to "actions/<notifier event>/error".
+
+          Example: Inject memory hotplug offline error (-12 == -ENOMEM)
+
+          # cd /sys/kernel/debug/notifier-error-inject/memory
+          # echo -12 > actions/MEM_GOING_OFFLINE/error
+          # echo offline > /sys/devices/system/memory/memoryXXX/state
+          bash: echo: write error: Cannot allocate memory
+
+          To compile this code as a module, choose M here: the module will
+          be called pSeries-reconfig-notifier-error-inject.
+
+          If unsure, say N.
+
+config PSERIES_RECONFIG_NOTIFIER_ERROR_INJECT
+        tristate "pSeries reconfig notifier error injection module"
+        depends on PPC_PSERIES && NOTIFIER_ERROR_INJECTION
+        help
+          This option provides the ability to inject artifical errors to
+          pSeries reconfig notifier chain callbacks.  It is controlled
+          through debugfs interface under
+          /sys/kernel/debug/notifier-error-inject/pSeries-reconfig/
+
+          If the notifier call chain should be failed with some events
+          notified, write the error code to "actions/<notifier event>/error".
+
+          To compile this code as a module, choose M here: the module will
+          be called memory-notifier-error-inject.
+
+          If unsure, say N.
+
 config FAULT_INJECTION
         bool "Fault-injection framework"
         depends on DEBUG_KERNEL
@@ -1205,8 +1325,13 @@ config DYNAMIC_DEBUG
           otherwise be available at runtime. These messages can then be
           enabled/disabled based on various levels of scope - per source file,
           function, module, format string, and line number. This mechanism
-          implicitly enables all pr_debug() and dev_dbg() calls. The impact of
-          this compile option is a larger kernel text size of about 2%.
+          implicitly compiles in all pr_debug() and dev_dbg() calls, which
+          enlarges the kernel text size by about 2%.
+
+          If a source file is compiled with DEBUG flag set, any
+          pr_debug() calls in it are enabled by default, but can be
+          disabled at runtime as below.  Note that DEBUG flag is
+          turned on by many CONFIG_*DEBUG* options.
 
           Usage:
 
@@ -1223,16 +1348,16 @@ config DYNAMIC_DEBUG
           lineno : line number of the debug statement
           module : module that contains the debug statement
           function : function that contains the debug statement
-          flags : 'p' means the line is turned 'on' for printing
+          flags : '=p' means the line is turned 'on' for printing
           format : the format used for the debug statement
 
           From a live system:
 
                 nullarbor:~ # cat <debugfs>/dynamic_debug/control
                 # filename:lineno [module]function flags format
-                fs/aio.c:222 [aio]__put_ioctx - "__put_ioctx:\040freeing\040%p\012"
-                fs/aio.c:248 [aio]ioctx_alloc - "ENOMEM:\040nr_events\040too\040high\012"
-                fs/aio.c:1770 [aio]sys_io_cancel - "calling\040cancel\012"
+                fs/aio.c:222 [aio]__put_ioctx =_ "__put_ioctx:\040freeing\040%p\012"
+                fs/aio.c:248 [aio]ioctx_alloc =_ "ENOMEM:\040nr_events\040too\040high\012"
+                fs/aio.c:1770 [aio]sys_io_cancel =_ "calling\040cancel\012"
 
           Example usage:
 
diff --git a/lib/Makefile b/lib/Makefile
index 18515f0267c4..42d283edc4d3 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -11,7 +11,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          rbtree.o radix-tree.o dump_stack.o timerqueue.o\
          idr.o int_sqrt.o extable.o prio_tree.o \
          sha1.o md5.o irq_regs.o reciprocal_div.o argv_split.o \
-         proportions.o prio_heap.o ratelimit.o show_mem.o \
+         proportions.o flex_proportions.o prio_heap.o ratelimit.o show_mem.o \
          is_single_threaded.o plist.o decompress.o
 
 lib-$(CONFIG_MMU) += ioremap.o
@@ -22,7 +22,7 @@ lib-y	+= kobject.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 find_last_bit.o find_next_bit.o llist.o
+         bsearch.o find_last_bit.o find_next_bit.o llist.o memweight.o
 obj-y += kstrtox.o
 obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
 
@@ -90,7 +90,12 @@ obj-$(CONFIG_AUDIT_GENERIC) += audit.o
 obj-$(CONFIG_SWIOTLB) += swiotlb.o
 obj-$(CONFIG_IOMMU_HELPER) += iommu-helper.o
 obj-$(CONFIG_FAULT_INJECTION) += fault-inject.o
+obj-$(CONFIG_NOTIFIER_ERROR_INJECTION) += notifier-error-inject.o
 obj-$(CONFIG_CPU_NOTIFIER_ERROR_INJECT) += cpu-notifier-error-inject.o
+obj-$(CONFIG_PM_NOTIFIER_ERROR_INJECT) += pm-notifier-error-inject.o
+obj-$(CONFIG_MEMORY_NOTIFIER_ERROR_INJECT) += memory-notifier-error-inject.o
+obj-$(CONFIG_PSERIES_RECONFIG_NOTIFIER_ERROR_INJECT) += \
+        pSeries-reconfig-notifier-error-inject.o
 
 lib-$(CONFIG_GENERIC_BUG) += bug.o
 
@@ -123,6 +128,18 @@ obj-$(CONFIG_SIGNATURE) += digsig.o
 
 obj-$(CONFIG_CLZ_TAB) += clz_tab.o
 
+obj-$(CONFIG_DDR) += jedec_ddr_data.o
+
+obj-$(CONFIG_GENERIC_STRNCPY_FROM_USER) += strncpy_from_user.o
+obj-$(CONFIG_GENERIC_STRNLEN_USER) += strnlen_user.o
+
+obj-$(CONFIG_STMP_DEVICE) += stmp_device.o
+
+libfdt_files = fdt.o fdt_ro.o fdt_wip.o fdt_rw.o fdt_sw.o fdt_strerror.o
+$(foreach file, $(libfdt_files), \
+        $(eval CFLAGS_$(file) = -I$(src)/../scripts/dtc/libfdt))
+lib-$(CONFIG_LIBFDT) += $(libfdt_files)
+
 hostprogs-y     := gen_crc32table
 clean-files     := crc32table.h
 
diff --git a/lib/atomic64_test.c b/lib/atomic64_test.c
index cb99b91c3a1d..00bca223d1e1 100644
--- a/lib/atomic64_test.c
+++ b/lib/atomic64_test.c
@@ -114,8 +114,7 @@ static __init int test_atomic64(void)
         r += one;
         BUG_ON(v.counter != r);
 
-#if defined(CONFIG_X86) || defined(CONFIG_MIPS) || defined(CONFIG_PPC) || \
-    defined(CONFIG_S390) || defined(_ASM_GENERIC_ATOMIC64_H) || defined(CONFIG_ARM)
+#ifdef CONFIG_ARCH_HAS_ATOMIC64_DEC_IF_POSITIVE
         INIT(onestwos);
         BUG_ON(atomic64_dec_if_positive(&v) != (onestwos - 1));
         r -= one;
@@ -129,7 +128,7 @@ static __init int test_atomic64(void)
         BUG_ON(atomic64_dec_if_positive(&v) != (-one - one));
         BUG_ON(v.counter != r);
 #else
-#warning Please implement atomic64_dec_if_positive for your architecture, and add it to the IF above
+#warning Please implement atomic64_dec_if_positive for your architecture and select the above Kconfig symbol
 #endif
 
         INIT(onestwos);
diff --git a/lib/bitmap.c b/lib/bitmap.c
index b5a8b6ad2454..06fdfa1aeba7 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -369,7 +369,8 @@ EXPORT_SYMBOL(bitmap_find_next_zero_area);
  * @nmaskbits: size of bitmap, in bits
  *
  * Exactly @nmaskbits bits are displayed.  Hex digits are grouped into
- * comma-separated sets of eight digits per set.
+ * comma-separated sets of eight digits per set.  Returns the number of
+ * characters which were written to *buf, excluding the trailing \0.
  */
 int bitmap_scnprintf(char *buf, unsigned int buflen,
         const unsigned long *maskp, int nmaskbits)
@@ -517,8 +518,8 @@ EXPORT_SYMBOL(bitmap_parse_user);
  *
  * Helper routine for bitmap_scnlistprintf().  Write decimal number
  * or range to buf, suppressing output past buf+buflen, with optional
- * comma-prefix.  Return len of what would be written to buf, if it
- * all fit.
+ * comma-prefix.  Return len of what was written to *buf, excluding the
+ * trailing \0.
  */
 static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len)
 {
@@ -544,9 +545,8 @@ static inline int bscnl_emit(char *buf, int buflen, int rbot, int rtop, int len)
  * the range.  Output format is compatible with the format
  * accepted as input by bitmap_parselist().
  *
- * The return value is the number of characters which would be
- * generated for the given input, excluding the trailing '\0', as
- * per ISO C99.
+ * The return value is the number of characters which were written to *buf
+ * excluding the trailing '\0', as per ISO C99's scnprintf.
  */
 int bitmap_scnlistprintf(char *buf, unsigned int buflen,
         const unsigned long *maskp, int nmaskbits)
diff --git a/lib/btree.c b/lib/btree.c
index e5ec1e9c1aa5..f9a484676cb6 100644
--- a/lib/btree.c
+++ b/lib/btree.c
@@ -319,8 +319,8 @@ void *btree_get_prev(struct btree_head *head, struct btree_geo *geo,
 
         if (head->height == 0)
                 return NULL;
-retry:
         longcpy(key, __key, geo->keylen);
+retry:
         dec_key(geo, key);
 
         node = head->node;
@@ -351,7 +351,7 @@ retry:
         }
 miss:
         if (retry_key) {
-                __key = retry_key;
+                longcpy(key, retry_key, geo->keylen);
                 retry_key = NULL;
                 goto retry;
         }
@@ -509,6 +509,7 @@ retry:
 int btree_insert(struct btree_head *head, struct btree_geo *geo,
                 unsigned long *key, void *val, gfp_t gfp)
 {
+        BUG_ON(!val);
         return btree_insert_level(head, geo, key, val, 1, gfp);
 }
 EXPORT_SYMBOL_GPL(btree_insert);
diff --git a/lib/cpu-notifier-error-inject.c b/lib/cpu-notifier-error-inject.c
index 4dc20321b0d5..707ca24f7b18 100644
--- a/lib/cpu-notifier-error-inject.c
+++ b/lib/cpu-notifier-error-inject.c
@@ -1,58 +1,45 @@
 #include <linux/kernel.h>
-#include <linux/cpu.h>
 #include <linux/module.h>
-#include <linux/notifier.h>
+#include <linux/cpu.h>
 
-static int priority;
-static int cpu_up_prepare_error;
-static int cpu_down_prepare_error;
+#include "notifier-error-inject.h"
 
+static int priority;
 module_param(priority, int, 0);
 MODULE_PARM_DESC(priority, "specify cpu notifier priority");
 
-module_param(cpu_up_prepare_error, int, 0644);
-MODULE_PARM_DESC(cpu_up_prepare_error,
-                "specify error code to inject CPU_UP_PREPARE action");
-
-module_param(cpu_down_prepare_error, int, 0644);
-MODULE_PARM_DESC(cpu_down_prepare_error,
-                "specify error code to inject CPU_DOWN_PREPARE action");
-
-static int err_inject_cpu_callback(struct notifier_block *nfb,
-                                unsigned long action, void *hcpu)
-{
-        int err = 0;
-
-        switch (action) {
-        case CPU_UP_PREPARE:
-        case CPU_UP_PREPARE_FROZEN:
-                err = cpu_up_prepare_error;
-                break;
-        case CPU_DOWN_PREPARE:
-        case CPU_DOWN_PREPARE_FROZEN:
-                err = cpu_down_prepare_error;
-                break;
+static struct notifier_err_inject cpu_notifier_err_inject = {
+        .actions = {
+                { NOTIFIER_ERR_INJECT_ACTION(CPU_UP_PREPARE) },
+                { NOTIFIER_ERR_INJECT_ACTION(CPU_UP_PREPARE_FROZEN) },
+                { NOTIFIER_ERR_INJECT_ACTION(CPU_DOWN_PREPARE) },
+                { NOTIFIER_ERR_INJECT_ACTION(CPU_DOWN_PREPARE_FROZEN) },
+                {}
         }
-        if (err)
-                printk(KERN_INFO "Injecting error (%d) at cpu notifier\n", err);
-
-        return notifier_from_errno(err);
-}
-
-static struct notifier_block err_inject_cpu_notifier = {
-        .notifier_call = err_inject_cpu_callback,
 };
 
+static struct dentry *dir;
+
 static int err_inject_init(void)
 {
-        err_inject_cpu_notifier.priority = priority;
+        int err;
+
+        dir = notifier_err_inject_init("cpu", notifier_err_inject_dir,
+                                        &cpu_notifier_err_inject, priority);
+        if (IS_ERR(dir))
+                return PTR_ERR(dir);
+
+        err = register_hotcpu_notifier(&cpu_notifier_err_inject.nb);
+        if (err)
+                debugfs_remove_recursive(dir);
 
-        return register_hotcpu_notifier(&err_inject_cpu_notifier);
+        return err;
 }
 
 static void err_inject_exit(void)
 {
-        unregister_hotcpu_notifier(&err_inject_cpu_notifier);
+        unregister_hotcpu_notifier(&cpu_notifier_err_inject.nb);
+        debugfs_remove_recursive(dir);
 }
 
 module_init(err_inject_init);
diff --git a/lib/crc32.c b/lib/crc32.c
index b0d278fb1d91..61774b8db4de 100644
--- a/lib/crc32.c
+++ b/lib/crc32.c
@@ -74,7 +74,9 @@ crc32_body(u32 crc, unsigned char const *buf, size_t len, const u32 (*tab)[256])
         size_t i;
 # endif
         const u32 *t0=tab[0], *t1=tab[1], *t2=tab[2], *t3=tab[3];
+# if CRC_LE_BITS != 32
         const u32 *t4 = tab[4], *t5 = tab[5], *t6 = tab[6], *t7 = tab[7];
+# endif
         u32 q;
 
         /* Align it */
diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index 0ab9ae8057f0..d11808ca4bc4 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -79,30 +79,29 @@ static const char *obj_states[ODEBUG_STATE_MAX] = {
         [ODEBUG_STATE_NOTAVAILABLE]     = "not available",
 };
 
-static int fill_pool(void)
+static void fill_pool(void)
 {
         gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
         struct debug_obj *new;
         unsigned long flags;
 
         if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
-                return obj_pool_free;
+                return;
 
         if (unlikely(!obj_cache))
-                return obj_pool_free;
+                return;
 
         while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
 
                 new = kmem_cache_zalloc(obj_cache, gfp);
                 if (!new)
-                        return obj_pool_free;
+                        return;
 
                 raw_spin_lock_irqsave(&pool_lock, flags);
                 hlist_add_head(&new->node, &obj_pool);
                 obj_pool_free++;
                 raw_spin_unlock_irqrestore(&pool_lock, flags);
         }
-        return obj_pool_free;
 }
 
 /*
@@ -1052,10 +1051,10 @@ static int __init debug_objects_replace_static_objects(void)
                         cnt++;
                 }
         }
+        local_irq_enable();
 
         printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt,
                obj_pool_used);
-        local_irq_enable();
         return 0;
 free:
         hlist_for_each_entry_safe(obj, node, tmp, &objects, node) {
diff --git a/lib/div64.c b/lib/div64.c
index 3ea24907d52e..a163b6caef73 100644
--- a/lib/div64.c
+++ b/lib/div64.c
@@ -87,7 +87,7 @@ EXPORT_SYMBOL(div_s64_rem);
  * by the book 'Hacker's Delight'.  The original source and full proof
  * can be found here and is available for use without restriction.
  *
- * 'http://www.hackersdelight.org/HDcode/newCode/divDouble.c'
+ * 'http://www.hackersdelight.org/HDcode/newCode/divDouble.c.txt'
  */
 #ifndef div64_u64
 u64 div64_u64(u64 dividend, u64 divisor)
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index 13ef2338be41..66ce41489133 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -78,7 +78,7 @@ static LIST_HEAD(free_entries);
 static DEFINE_SPINLOCK(free_entries_lock);
 
 /* Global disable flag - will be set in case of an error */
-static bool global_disable __read_mostly;
+static u32 global_disable __read_mostly;
 
 /* Global error count */
 static u32 error_count;
@@ -430,7 +430,7 @@ static struct dma_debug_entry *__dma_entry_alloc(void)
  */
 static struct dma_debug_entry *dma_entry_alloc(void)
 {
-        struct dma_debug_entry *entry = NULL;
+        struct dma_debug_entry *entry;
         unsigned long flags;
 
         spin_lock_irqsave(&free_entries_lock, flags);
@@ -438,11 +438,14 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         if (list_empty(&free_entries)) {
                 pr_err("DMA-API: debugging out of memory - disabling\n");
                 global_disable = true;
-                goto out;
+                spin_unlock_irqrestore(&free_entries_lock, flags);
+                return NULL;
         }
 
         entry = __dma_entry_alloc();
 
+        spin_unlock_irqrestore(&free_entries_lock, flags);
+
 #ifdef CONFIG_STACKTRACE
         entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;
         entry->stacktrace.entries = entry->st_entries;
@@ -450,9 +453,6 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         save_stack_trace(&entry->stacktrace);
 #endif
 
-out:
-        spin_unlock_irqrestore(&free_entries_lock, flags);
-
         return entry;
 }
 
@@ -657,7 +657,7 @@ static int dma_debug_fs_init(void)
 
         global_disable_dent = debugfs_create_bool("disabled", 0444,
                         dma_debug_dent,
-                        (u32 *)&global_disable);
+                        &global_disable);
         if (!global_disable_dent)
                 goto out_err;
 
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index 310c753cf83e..7ca29a0a3019 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -107,20 +107,22 @@ static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
         return buf;
 }
 
-#define vpr_info_dq(q, msg)                                             \
-do {                                                                    \
-        if (verbose)                                                    \
-                /* trim last char off format print */                   \
-                pr_info("%s: func=\"%s\" file=\"%s\" "                  \
-                        "module=\"%s\" format=\"%.*s\" "                \
-                        "lineno=%u-%u",                                 \
-                        msg,                                            \
-                        q->function ? q->function : "",                 \
-                        q->filename ? q->filename : "",                 \
-                        q->module ? q->module : "",                     \
-                        (int)(q->format ? strlen(q->format) - 1 : 0),   \
-                        q->format ? q->format : "",                     \
-                        q->first_lineno, q->last_lineno);               \
+#define vpr_info(fmt, ...) \
+        if (verbose) do { pr_info(fmt, ##__VA_ARGS__); } while (0)
+
+#define vpr_info_dq(q, msg)                                     \
+do {                                                            \
+        /* trim last char off format print */                   \
+        vpr_info("%s: func=\"%s\" file=\"%s\" "                 \
+                "module=\"%s\" format=\"%.*s\" "                \
+                "lineno=%u-%u",                                 \
+                msg,                                            \
+                q->function ? q->function : "",                 \
+                q->filename ? q->filename : "",                 \
+                q->module ? q->module : "",                     \
+                (int)(q->format ? strlen(q->format) - 1 : 0),   \
+                q->format ? q->format : "",                     \
+                q->first_lineno, q->last_lineno);               \
 } while (0)
 
 /*
@@ -180,12 +182,11 @@ static int ddebug_change(const struct ddebug_query *query,
                         if (newflags == dp->flags)
                                 continue;
                         dp->flags = newflags;
-                        if (verbose)
-                                pr_info("changed %s:%d [%s]%s =%s\n",
-                                        trim_prefix(dp->filename), dp->lineno,
-                                        dt->mod_name, dp->function,
-                                        ddebug_describe_flags(dp, flagbuf,
-                                                        sizeof(flagbuf)));
+                        vpr_info("changed %s:%d [%s]%s =%s\n",
+                                trim_prefix(dp->filename), dp->lineno,
+                                dt->mod_name, dp->function,
+                                ddebug_describe_flags(dp, flagbuf,
+                                                sizeof(flagbuf)));
                 }
         }
         mutex_unlock(&ddebug_lock);
@@ -337,7 +338,7 @@ static int check_set(const char **dest, char *src, char *name)
  * Returns 0 on success, <0 on error.
  */
 static int ddebug_parse_query(char *words[], int nwords,
-                               struct ddebug_query *query)
+                        struct ddebug_query *query, const char *modname)
 {
         unsigned int i;
         int rc;
@@ -347,6 +348,10 @@ static int ddebug_parse_query(char *words[], int nwords,
                 return -EINVAL;
         memset(query, 0, sizeof(*query));
 
+        if (modname)
+                /* support $modname.dyndbg=<multiple queries> */
+                query->module = modname;
+
         for (i = 0 ; i < nwords ; i += 2) {
                 if (!strcmp(words[i], "func"))
                         rc = check_set(&query->function, words[i+1], "func");
@@ -410,8 +415,7 @@ static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
         default:
                 return -EINVAL;
         }
-        if (verbose)
-                pr_info("op='%c'\n", op);
+        vpr_info("op='%c'\n", op);
 
         for ( ; *str ; ++str) {
                 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
@@ -423,8 +427,7 @@ static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
                 if (i < 0)
                         return -EINVAL;
         }
-        if (verbose)
-                pr_info("flags=0x%x\n", flags);
+        vpr_info("flags=0x%x\n", flags);
 
         /* calculate final *flagsp, *maskp according to mask and op */
         switch (op) {
@@ -441,12 +444,11 @@ static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
                 *flagsp = 0;
                 break;
         }
-        if (verbose)
-                pr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
+        vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
         return 0;
 }
 
-static int ddebug_exec_query(char *query_string)
+static int ddebug_exec_query(char *query_string, const char *modname)
 {
         unsigned int flags = 0, mask = 0;
         struct ddebug_query query;
@@ -457,7 +459,7 @@ static int ddebug_exec_query(char *query_string)
         nwords = ddebug_tokenize(query_string, words, MAXWORDS);
         if (nwords <= 0)
                 return -EINVAL;
-        if (ddebug_parse_query(words, nwords-1, &query))
+        if (ddebug_parse_query(words, nwords-1, &query, modname))
                 return -EINVAL;
         if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
                 return -EINVAL;
@@ -473,7 +475,7 @@ static int ddebug_exec_query(char *query_string)
    last error or number of matching callsites.  Module name is either
    in param (for boot arg) or perhaps in query string.
 */
-static int ddebug_exec_queries(char *query)
+static int ddebug_exec_queries(char *query, const char *modname)
 {
         char *split;
         int i, errs = 0, exitcode = 0, rc, nfound = 0;
@@ -487,10 +489,9 @@ static int ddebug_exec_queries(char *query)
                 if (!query || !*query || *query == '#')
                         continue;
 
-                if (verbose)
-                        pr_info("query %d: \"%s\"\n", i, query);
+                vpr_info("query %d: \"%s\"\n", i, query);
 
-                rc = ddebug_exec_query(query);
+                rc = ddebug_exec_query(query, modname);
                 if (rc < 0) {
                         errs++;
                         exitcode = rc;
@@ -498,7 +499,7 @@ static int ddebug_exec_queries(char *query)
                         nfound += rc;
                 i++;
         }
-        pr_info("processed %d queries, with %d matches, %d errs\n",
+        vpr_info("processed %d queries, with %d matches, %d errs\n",
                  i, nfound, errs);
 
         if (exitcode)
@@ -653,10 +654,9 @@ static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
                 return -EFAULT;
         }
         tmpbuf[len] = '\0';
-        if (verbose)
-                pr_info("read %d bytes from userspace\n", (int)len);
+        vpr_info("read %d bytes from userspace\n", (int)len);
 
-        ret = ddebug_exec_queries(tmpbuf);
+        ret = ddebug_exec_queries(tmpbuf, NULL);
         kfree(tmpbuf);
         if (ret < 0)
                 return ret;
@@ -717,8 +717,7 @@ static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
         struct _ddebug *dp;
         int n = *pos;
 
-        if (verbose)
-                pr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
+        vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
 
         mutex_lock(&ddebug_lock);
 
@@ -742,9 +741,8 @@ static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
         struct ddebug_iter *iter = m->private;
         struct _ddebug *dp;
 
-        if (verbose)
-                pr_info("called m=%p p=%p *pos=%lld\n",
-                        m, p, (unsigned long long)*pos);
+        vpr_info("called m=%p p=%p *pos=%lld\n",
+                m, p, (unsigned long long)*pos);
 
         if (p == SEQ_START_TOKEN)
                 dp = ddebug_iter_first(iter);
@@ -766,8 +764,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)
         struct _ddebug *dp = p;
         char flagsbuf[10];
 
-        if (verbose)
-                pr_info("called m=%p p=%p\n", m, p);
+        vpr_info("called m=%p p=%p\n", m, p);
 
         if (p == SEQ_START_TOKEN) {
                 seq_puts(m,
@@ -791,8 +788,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)
  */
 static void ddebug_proc_stop(struct seq_file *m, void *p)
 {
-        if (verbose)
-                pr_info("called m=%p p=%p\n", m, p);
+        vpr_info("called m=%p p=%p\n", m, p);
         mutex_unlock(&ddebug_lock);
 }
 
@@ -815,8 +811,7 @@ static int ddebug_proc_open(struct inode *inode, struct file *file)
         struct ddebug_iter *iter;
         int err;
 
-        if (verbose)
-                pr_info("called\n");
+        vpr_info("called\n");
 
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
         if (iter == NULL)
@@ -866,12 +861,51 @@ int ddebug_add_module(struct _ddebug *tab, unsigned int n,
         list_add_tail(&dt->link, &ddebug_tables);
         mutex_unlock(&ddebug_lock);
 
-        if (verbose)
-                pr_info("%u debug prints in module %s\n", n, dt->mod_name);
+        vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
         return 0;
 }
 EXPORT_SYMBOL_GPL(ddebug_add_module);
 
+/* helper for ddebug_dyndbg_(boot|module)_param_cb */
+static int ddebug_dyndbg_param_cb(char *param, char *val,
+                                const char *modname, int on_err)
+{
+        char *sep;
+
+        sep = strchr(param, '.');
+        if (sep) {
+                /* needed only for ddebug_dyndbg_boot_param_cb */
+                *sep = '\0';
+                modname = param;
+                param = sep + 1;
+        }
+        if (strcmp(param, "dyndbg"))
+                return on_err; /* determined by caller */
+
+        ddebug_exec_queries((val ? val : "+p"), modname);
+
+        return 0; /* query failure shouldnt stop module load */
+}
+
+/* handle both dyndbg and $module.dyndbg params at boot */
+static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
+                                const char *unused)
+{
+        vpr_info("%s=\"%s\"\n", param, val);
+        return ddebug_dyndbg_param_cb(param, val, NULL, 0);
+}
+
+/*
+ * modprobe foo finds foo.params in boot-args, strips "foo.", and
+ * passes them to load_module().  This callback gets unknown params,
+ * processes dyndbg params, rejects others.
+ */
+int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
+{
+        vpr_info("module: %s %s=\"%s\"\n", module, param, val);
+        return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
+}
+
 static void ddebug_table_free(struct ddebug_table *dt)
 {
         list_del_init(&dt->link);
@@ -888,8 +922,7 @@ int ddebug_remove_module(const char *mod_name)
         struct ddebug_table *dt, *nextdt;
         int ret = -ENOENT;
 
-        if (verbose)
-                pr_info("removing module \"%s\"\n", mod_name);
+        vpr_info("removing module \"%s\"\n", mod_name);
 
         mutex_lock(&ddebug_lock);
         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
@@ -940,8 +973,10 @@ static int __init dynamic_debug_init(void)
 {
         struct _ddebug *iter, *iter_start;
         const char *modname = NULL;
+        char *cmdline;
         int ret = 0;
-        int n = 0;
+        int n = 0, entries = 0, modct = 0;
+        int verbose_bytes = 0;
 
         if (__start___verbose == __stop___verbose) {
                 pr_warn("_ddebug table is empty in a "
@@ -952,10 +987,15 @@ static int __init dynamic_debug_init(void)
         modname = iter->modname;
         iter_start = iter;
         for (; iter < __stop___verbose; iter++) {
+                entries++;
+                verbose_bytes += strlen(iter->modname) + strlen(iter->function)
+                        + strlen(iter->filename) + strlen(iter->format);
+
                 if (strcmp(modname, iter->modname)) {
+                        modct++;
                         ret = ddebug_add_module(iter_start, n, modname);
                         if (ret)
-                                goto out_free;
+                                goto out_err;
                         n = 0;
                         modname = iter->modname;
                         iter_start = iter;
@@ -964,29 +1004,45 @@ static int __init dynamic_debug_init(void)
         }
         ret = ddebug_add_module(iter_start, n, modname);
         if (ret)
-                goto out_free;
+                goto out_err;
+
+        ddebug_init_success = 1;
+        vpr_info("%d modules, %d entries and %d bytes in ddebug tables,"
+                " %d bytes in (readonly) verbose section\n",
+                modct, entries, (int)( modct * sizeof(struct ddebug_table)),
+                verbose_bytes + (int)(__stop___verbose - __start___verbose));
 
-        /* ddebug_query boot param got passed -> set it up */
+        /* apply ddebug_query boot param, dont unload tables on err */
         if (ddebug_setup_string[0] != '\0') {
-                ret = ddebug_exec_queries(ddebug_setup_string);
+                pr_warn("ddebug_query param name is deprecated,"
+                        " change it to dyndbg\n");
+                ret = ddebug_exec_queries(ddebug_setup_string, NULL);
                 if (ret < 0)
                         pr_warn("Invalid ddebug boot param %s",
                                 ddebug_setup_string);
                 else
                         pr_info("%d changes by ddebug_query\n", ret);
-
-                /* keep tables even on ddebug_query parse error */
-                ret = 0;
         }
+        /* now that ddebug tables are loaded, process all boot args
+         * again to find and activate queries given in dyndbg params.
+         * While this has already been done for known boot params, it
+         * ignored the unknown ones (dyndbg in particular).  Reusing
+         * parse_args avoids ad-hoc parsing.  This will also attempt
+         * to activate queries for not-yet-loaded modules, which is
+         * slightly noisy if verbose, but harmless.
+         */
+        cmdline = kstrdup(saved_command_line, GFP_KERNEL);
+        parse_args("dyndbg params", cmdline, NULL,
+                   0, 0, 0, &ddebug_dyndbg_boot_param_cb);
+        kfree(cmdline);
+        return 0;
 
-out_free:
-        if (ret)
-                ddebug_remove_all_tables();
-        else
-                ddebug_init_success = 1;
+out_err:
+        ddebug_remove_all_tables();
         return 0;
 }
 /* Allow early initialization for boot messages via boot param */
-arch_initcall(dynamic_debug_init);
+early_initcall(dynamic_debug_init);
+
 /* Debugfs setup must be done later */
-module_init(dynamic_debug_init_debugfs);
+fs_initcall(dynamic_debug_init_debugfs);
diff --git a/lib/dynamic_queue_limits.c b/lib/dynamic_queue_limits.c
index 6ab4587d052b..0777c5a45fa0 100644
--- a/lib/dynamic_queue_limits.c
+++ b/lib/dynamic_queue_limits.c
@@ -10,23 +10,27 @@
 #include <linux/jiffies.h>
 #include <linux/dynamic_queue_limits.h>
 
-#define POSDIFF(A, B) ((A) > (B) ? (A) - (B) : 0)
+#define POSDIFF(A, B) ((int)((A) - (B)) > 0 ? (A) - (B) : 0)
+#define AFTER_EQ(A, B) ((int)((A) - (B)) >= 0)
 
 /* Records completed count and recalculates the queue limit */
 void dql_completed(struct dql *dql, unsigned int count)
 {
         unsigned int inprogress, prev_inprogress, limit;
-        unsigned int ovlimit, all_prev_completed, completed;
+        unsigned int ovlimit, completed, num_queued;
+        bool all_prev_completed;
+
+        num_queued = ACCESS_ONCE(dql->num_queued);
 
         /* Can't complete more than what's in queue */
-        BUG_ON(count > dql->num_queued - dql->num_completed);
+        BUG_ON(count > num_queued - dql->num_completed);
 
         completed = dql->num_completed + count;
         limit = dql->limit;
-        ovlimit = POSDIFF(dql->num_queued - dql->num_completed, limit);
-        inprogress = dql->num_queued - completed;
+        ovlimit = POSDIFF(num_queued - dql->num_completed, limit);
+        inprogress = num_queued - completed;
         prev_inprogress = dql->prev_num_queued - dql->num_completed;
-        all_prev_completed = POSDIFF(completed, dql->prev_num_queued);
+        all_prev_completed = AFTER_EQ(completed, dql->prev_num_queued);
 
         if ((ovlimit && !inprogress) ||
             (dql->prev_ovlimit && all_prev_completed)) {
@@ -104,7 +108,7 @@ void dql_completed(struct dql *dql, unsigned int count)
         dql->prev_ovlimit = ovlimit;
         dql->prev_last_obj_cnt = dql->last_obj_cnt;
         dql->num_completed = completed;
-        dql->prev_num_queued = dql->num_queued;
+        dql->prev_num_queued = num_queued;
 }
 EXPORT_SYMBOL(dql_completed);
 
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index 6805453c18e7..f7210ad6cffd 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -101,6 +101,10 @@ static inline bool fail_stacktrace(struct fault_attr *attr)
 
 bool should_fail(struct fault_attr *attr, ssize_t size)
 {
+        /* No need to check any other properties if the probability is 0 */
+        if (attr->probability == 0)
+                return false;
+
         if (attr->task_filter && !fail_task(attr, current))
                 return false;
 
diff --git a/lib/fdt.c b/lib/fdt.c
new file mode 100644
index 000000000000..97f20069fc37
--- /dev/null
+++ b/lib/fdt.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt.c"
diff --git a/lib/fdt_ro.c b/lib/fdt_ro.c
new file mode 100644
index 000000000000..f73c04ea7be4
--- /dev/null
+++ b/lib/fdt_ro.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt_ro.c"
diff --git a/lib/fdt_rw.c b/lib/fdt_rw.c
new file mode 100644
index 000000000000..0c1f0f4a4b13
--- /dev/null
+++ b/lib/fdt_rw.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt_rw.c"
diff --git a/lib/fdt_strerror.c b/lib/fdt_strerror.c
new file mode 100644
index 000000000000..8713e3ff4707
--- /dev/null
+++ b/lib/fdt_strerror.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt_strerror.c"
diff --git a/lib/fdt_sw.c b/lib/fdt_sw.c
new file mode 100644
index 000000000000..9ac7e50c76ce
--- /dev/null
+++ b/lib/fdt_sw.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt_sw.c"
diff --git a/lib/fdt_wip.c b/lib/fdt_wip.c
new file mode 100644
index 000000000000..45b3fc3d3ba1
--- /dev/null
+++ b/lib/fdt_wip.c
@@ -0,0 +1,2 @@
+#include <linux/libfdt_env.h>
+#include "../scripts/dtc/libfdt/fdt_wip.c"
diff --git a/lib/flex_proportions.c b/lib/flex_proportions.c
new file mode 100644
index 000000000000..c785554f9523
--- /dev/null
+++ b/lib/flex_proportions.c
@@ -0,0 +1,272 @@
+/*
+ *  Floating proportions with flexible aging period
+ *
+ *   Copyright (C) 2011, SUSE, Jan Kara <jack@suse.cz>
+ *
+ * The goal of this code is: Given different types of event, measure proportion
+ * of each type of event over time. The proportions are measured with
+ * exponentially decaying history to give smooth transitions. A formula
+ * expressing proportion of event of type 'j' is:
+ *
+ *   p_{j} = (\Sum_{i>=0} x_{i,j}/2^{i+1})/(\Sum_{i>=0} x_i/2^{i+1})
+ *
+ * Where x_{i,j} is j's number of events in i-th last time period and x_i is
+ * total number of events in i-th last time period.
+ *
+ * Note that p_{j}'s are normalised, i.e.
+ *
+ *   \Sum_{j} p_{j} = 1,
+ *
+ * This formula can be straightforwardly computed by maintaing denominator
+ * (let's call it 'd') and for each event type its numerator (let's call it
+ * 'n_j'). When an event of type 'j' happens, we simply need to do:
+ *   n_j++; d++;
+ *
+ * When a new period is declared, we could do:
+ *   d /= 2
+ *   for each j
+ *     n_j /= 2
+ *
+ * To avoid iteration over all event types, we instead shift numerator of event
+ * j lazily when someone asks for a proportion of event j or when event j
+ * occurs. This can bit trivially implemented by remembering last period in
+ * which something happened with proportion of type j.
+ */
+#include <linux/flex_proportions.h>
+
+int fprop_global_init(struct fprop_global *p)
+{
+        int err;
+
+        p->period = 0;
+        /* Use 1 to avoid dealing with periods with 0 events... */
+        err = percpu_counter_init(&p->events, 1);
+        if (err)
+                return err;
+        seqcount_init(&p->sequence);
+        return 0;
+}
+
+void fprop_global_destroy(struct fprop_global *p)
+{
+        percpu_counter_destroy(&p->events);
+}
+
+/*
+ * Declare @periods new periods. It is upto the caller to make sure period
+ * transitions cannot happen in parallel.
+ *
+ * The function returns true if the proportions are still defined and false
+ * if aging zeroed out all events. This can be used to detect whether declaring
+ * further periods has any effect.
+ */
+bool fprop_new_period(struct fprop_global *p, int periods)
+{
+        u64 events;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        events = percpu_counter_sum(&p->events);
+        /*
+         * Don't do anything if there are no events.
+         */
+        if (events <= 1) {
+                local_irq_restore(flags);
+                return false;
+        }
+        write_seqcount_begin(&p->sequence);
+        if (periods < 64)
+                events -= events >> periods;
+        /* Use addition to avoid losing events happening between sum and set */
+        percpu_counter_add(&p->events, -events);
+        p->period += periods;
+        write_seqcount_end(&p->sequence);
+        local_irq_restore(flags);
+
+        return true;
+}
+
+/*
+ * ---- SINGLE ----
+ */
+
+int fprop_local_init_single(struct fprop_local_single *pl)
+{
+        pl->events = 0;
+        pl->period = 0;
+        raw_spin_lock_init(&pl->lock);
+        return 0;
+}
+
+void fprop_local_destroy_single(struct fprop_local_single *pl)
+{
+}
+
+static void fprop_reflect_period_single(struct fprop_global *p,
+                                        struct fprop_local_single *pl)
+{
+        unsigned int period = p->period;
+        unsigned long flags;
+
+        /* Fast path - period didn't change */
+        if (pl->period == period)
+                return;
+        raw_spin_lock_irqsave(&pl->lock, flags);
+        /* Someone updated pl->period while we were spinning? */
+        if (pl->period >= period) {
+                raw_spin_unlock_irqrestore(&pl->lock, flags);
+                return;
+        }
+        /* Aging zeroed our fraction? */
+        if (period - pl->period < BITS_PER_LONG)
+                pl->events >>= period - pl->period;
+        else
+                pl->events = 0;
+        pl->period = period;
+        raw_spin_unlock_irqrestore(&pl->lock, flags);
+}
+
+/* Event of type pl happened */
+void __fprop_inc_single(struct fprop_global *p, struct fprop_local_single *pl)
+{
+        fprop_reflect_period_single(p, pl);
+        pl->events++;
+        percpu_counter_add(&p->events, 1);
+}
+
+/* Return fraction of events of type pl */
+void fprop_fraction_single(struct fprop_global *p,
+                           struct fprop_local_single *pl,
+                           unsigned long *numerator, unsigned long *denominator)
+{
+        unsigned int seq;
+        s64 num, den;
+
+        do {
+                seq = read_seqcount_begin(&p->sequence);
+                fprop_reflect_period_single(p, pl);
+                num = pl->events;
+                den = percpu_counter_read_positive(&p->events);
+        } while (read_seqcount_retry(&p->sequence, seq));
+
+        /*
+         * Make fraction <= 1 and denominator > 0 even in presence of percpu
+         * counter errors
+         */
+        if (den <= num) {
+                if (num)
+                        den = num;
+                else
+                        den = 1;
+        }
+        *denominator = den;
+        *numerator = num;
+}
+
+/*
+ * ---- PERCPU ----
+ */
+#define PROP_BATCH (8*(1+ilog2(nr_cpu_ids)))
+
+int fprop_local_init_percpu(struct fprop_local_percpu *pl)
+{
+        int err;
+
+        err = percpu_counter_init(&pl->events, 0);
+        if (err)
+                return err;
+        pl->period = 0;
+        raw_spin_lock_init(&pl->lock);
+        return 0;
+}
+
+void fprop_local_destroy_percpu(struct fprop_local_percpu *pl)
+{
+        percpu_counter_destroy(&pl->events);
+}
+
+static void fprop_reflect_period_percpu(struct fprop_global *p,
+                                        struct fprop_local_percpu *pl)
+{
+        unsigned int period = p->period;
+        unsigned long flags;
+
+        /* Fast path - period didn't change */
+        if (pl->period == period)
+                return;
+        raw_spin_lock_irqsave(&pl->lock, flags);
+        /* Someone updated pl->period while we were spinning? */
+        if (pl->period >= period) {
+                raw_spin_unlock_irqrestore(&pl->lock, flags);
+                return;
+        }
+        /* Aging zeroed our fraction? */
+        if (period - pl->period < BITS_PER_LONG) {
+                s64 val = percpu_counter_read(&pl->events);
+
+                if (val < (nr_cpu_ids * PROP_BATCH))
+                        val = percpu_counter_sum(&pl->events);
+
+                __percpu_counter_add(&pl->events,
+                        -val + (val >> (period-pl->period)), PROP_BATCH);
+        } else
+                percpu_counter_set(&pl->events, 0);
+        pl->period = period;
+        raw_spin_unlock_irqrestore(&pl->lock, flags);
+}
+
+/* Event of type pl happened */
+void __fprop_inc_percpu(struct fprop_global *p, struct fprop_local_percpu *pl)
+{
+        fprop_reflect_period_percpu(p, pl);
+        __percpu_counter_add(&pl->events, 1, PROP_BATCH);
+        percpu_counter_add(&p->events, 1);
+}
+
+void fprop_fraction_percpu(struct fprop_global *p,
+                           struct fprop_local_percpu *pl,
+                           unsigned long *numerator, unsigned long *denominator)
+{
+        unsigned int seq;
+        s64 num, den;
+
+        do {
+                seq = read_seqcount_begin(&p->sequence);
+                fprop_reflect_period_percpu(p, pl);
+                num = percpu_counter_read_positive(&pl->events);
+                den = percpu_counter_read_positive(&p->events);
+        } while (read_seqcount_retry(&p->sequence, seq));
+
+        /*
+         * Make fraction <= 1 and denominator > 0 even in presence of percpu
+         * counter errors
+         */
+        if (den <= num) {
+                if (num)
+                        den = num;
+                else
+                        den = 1;
+        }
+        *denominator = den;
+        *numerator = num;
+}
+
+/*
+ * Like __fprop_inc_percpu() except that event is counted only if the given
+ * type has fraction smaller than @max_frac/FPROP_FRAC_BASE
+ */
+void __fprop_inc_percpu_max(struct fprop_global *p,
+                            struct fprop_local_percpu *pl, int max_frac)
+{
+        if (unlikely(max_frac < FPROP_FRAC_BASE)) {
+                unsigned long numerator, denominator;
+
+                fprop_fraction_percpu(p, pl, &numerator, &denominator);
+                if (numerator >
+                    (((u64)denominator) * max_frac) >> FPROP_FRAC_SHIFT)
+                        return;
+        } else
+                fprop_reflect_period_percpu(p, pl);
+        __percpu_counter_add(&pl->events, 1, PROP_BATCH);
+        percpu_counter_add(&p->events, 1);
+}
diff --git a/lib/jedec_ddr_data.c b/lib/jedec_ddr_data.c
new file mode 100644
index 000000000000..6d2cbf1d567f
--- /dev/null
+++ b/lib/jedec_ddr_data.c
@@ -0,0 +1,135 @@
+/*
+ * DDR addressing details and AC timing parameters from JEDEC specs
+ *
+ * Copyright (C) 2012 Texas Instruments, Inc.
+ *
+ * Aneesh V <aneesh@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <memory/jedec_ddr.h>
+#include <linux/module.h>
+
+/* LPDDR2 addressing details from JESD209-2 section 2.4 */
+const struct lpddr2_addressing
+        lpddr2_jedec_addressing_table[NUM_DDR_ADDR_TABLE_ENTRIES] = {
+        {B4, T_REFI_15_6, T_RFC_90}, /* 64M */
+        {B4, T_REFI_15_6, T_RFC_90}, /* 128M */
+        {B4, T_REFI_7_8,  T_RFC_90}, /* 256M */
+        {B4, T_REFI_7_8,  T_RFC_90}, /* 512M */
+        {B8, T_REFI_7_8, T_RFC_130}, /* 1GS4 */
+        {B8, T_REFI_3_9, T_RFC_130}, /* 2GS4 */
+        {B8, T_REFI_3_9, T_RFC_130}, /* 4G */
+        {B8, T_REFI_3_9, T_RFC_210}, /* 8G */
+        {B4, T_REFI_7_8, T_RFC_130}, /* 1GS2 */
+        {B4, T_REFI_3_9, T_RFC_130}, /* 2GS2 */
+};
+EXPORT_SYMBOL_GPL(lpddr2_jedec_addressing_table);
+
+/* LPDDR2 AC timing parameters from JESD209-2 section 12 */
+const struct lpddr2_timings
+        lpddr2_jedec_timings[NUM_DDR_TIMING_TABLE_ENTRIES] = {
+        /* Speed bin 400(200 MHz) */
+        [0] = {
+                .max_freq       = 200000000,
+                .min_freq       = 10000000,
+                .tRPab          = 21000,
+                .tRCD           = 18000,
+                .tWR            = 15000,
+                .tRAS_min       = 42000,
+                .tRRD           = 10000,
+                .tWTR           = 10000,
+                .tXP            = 7500,
+                .tRTP           = 7500,
+                .tCKESR         = 15000,
+                .tDQSCK_max     = 5500,
+                .tFAW           = 50000,
+                .tZQCS          = 90000,
+                .tZQCL          = 360000,
+                .tZQinit        = 1000000,
+                .tRAS_max_ns    = 70000,
+                .tDQSCK_max_derated = 6000,
+        },
+        /* Speed bin 533(266 MHz) */
+        [1] = {
+                .max_freq       = 266666666,
+                .min_freq       = 10000000,
+                .tRPab          = 21000,
+                .tRCD           = 18000,
+                .tWR            = 15000,
+                .tRAS_min       = 42000,
+                .tRRD           = 10000,
+                .tWTR           = 7500,
+                .tXP            = 7500,
+                .tRTP           = 7500,
+                .tCKESR         = 15000,
+                .tDQSCK_max     = 5500,
+                .tFAW           = 50000,
+                .tZQCS          = 90000,
+                .tZQCL          = 360000,
+                .tZQinit        = 1000000,
+                .tRAS_max_ns    = 70000,
+                .tDQSCK_max_derated = 6000,
+        },
+        /* Speed bin 800(400 MHz) */
+        [2] = {
+                .max_freq       = 400000000,
+                .min_freq       = 10000000,
+                .tRPab          = 21000,
+                .tRCD           = 18000,
+                .tWR            = 15000,
+                .tRAS_min       = 42000,
+                .tRRD           = 10000,
+                .tWTR           = 7500,
+                .tXP            = 7500,
+                .tRTP           = 7500,
+                .tCKESR         = 15000,
+                .tDQSCK_max     = 5500,
+                .tFAW           = 50000,
+                .tZQCS          = 90000,
+                .tZQCL          = 360000,
+                .tZQinit        = 1000000,
+                .tRAS_max_ns    = 70000,
+                .tDQSCK_max_derated = 6000,
+        },
+        /* Speed bin 1066(533 MHz) */
+        [3] = {
+                .max_freq       = 533333333,
+                .min_freq       = 10000000,
+                .tRPab          = 21000,
+                .tRCD           = 18000,
+                .tWR            = 15000,
+                .tRAS_min       = 42000,
+                .tRRD           = 10000,
+                .tWTR           = 7500,
+                .tXP            = 7500,
+                .tRTP           = 7500,
+                .tCKESR         = 15000,
+                .tDQSCK_max     = 5500,
+                .tFAW           = 50000,
+                .tZQCS          = 90000,
+                .tZQCL          = 360000,
+                .tZQinit        = 1000000,
+                .tRAS_max_ns    = 70000,
+                .tDQSCK_max_derated = 5620,
+        },
+};
+EXPORT_SYMBOL_GPL(lpddr2_jedec_timings);
+
+const struct lpddr2_min_tck lpddr2_jedec_min_tck = {
+        .tRPab          = 3,
+        .tRCD           = 3,
+        .tWR            = 3,
+        .tRASmin        = 3,
+        .tRRD           = 2,
+        .tWTR           = 2,
+        .tXP            = 2,
+        .tRTP           = 2,
+        .tCKE           = 3,
+        .tCKESR         = 3,
+        .tFAW           = 8
+};
+EXPORT_SYMBOL_GPL(lpddr2_jedec_min_tck);
diff --git a/lib/kobject.c b/lib/kobject.c
index aeefa8bc8b1c..e07ee1fcd6f1 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -47,13 +47,11 @@ static int populate_dir(struct kobject *kobj)
 static int create_dir(struct kobject *kobj)
 {
         int error = 0;
-        if (kobject_name(kobj)) {
-                error = sysfs_create_dir(kobj);
-                if (!error) {
-                        error = populate_dir(kobj);
-                        if (error)
-                                sysfs_remove_dir(kobj);
-                }
+        error = sysfs_create_dir(kobj);
+        if (!error) {
+                error = populate_dir(kobj);
+                if (error)
+                        sysfs_remove_dir(kobj);
         }
         return error;
 }
@@ -634,7 +632,7 @@ struct kobject *kobject_create(void)
 /**
  * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
  *
- * @name: the name for the kset
+ * @name: the name for the kobject
  * @parent: the parent kobject of this kobject, if any.
  *
  * This function creates a kobject structure dynamically and registers it
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 1a91efa6d121..0401d2916d9f 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -373,13 +373,16 @@ EXPORT_SYMBOL_GPL(add_uevent_var);
 static int uevent_net_init(struct net *net)
 {
         struct uevent_sock *ue_sk;
+        struct netlink_kernel_cfg cfg = {
+                .groups = 1,
+        };
 
         ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);
         if (!ue_sk)
                 return -ENOMEM;
 
         ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT,
-                                          1, NULL, NULL, THIS_MODULE);
+                                          THIS_MODULE, &cfg);
         if (!ue_sk->sk) {
                 printk(KERN_ERR
                        "kobject_uevent: unable to create netlink socket!\n");
diff --git a/lib/list_debug.c b/lib/list_debug.c
index 982b850d4e7a..c24c2f7e296f 100644
--- a/lib/list_debug.c
+++ b/lib/list_debug.c
@@ -10,6 +10,7 @@
 #include <linux/list.h>
 #include <linux/bug.h>
 #include <linux/kernel.h>
+#include <linux/rculist.h>
 
 /*
  * Insert a new entry between two known consecutive entries.
@@ -30,6 +31,9 @@ void __list_add(struct list_head *new,
                 "list_add corruption. prev->next should be "
                 "next (%p), but was %p. (prev=%p).\n",
                 next, prev->next, prev);
+        WARN(new == prev || new == next,
+             "list_add double add: new=%p, prev=%p, next=%p.\n",
+             new, prev, next);
         next->prev = new;
         new->next = next;
         new->prev = prev;
@@ -75,3 +79,22 @@ void list_del(struct list_head *entry)
         entry->prev = LIST_POISON2;
 }
 EXPORT_SYMBOL(list_del);
+
+/*
+ * RCU variants.
+ */
+void __list_add_rcu(struct list_head *new,
+                    struct list_head *prev, struct list_head *next)
+{
+        WARN(next->prev != prev,
+                "list_add_rcu corruption. next->prev should be prev (%p), but was %p. (next=%p).\n",
+                prev, next->prev, next);
+        WARN(prev->next != next,
+                "list_add_rcu corruption. prev->next should be next (%p), but was %p. (prev=%p).\n",
+                next, prev->next, prev);
+        new->next = next;
+        new->prev = prev;
+        rcu_assign_pointer(list_next_rcu(prev), new);
+        next->prev = new;
+}
+EXPORT_SYMBOL(__list_add_rcu);
diff --git a/lib/memory-notifier-error-inject.c b/lib/memory-notifier-error-inject.c
new file mode 100644
index 000000000000..e6239bf0b0df
--- /dev/null
+++ b/lib/memory-notifier-error-inject.c
@@ -0,0 +1,48 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/memory.h>
+
+#include "notifier-error-inject.h"
+
+static int priority;
+module_param(priority, int, 0);
+MODULE_PARM_DESC(priority, "specify memory notifier priority");
+
+static struct notifier_err_inject memory_notifier_err_inject = {
+        .actions = {
+                { NOTIFIER_ERR_INJECT_ACTION(MEM_GOING_ONLINE) },
+                { NOTIFIER_ERR_INJECT_ACTION(MEM_GOING_OFFLINE) },
+                {}
+        }
+};
+
+static struct dentry *dir;
+
+static int err_inject_init(void)
+{
+        int err;
+
+        dir = notifier_err_inject_init("memory", notifier_err_inject_dir,
+                                        &memory_notifier_err_inject, priority);
+        if (IS_ERR(dir))
+                return PTR_ERR(dir);
+
+        err = register_memory_notifier(&memory_notifier_err_inject.nb);
+        if (err)
+                debugfs_remove_recursive(dir);
+
+        return err;
+}
+
+static void err_inject_exit(void)
+{
+        unregister_memory_notifier(&memory_notifier_err_inject.nb);
+        debugfs_remove_recursive(dir);
+}
+
+module_init(err_inject_init);
+module_exit(err_inject_exit);
+
+MODULE_DESCRIPTION("memory notifier error injection module");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
diff --git a/lib/memweight.c b/lib/memweight.c
new file mode 100644
index 000000000000..e35fc8771893
--- /dev/null
+++ b/lib/memweight.c
@@ -0,0 +1,38 @@
+#include <linux/export.h>
+#include <linux/bug.h>
+#include <linux/bitmap.h>
+
+/**
+ * memweight - count the total number of bits set in memory area
+ * @ptr: pointer to the start of the area
+ * @bytes: the size of the area
+ */
+size_t memweight(const void *ptr, size_t bytes)
+{
+        size_t ret = 0;
+        size_t longs;
+        const unsigned char *bitmap = ptr;
+
+        for (; bytes > 0 && ((unsigned long)bitmap) % sizeof(long);
+                        bytes--, bitmap++)
+                ret += hweight8(*bitmap);
+
+        longs = bytes / sizeof(long);
+        if (longs) {
+                BUG_ON(longs >= INT_MAX / BITS_PER_LONG);
+                ret += bitmap_weight((unsigned long *)bitmap,
+                                longs * BITS_PER_LONG);
+                bytes -= longs * sizeof(long);
+                bitmap += longs * sizeof(long);
+        }
+        /*
+         * The reason that this last loop is distinct from the preceding
+         * bitmap_weight() call is to compute 1-bits in the last region smaller
+         * than sizeof(long) properly on big-endian systems.
+         */
+        for (; bytes > 0; bytes--, bitmap++)
+                ret += hweight8(*bitmap);
+
+        return ret;
+}
+EXPORT_SYMBOL(memweight);
diff --git a/lib/mpi/Makefile b/lib/mpi/Makefile
index 567d52e74d77..45ca90a8639c 100644
--- a/lib/mpi/Makefile
+++ b/lib/mpi/Makefile
@@ -19,14 +19,3 @@ mpi-y = \
         mpih-mul.o                      \
         mpi-pow.o                       \
         mpiutil.o
-
-mpi-$(CONFIG_MPILIB_EXTRA) += \
-        mpi-add.o                       \
-        mpi-div.o                       \
-        mpi-cmp.o                       \
-        mpi-gcd.o                       \
-        mpi-inline.o                    \
-        mpi-inv.o                       \
-        mpi-mpow.o                      \
-        mpi-mul.o                       \
-        mpi-scan.o
diff --git a/lib/mpi/generic_mpi-asm-defs.h b/lib/mpi/generic_mpi-asm-defs.h
deleted file mode 100644
index 047d1f5a7249..000000000000
--- a/lib/mpi/generic_mpi-asm-defs.h
+++ /dev/null
@@ -1,4 +0,0 @@
-/* This file defines some basic constants for the MPI machinery.  We
- * need to define the types on a per-CPU basis, so it is done with
- * this file here.  */
-#define BYTES_PER_MPI_LIMB  (SIZEOF_UNSIGNED_LONG)
diff --git a/lib/mpi/mpi-add.c b/lib/mpi/mpi-add.c
deleted file mode 100644
index f56b9ba295e6..000000000000
--- a/lib/mpi/mpi-add.c
+++ /dev/null
@@ -1,234 +0,0 @@
-/* mpi-add.c  -  MPI functions
- *      Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- *      Copyright (C) 1994, 1996 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- *
- * Note: This code is heavily based on the GNU MP Library.
- *       Actually it's the same code with only minor changes in the
- *       way the data is stored; this is to support the abstraction
- *       of an optional secure memory allocation which may be used
- *       to avoid revealing of sensitive data due to paging etc.
- *       The GNU MP Library itself is published under the LGPL;
- *       however I decided to publish this code under the plain GPL.
- */
-
-#include "mpi-internal.h"
-
-/****************
- * Add the unsigned integer V to the mpi-integer U and store the
- * result in W. U and V may be the same.
- */
-int mpi_add_ui(MPI w, const MPI u, unsigned long v)
-{
-        mpi_ptr_t wp, up;
-        mpi_size_t usize, wsize;
-        int usign, wsign;
-
-        usize = u->nlimbs;
-        usign = u->sign;
-        wsign = 0;
-
-        /* If not space for W (and possible carry), increase space.  */
-        wsize = usize + 1;
-        if (w->alloced < wsize)
-                if (mpi_resize(w, wsize) < 0)
-                        return -ENOMEM;
-
-        /* These must be after realloc (U may be the same as W).  */
-        up = u->d;
-        wp = w->d;
-
-        if (!usize) {           /* simple */
-                wp[0] = v;
-                wsize = v ? 1 : 0;
-        } else if (!usign) {    /* mpi is not negative */
-                mpi_limb_t cy;
-                cy = mpihelp_add_1(wp, up, usize, v);
-                wp[usize] = cy;
-                wsize = usize + cy;
-        } else {                /* The signs are different.  Need exact comparison to determine
-                                 * which operand to subtract from which.  */
-                if (usize == 1 && up[0] < v) {
-                        wp[0] = v - up[0];
-                        wsize = 1;
-                } else {
-                        mpihelp_sub_1(wp, up, usize, v);
-                        /* Size can decrease with at most one limb. */
-                        wsize = usize - (wp[usize - 1] == 0);
-                        wsign = 1;
-                }
-        }
-
-        w->nlimbs = wsize;
-        w->sign = wsign;
-        return 0;
-}
-
-int mpi_add(MPI w, MPI u, MPI v)
-{
-        mpi_ptr_t wp, up, vp;
-        mpi_size_t usize, vsize, wsize;
-        int usign, vsign, wsign;
-
-        if (u->nlimbs < v->nlimbs) {    /* Swap U and V. */
-                usize = v->nlimbs;
-                usign = v->sign;
-                vsize = u->nlimbs;
-                vsign = u->sign;
-                wsize = usize + 1;
-                if (RESIZE_IF_NEEDED(w, wsize) < 0)
-                        return -ENOMEM;
-                /* These must be after realloc (u or v may be the same as w).  */
-                up = v->d;
-                vp = u->d;
-        } else {
-                usize = u->nlimbs;
-                usign = u->sign;
-                vsize = v->nlimbs;
-                vsign = v->sign;
-                wsize = usize + 1;
-                if (RESIZE_IF_NEEDED(w, wsize) < 0)
-                        return -ENOMEM;
-                /* These must be after realloc (u or v may be the same as w).  */
-                up = u->d;
-                vp = v->d;
-        }
-        wp = w->d;
-        wsign = 0;
-
-        if (!vsize) {           /* simple */
-                MPN_COPY(wp, up, usize);
-                wsize = usize;
-                wsign = usign;
-        } else if (usign != vsign) {    /* different sign */
-                /* This test is right since USIZE >= VSIZE */
-                if (usize != vsize) {
-                        mpihelp_sub(wp, up, usize, vp, vsize);
-                        wsize = usize;
-                        MPN_NORMALIZE(wp, wsize);
-                        wsign = usign;
-                } else if (mpihelp_cmp(up, vp, usize) < 0) {
-                        mpihelp_sub_n(wp, vp, up, usize);
-                        wsize = usize;
-                        MPN_NORMALIZE(wp, wsize);
-                        if (!usign)
-                                wsign = 1;
-                } else {
-                        mpihelp_sub_n(wp, up, vp, usize);
-                        wsize = usize;
-                        MPN_NORMALIZE(wp, wsize);
-                        if (usign)
-                                wsign = 1;
-                }
-        } else {                /* U and V have same sign. Add them. */
-                mpi_limb_t cy = mpihelp_add(wp, up, usize, vp, vsize);
-                wp[usize] = cy;
-                wsize = usize + cy;
-                if (usign)
-                        wsign = 1;
-        }
-
-        w->nlimbs = wsize;
-        w->sign = wsign;
-        return 0;
-}
-
-/****************
- * Subtract the unsigned integer V from the mpi-integer U and store the
- * result in W.
- */
-int mpi_sub_ui(MPI w, MPI u, unsigned long v)
-{
-        mpi_ptr_t wp, up;
-        mpi_size_t usize, wsize;
-        int usign, wsign;
-
-        usize = u->nlimbs;
-        usign = u->sign;
-        wsign = 0;
-
-        /* If not space for W (and possible carry), increase space.  */
-        wsize = usize + 1;
-        if (w->alloced < wsize)
-                if (mpi_resize(w, wsize) < 0)
-                        return -ENOMEM;
-
-        /* These must be after realloc (U may be the same as W).  */
-        up = u->d;
-        wp = w->d;
-
-        if (!usize) {           /* simple */
-                wp[0] = v;
-                wsize = v ? 1 : 0;
-                wsign = 1;
-        } else if (usign) {     /* mpi and v are negative */
-                mpi_limb_t cy;
-                cy = mpihelp_add_1(wp, up, usize, v);
-                wp[usize] = cy;
-                wsize = usize + cy;
-        } else {                /* The signs are different.  Need exact comparison to determine
-                                 * which operand to subtract from which.  */
-                if (usize == 1 && up[0] < v) {
-                        wp[0] = v - up[0];
-                        wsize = 1;
-                        wsign = 1;
-                } else {
-                        mpihelp_sub_1(wp, up, usize, v);
-                        /* Size can decrease with at most one limb. */
-                        wsize = usize - (wp[usize - 1] == 0);
-                }
-        }
-
-        w->nlimbs = wsize;
-        w->sign = wsign;
-        return 0;
-}
-
-int mpi_sub(MPI w, MPI u, MPI v)
-{
-        int rc;
-
-        if (w == v) {
-                MPI vv;
-                if (mpi_copy(&vv, v) < 0)
-                        return -ENOMEM;
-                vv->sign = !vv->sign;
-                rc = mpi_add(w, u, vv);
-                mpi_free(vv);
-        } else {
-                /* fixme: this is not thread-save (we temp. modify v) */
-                v->sign = !v->sign;
-                rc = mpi_add(w, u, v);
-                v->sign = !v->sign;
-        }
-        return rc;
-}
-
-int mpi_addm(MPI w, MPI u, MPI v, MPI m)
-{
-        if (mpi_add(w, u, v) < 0 || mpi_fdiv_r(w, w, m) < 0)
-                return -ENOMEM;
-        return 0;
-}
-
-int mpi_subm(MPI w, MPI u, MPI v, MPI m)
-{
-        if (mpi_sub(w, u, v) < 0 || mpi_fdiv_r(w, w, m) < 0)
-                return -ENOMEM;
-        return 0;
-}
diff --git a/lib/mpi/mpi-bit.c b/lib/mpi/mpi-bit.c
index 0c505361da19..568724804f29 100644
--- a/lib/mpi/mpi-bit.c
+++ b/lib/mpi/mpi-bit.c
@@ -54,165 +54,3 @@ unsigned mpi_get_nbits(MPI a)
         return n;
 }
 EXPORT_SYMBOL_GPL(mpi_get_nbits);
-
-/****************
- * Test whether bit N is set.
- */
-int mpi_test_bit(MPI a, unsigned n)
-{
-        unsigned limbno, bitno;
-        mpi_limb_t limb;
-
-        limbno = n / BITS_PER_MPI_LIMB;
-        bitno = n % BITS_PER_MPI_LIMB;
-
-        if (limbno >= a->nlimbs)
-                return 0;       /* too far left: this is a 0 */
-        limb = a->d[limbno];
-        return (limb & (A_LIMB_1 << bitno)) ? 1 : 0;
-}
-
-/****************
- * Set bit N of A.
- */
-int mpi_set_bit(MPI a, unsigned n)
-{
-        unsigned limbno, bitno;
-
-        limbno = n / BITS_PER_MPI_LIMB;
-        bitno = n % BITS_PER_MPI_LIMB;
-
-        if (limbno >= a->nlimbs) {      /* resize */
-                if (a->alloced >= limbno)
-                        if (mpi_resize(a, limbno + 1) < 0)
-                                return -ENOMEM;
-                a->nlimbs = limbno + 1;
-        }
-        a->d[limbno] |= (A_LIMB_1 << bitno);
-        return 0;
-}
-
-/****************
- * Set bit N of A. and clear all bits above
- */
-int mpi_set_highbit(MPI a, unsigned n)
-{
-        unsigned limbno, bitno;
-
-        limbno = n / BITS_PER_MPI_LIMB;
-        bitno = n % BITS_PER_MPI_LIMB;
-
-        if (limbno >= a->nlimbs) {      /* resize */
-                if (a->alloced >= limbno)
-                        if (mpi_resize(a, limbno + 1) < 0)
-                                return -ENOMEM;
-                a->nlimbs = limbno + 1;
-        }
-        a->d[limbno] |= (A_LIMB_1 << bitno);
-        for (bitno++; bitno < BITS_PER_MPI_LIMB; bitno++)
-                a->d[limbno] &= ~(A_LIMB_1 << bitno);
-        a->nlimbs = limbno + 1;
-        return 0;
-}
-
-/****************
- * clear bit N of A and all bits above
- */
-void mpi_clear_highbit(MPI a, unsigned n)
-{
-        unsigned limbno, bitno;
-
-        limbno = n / BITS_PER_MPI_LIMB;
-        bitno = n % BITS_PER_MPI_LIMB;
-
-        if (limbno >= a->nlimbs)
-                return;         /* not allocated, so need to clear bits :-) */
-
-        for (; bitno < BITS_PER_MPI_LIMB; bitno++)
-                a->d[limbno] &= ~(A_LIMB_1 << bitno);
-        a->nlimbs = limbno + 1;
-}
-
-/****************
- * Clear bit N of A.
- */
-void mpi_clear_bit(MPI a, unsigned n)
-{
-        unsigned limbno, bitno;
-
-        limbno = n / BITS_PER_MPI_LIMB;
-        bitno = n % BITS_PER_MPI_LIMB;
-
-        if (limbno >= a->nlimbs)
-                return;         /* don't need to clear this bit, it's to far to left */
-        a->d[limbno] &= ~(A_LIMB_1 << bitno);
-}
-
-/****************
- * Shift A by N bits to the right
- * FIXME: should use alloc_limb if X and A are same.
- */
-int mpi_rshift(MPI x, MPI a, unsigned n)
-{
-        mpi_ptr_t xp;
-        mpi_size_t xsize;
-
-        xsize = a->nlimbs;
-        x->sign = a->sign;
-        if (RESIZE_IF_NEEDED(x, (size_t) xsize) < 0)
-                return -ENOMEM;
-        xp = x->d;
-
-        if (xsize) {
-                mpihelp_rshift(xp, a->d, xsize, n);
-                MPN_NORMALIZE(xp, xsize);
-        }
-        x->nlimbs = xsize;
-        return 0;
-}
-
-/****************
- * Shift A by COUNT limbs to the left
- * This is used only within the MPI library
- */
-int mpi_lshift_limbs(MPI a, unsigned int count)
-{
-        const int n = a->nlimbs;
-        mpi_ptr_t ap;
-        int i;
-
-        if (!count || !n)
-                return 0;
-
-        if (RESIZE_IF_NEEDED(a, n + count) < 0)
-                return -ENOMEM;
-
-        ap = a->d;
-        for (i = n - 1; i >= 0; i--)
-                ap[i + count] = ap[i];
-        for (i = 0; i < count; i++)
-                ap[i] = 0;
-        a->nlimbs += count;
-        return 0;
-}
-
-/****************
- * Shift A by COUNT limbs to the right
- * This is used only within the MPI library
- */
-void mpi_rshift_limbs(MPI a, unsigned int count)
-{
-        mpi_ptr_t ap = a->d;
-        mpi_size_t n = a->nlimbs;
-        unsigned int i;
-
-        if (count >= n) {
-                a->nlimbs = 0;
-                return;
-        }
-
-        for (i = 0; i < n - count; i++)
-                ap[i] = ap[i + count];
-        ap[i] = 0;
-        a->nlimbs -= count;
-}
diff --git a/lib/mpi/mpi-cmp.c b/lib/mpi/mpi-cmp.c
deleted file mode 100644
index 914bc42a8a80..000000000000
--- a/lib/mpi/mpi-cmp.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/* mpi-cmp.c  -  MPI functions
- * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "mpi-internal.h"
-
-int mpi_cmp_ui(MPI u, unsigned long v)
-{
-        mpi_limb_t limb = v;
-
-        mpi_normalize(u);
-        if (!u->nlimbs && !limb)
-                return 0;
-        if (u->sign)
-                return -1;
-        if (u->nlimbs > 1)
-                return 1;
-
-        if (u->d[0] == limb)
-                return 0;
-        else if (u->d[0] > limb)
-                return 1;
-        else
-                return -1;
-}
-
-int mpi_cmp(MPI u, MPI v)
-{
-        mpi_size_t usize, vsize;
-        int cmp;
-
-        mpi_normalize(u);
-        mpi_normalize(v);
-        usize = u->nlimbs;
-        vsize = v->nlimbs;
-        if (!u->sign && v->sign)
-                return 1;
-        if (u->sign && !v->sign)
-                return -1;
-        if (usize != vsize && !u->sign && !v->sign)
-                return usize - vsize;
-        if (usize != vsize && u->sign && v->sign)
-                return vsize + usize;
-        if (!usize)
-                return 0;
-        cmp = mpihelp_cmp(u->d, v->d, usize);
-        if (!cmp)
-                return 0;
-        if ((cmp < 0 ? 1 : 0) == (u->sign ? 1 : 0))
-                return 1;
-        return -1;
-}
diff --git a/lib/mpi/mpi-div.c b/lib/mpi/mpi-div.c
deleted file mode 100644
index f68cbbb4d4a4..000000000000
--- a/lib/mpi/mpi-div.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/* mpi-div.c  -  MPI functions
- *      Copyright (C) 1994, 1996 Free Software Foundation, Inc.
- *      Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- *
- * Note: This code is heavily based on the GNU MP Library.
- *       Actually it's the same code with only minor changes in the
- *       way the data is stored; this is to support the abstraction
- *       of an optional secure memory allocation which may be used
- *       to avoid revealing of sensitive data due to paging etc.
- *       The GNU MP Library itself is published under the LGPL;
- *       however I decided to publish this code under the plain GPL.
- */
-
-#include <linux/string.h>
-#include "mpi-internal.h"
-#include "longlong.h"
-
-int mpi_fdiv_r(MPI rem, MPI dividend, MPI divisor)
-{
-        int rc = -ENOMEM;
-        int divisor_sign = divisor->sign;
-        MPI temp_divisor = NULL;
-
-        /* We need the original value of the divisor after the remainder has been
-         * preliminary calculated.      We have to copy it to temporary space if it's
-         * the same variable as REM.  */
-        if (rem == divisor) {
-                if (mpi_copy(&temp_divisor, divisor) < 0)
-                        goto nomem;
-                divisor = temp_divisor;
-        }
-
-        if (mpi_tdiv_qr(NULL, rem, dividend, divisor) < 0)
-                goto nomem;
-        if (((divisor_sign ? 1 : 0) ^ (dividend->sign ? 1 : 0)) && rem->nlimbs)
-                if (mpi_add(rem, rem, divisor) < 0)
-                        goto nomem;
-
-        rc = 0;
-
-nomem:
-        if (temp_divisor)
-                mpi_free(temp_divisor);
-        return rc;
-}
-
-/****************
- * Division rounding the quotient towards -infinity.
- * The remainder gets the same sign as the denominator.
- * rem is optional
- */
-
-ulong mpi_fdiv_r_ui(MPI rem, MPI dividend, ulong divisor)
-{
-        mpi_limb_t rlimb;
-
-        rlimb = mpihelp_mod_1(dividend->d, dividend->nlimbs, divisor);
-        if (rlimb && dividend->sign)
-                rlimb = divisor - rlimb;
-
-        if (rem) {
-                rem->d[0] = rlimb;
-                rem->nlimbs = rlimb ? 1 : 0;
-        }
-        return rlimb;
-}
-
-int mpi_fdiv_q(MPI quot, MPI dividend, MPI divisor)
-{
-        MPI tmp = mpi_alloc(mpi_get_nlimbs(quot));
-        if (!tmp)
-                return -ENOMEM;
-        mpi_fdiv_qr(quot, tmp, dividend, divisor);
-        mpi_free(tmp);
-        return 0;
-}
-
-int mpi_fdiv_qr(MPI quot, MPI rem, MPI dividend, MPI divisor)
-{
-        int divisor_sign = divisor->sign;
-        MPI temp_divisor = NULL;
-
-        if (quot == divisor || rem == divisor) {
-                if (mpi_copy(&temp_divisor, divisor) < 0)
-                        return -ENOMEM;
-                divisor = temp_divisor;
-        }
-
-        if (mpi_tdiv_qr(quot, rem, dividend, divisor) < 0)
-                goto nomem;
-
-        if ((divisor_sign ^ dividend->sign) && rem->nlimbs) {
-                if (mpi_sub_ui(quot, quot, 1) < 0)
-                        goto nomem;
-                if (mpi_add(rem, rem, divisor) < 0)
-                        goto nomem;
-        }
-
-        if (temp_divisor)
-                mpi_free(temp_divisor);
-
-        return 0;
-
-nomem:
-        mpi_free(temp_divisor);
-        return -ENOMEM;
-}
-
-/* If den == quot, den needs temporary storage.
- * If den == rem, den needs temporary storage.
- * If num == quot, num needs temporary storage.
- * If den has temporary storage, it can be normalized while being copied,
- *   i.e no extra storage should be allocated.
- */
-
-int mpi_tdiv_r(MPI rem, MPI num, MPI den)
-{
-        return mpi_tdiv_qr(NULL, rem, num, den);
-}
-
-int mpi_tdiv_qr(MPI quot, MPI rem, MPI num, MPI den)
-{
-        int rc = -ENOMEM;
-        mpi_ptr_t np, dp;
-        mpi_ptr_t qp, rp;
-        mpi_size_t nsize = num->nlimbs;
-        mpi_size_t dsize = den->nlimbs;
-        mpi_size_t qsize, rsize;
-        mpi_size_t sign_remainder = num->sign;
-        mpi_size_t sign_quotient = num->sign ^ den->sign;
-        unsigned normalization_steps;
-        mpi_limb_t q_limb;
-        mpi_ptr_t marker[5];
-        int markidx = 0;
-
-        if (!dsize)
-                return -EINVAL;
-
-        memset(marker, 0, sizeof(marker));
-
-        /* Ensure space is enough for quotient and remainder.
-         * We need space for an extra limb in the remainder, because it's
-         * up-shifted (normalized) below.  */
-        rsize = nsize + 1;
-        if (mpi_resize(rem, rsize) < 0)
-                goto nomem;
-
-        qsize = rsize - dsize;  /* qsize cannot be bigger than this.  */
-        if (qsize <= 0) {
-                if (num != rem) {
-                        rem->nlimbs = num->nlimbs;
-                        rem->sign = num->sign;
-                        MPN_COPY(rem->d, num->d, nsize);
-                }
-                if (quot) {
-                        /* This needs to follow the assignment to rem, in case the
-                         * numerator and quotient are the same.  */
-                        quot->nlimbs = 0;
-                        quot->sign = 0;
-                }
-                return 0;
-        }
-
-        if (quot)
-                if (mpi_resize(quot, qsize) < 0)
-                        goto nomem;
-
-        /* Read pointers here, when reallocation is finished.  */
-        np = num->d;
-        dp = den->d;
-        rp = rem->d;
-
-        /* Optimize division by a single-limb divisor.  */
-        if (dsize == 1) {
-                mpi_limb_t rlimb;
-                if (quot) {
-                        qp = quot->d;
-                        rlimb = mpihelp_divmod_1(qp, np, nsize, dp[0]);
-                        qsize -= qp[qsize - 1] == 0;
-                        quot->nlimbs = qsize;
-                        quot->sign = sign_quotient;
-                } else
-                        rlimb = mpihelp_mod_1(np, nsize, dp[0]);
-                rp[0] = rlimb;
-                rsize = rlimb != 0 ? 1 : 0;
-                rem->nlimbs = rsize;
-                rem->sign = sign_remainder;
-                return 0;
-        }
-
-        if (quot) {
-                qp = quot->d;
-                /* Make sure QP and NP point to different objects.  Otherwise the
-                 * numerator would be gradually overwritten by the quotient limbs.  */
-                if (qp == np) { /* Copy NP object to temporary space.  */
-                        np = marker[markidx++] = mpi_alloc_limb_space(nsize);
-                        if (!np)
-                                goto nomem;
-                        MPN_COPY(np, qp, nsize);
-                }
-        } else                  /* Put quotient at top of remainder. */
-                qp = rp + dsize;
-
-        count_leading_zeros(normalization_steps, dp[dsize - 1]);
-
-        /* Normalize the denominator, i.e. make its most significant bit set by
-         * shifting it NORMALIZATION_STEPS bits to the left.  Also shift the
-         * numerator the same number of steps (to keep the quotient the same!).
-         */
-        if (normalization_steps) {
-                mpi_ptr_t tp;
-                mpi_limb_t nlimb;
-
-                /* Shift up the denominator setting the most significant bit of
-                 * the most significant word.  Use temporary storage not to clobber
-                 * the original contents of the denominator.  */
-                tp = marker[markidx++] = mpi_alloc_limb_space(dsize);
-                if (!tp)
-                        goto nomem;
-                mpihelp_lshift(tp, dp, dsize, normalization_steps);
-                dp = tp;
-
-                /* Shift up the numerator, possibly introducing a new most
-                 * significant word.  Move the shifted numerator in the remainder
-                 * meanwhile.  */
-                nlimb = mpihelp_lshift(rp, np, nsize, normalization_steps);
-                if (nlimb) {
-                        rp[nsize] = nlimb;
-                        rsize = nsize + 1;
-                } else
-                        rsize = nsize;
-        } else {
-                /* The denominator is already normalized, as required.  Copy it to
-                 * temporary space if it overlaps with the quotient or remainder.  */
-                if (dp == rp || (quot && (dp == qp))) {
-                        mpi_ptr_t tp;
-
-                        tp = marker[markidx++] = mpi_alloc_limb_space(dsize);
-                        if (!tp)
-                                goto nomem;
-                        MPN_COPY(tp, dp, dsize);
-                        dp = tp;
-                }
-
-                /* Move the numerator to the remainder.  */
-                if (rp != np)
-                        MPN_COPY(rp, np, nsize);
-
-                rsize = nsize;
-        }
-
-        q_limb = mpihelp_divrem(qp, 0, rp, rsize, dp, dsize);
-
-        if (quot) {
-                qsize = rsize - dsize;
-                if (q_limb) {
-                        qp[qsize] = q_limb;
-                        qsize += 1;
-                }
-
-                quot->nlimbs = qsize;
-                quot->sign = sign_quotient;
-        }
-
-        rsize = dsize;
-        MPN_NORMALIZE(rp, rsize);
-
-        if (normalization_steps && rsize) {
-                mpihelp_rshift(rp, rp, rsize, normalization_steps);
-                rsize -= rp[rsize - 1] == 0 ? 1 : 0;
-        }
-
-        rem->nlimbs = rsize;
-        rem->sign = sign_remainder;
-
-        rc = 0;
-nomem:
-        while (markidx)
-                mpi_free_limb_space(marker[--markidx]);
-        return rc;
-}
-
-int mpi_tdiv_q_2exp(MPI w, MPI u, unsigned count)
-{
-        mpi_size_t usize, wsize;
-        mpi_size_t limb_cnt;
-
-        usize = u->nlimbs;
-        limb_cnt = count / BITS_PER_MPI_LIMB;
-        wsize = usize - limb_cnt;
-        if (limb_cnt >= usize)
-                w->nlimbs = 0;
-        else {
-                mpi_ptr_t wp;
-                mpi_ptr_t up;
-
-                if (RESIZE_IF_NEEDED(w, wsize) < 0)
-                        return -ENOMEM;
-                wp = w->d;
-                up = u->d;
-
-                count %= BITS_PER_MPI_LIMB;
-                if (count) {
-                        mpihelp_rshift(wp, up + limb_cnt, wsize, count);
-                        wsize -= !wp[wsize - 1];
-                } else {
-                        MPN_COPY_INCR(wp, up + limb_cnt, wsize);
-                }
-
-                w->nlimbs = wsize;
-        }
-        return 0;
-}
-
-/****************
- * Check whether dividend is divisible by divisor
- * (note: divisor must fit into a limb)
- */
-int mpi_divisible_ui(MPI dividend, ulong divisor)
-{
-        return !mpihelp_mod_1(dividend->d, dividend->nlimbs, divisor);
-}
diff --git a/lib/mpi/mpi-gcd.c b/lib/mpi/mpi-gcd.c
deleted file mode 100644
index 13c48aef9c4e..000000000000
--- a/lib/mpi/mpi-gcd.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/* mpi-gcd.c  -  MPI functions
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "mpi-internal.h"
-
-/****************
- * Find the greatest common divisor G of A and B.
- * Return: true if this 1, false in all other cases
- */
-int mpi_gcd(MPI g, const MPI xa, const MPI xb)
-{
-        MPI a = NULL, b = NULL;
-
-        if (mpi_copy(&a, xa) < 0)
-                goto nomem;
-
-        if (mpi_copy(&b, xb) < 0)
-                goto nomem;
-
-        /* TAOCP Vol II, 4.5.2, Algorithm A */
-        a->sign = 0;
-        b->sign = 0;
-        while (mpi_cmp_ui(b, 0)) {
-                if (mpi_fdiv_r(g, a, b) < 0)    /* g used as temorary variable */
-                        goto nomem;
-                if (mpi_set(a, b) < 0)
-                        goto nomem;
-                if (mpi_set(b, g) < 0)
-                        goto nomem;
-        }
-        if (mpi_set(g, a) < 0)
-                goto nomem;
-
-        mpi_free(a);
-        mpi_free(b);
-        return !mpi_cmp_ui(g, 1);
-
-nomem:
-        mpi_free(a);
-        mpi_free(b);
-        return -ENOMEM;
-}
diff --git a/lib/mpi/mpi-inline.c b/lib/mpi/mpi-inline.c
deleted file mode 100644
index 654f68aeed8b..000000000000
--- a/lib/mpi/mpi-inline.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/* mpi-inline.c
- * Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-/* put the inline functions as real functions into the lib */
-#define G10_MPI_INLINE_DECL
-
-#include "mpi-internal.h"
-
-/* always include the header becuase it is only
- * included by mpi-internal if __GCC__ is defined but we
- * need it here in all cases and the above definition of
- * of the macro allows us to do so
- */
-#include "mpi-inline.h"
diff --git a/lib/mpi/mpi-inv.c b/lib/mpi/mpi-inv.c
deleted file mode 100644
index 0951f9847745..000000000000
--- a/lib/mpi/mpi-inv.c
+++ /dev/null
@@ -1,187 +0,0 @@
-/* mpi-inv.c  -  MPI functions
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "mpi-internal.h"
-
-/****************
- * Calculate the multiplicative inverse X of A mod N
- * That is: Find the solution x for
- *              1 = (a*x) mod n
- */
-int mpi_invm(MPI x, const MPI a, const MPI n)
-{
-        /* Extended Euclid's algorithm (See TAOPC Vol II, 4.5.2, Alg X)
-         * modified according to Michael Penk's solution for Exercice 35
-         * with further enhancement */
-        MPI u = NULL, v = NULL;
-        MPI u1 = NULL, u2 = NULL, u3 = NULL;
-        MPI v1 = NULL, v2 = NULL, v3 = NULL;
-        MPI t1 = NULL, t2 = NULL, t3 = NULL;
-        unsigned k;
-        int sign;
-        int odd = 0;
-        int rc = -ENOMEM;
-
-        if (mpi_copy(&u, a) < 0)
-                goto cleanup;
-        if (mpi_copy(&v, n) < 0)
-                goto cleanup;
-
-        for (k = 0; !mpi_test_bit(u, 0) && !mpi_test_bit(v, 0); k++) {
-                if (mpi_rshift(u, u, 1) < 0)
-                        goto cleanup;
-                if (mpi_rshift(v, v, 1) < 0)
-                        goto cleanup;
-        }
-        odd = mpi_test_bit(v, 0);
-
-        u1 = mpi_alloc_set_ui(1);
-        if (!u1)
-                goto cleanup;
-        if (!odd) {
-                u2 = mpi_alloc_set_ui(0);
-                if (!u2)
-                        goto cleanup;
-        }
-        if (mpi_copy(&u3, u) < 0)
-                goto cleanup;
-        if (mpi_copy(&v1, v) < 0)
-                goto cleanup;
-        if (!odd) {
-                v2 = mpi_alloc(mpi_get_nlimbs(u));
-                if (!v2)
-                        goto cleanup;
-                if (mpi_sub(v2, u1, u) < 0)
-                        goto cleanup;   /* U is used as const 1 */
-        }
-        if (mpi_copy(&v3, v) < 0)
-                goto cleanup;
-        if (mpi_test_bit(u, 0)) {       /* u is odd */
-                t1 = mpi_alloc_set_ui(0);
-                if (!t1)
-                        goto cleanup;
-                if (!odd) {
-                        t2 = mpi_alloc_set_ui(1);
-                        if (!t2)
-                                goto cleanup;
-                        t2->sign = 1;
-                }
-                if (mpi_copy(&t3, v) < 0)
-                        goto cleanup;
-                t3->sign = !t3->sign;
-                goto Y4;
-        } else {
-                t1 = mpi_alloc_set_ui(1);
-                if (!t1)
-                        goto cleanup;
-                if (!odd) {
-                        t2 = mpi_alloc_set_ui(0);
-                        if (!t2)
-                                goto cleanup;
-                }
-                if (mpi_copy(&t3, u) < 0)
-                        goto cleanup;
-        }
-        do {
-                do {
-                        if (!odd) {
-                                if (mpi_test_bit(t1, 0) || mpi_test_bit(t2, 0)) {       /* one is odd */
-                                        if (mpi_add(t1, t1, v) < 0)
-                                                goto cleanup;
-                                        if (mpi_sub(t2, t2, u) < 0)
-                                                goto cleanup;
-                                }
-                                if (mpi_rshift(t1, t1, 1) < 0)
-                                        goto cleanup;
-                                if (mpi_rshift(t2, t2, 1) < 0)
-                                        goto cleanup;
-                                if (mpi_rshift(t3, t3, 1) < 0)
-                                        goto cleanup;
-                        } else {
-                                if (mpi_test_bit(t1, 0))
-                                        if (mpi_add(t1, t1, v) < 0)
-                                                goto cleanup;
-                                if (mpi_rshift(t1, t1, 1) < 0)
-                                        goto cleanup;
-                                if (mpi_rshift(t3, t3, 1) < 0)
-                                        goto cleanup;
-                        }
-Y4:
-                        ;
-                } while (!mpi_test_bit(t3, 0)); /* while t3 is even */
-
-                if (!t3->sign) {
-                        if (mpi_set(u1, t1) < 0)
-                                goto cleanup;
-                        if (!odd)
-                                if (mpi_set(u2, t2) < 0)
-                                        goto cleanup;
-                        if (mpi_set(u3, t3) < 0)
-                                goto cleanup;
-                } else {
-                        if (mpi_sub(v1, v, t1) < 0)
-                                goto cleanup;
-                        sign = u->sign;
-                        u->sign = !u->sign;
-                        if (!odd)
-                                if (mpi_sub(v2, u, t2) < 0)
-                                        goto cleanup;
-                        u->sign = sign;
-                        sign = t3->sign;
-                        t3->sign = !t3->sign;
-                        if (mpi_set(v3, t3) < 0)
-                                goto cleanup;
-                        t3->sign = sign;
-                }
-                if (mpi_sub(t1, u1, v1) < 0)
-                        goto cleanup;
-                if (!odd)
-                        if (mpi_sub(t2, u2, v2) < 0)
-                                goto cleanup;
-                if (mpi_sub(t3, u3, v3) < 0)
-                        goto cleanup;
-                if (t1->sign) {
-                        if (mpi_add(t1, t1, v) < 0)
-                                goto cleanup;
-                        if (!odd)
-                                if (mpi_sub(t2, t2, u) < 0)
-                                        goto cleanup;
-                }
-        } while (mpi_cmp_ui(t3, 0));    /* while t3 != 0 */
-        /* mpi_lshift( u3, k ); */
-        rc = mpi_set(x, u1);
-
-cleanup:
-        mpi_free(u1);
-        mpi_free(v1);
-        mpi_free(t1);
-        if (!odd) {
-                mpi_free(u2);
-                mpi_free(v2);
-                mpi_free(t2);
-        }
-        mpi_free(u3);
-        mpi_free(v3);
-        mpi_free(t3);
-
-        mpi_free(u);
-        mpi_free(v);
-        return rc;
-}
diff --git a/lib/mpi/mpi-mpow.c b/lib/mpi/mpi-mpow.c
deleted file mode 100644
index 7328d0d6c748..000000000000
--- a/lib/mpi/mpi-mpow.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/* mpi-mpow.c  -  MPI functions
- * Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "mpi-internal.h"
-#include "longlong.h"
-
-static int build_index(const MPI *exparray, int k, int i, int t)
-{
-        int j, bitno;
-        int index = 0;
-
-        bitno = t - i;
-        for (j = k - 1; j >= 0; j--) {
-                index <<= 1;
-                if (mpi_test_bit(exparray[j], bitno))
-                        index |= 1;
-        }
-        return index;
-}
-
-/****************
- * RES = (BASE[0] ^ EXP[0]) *  (BASE[1] ^ EXP[1]) * ... * mod M
- */
-int mpi_mulpowm(MPI res, MPI *basearray, MPI *exparray, MPI m)
-{
-        int rc = -ENOMEM;
-        int k;                  /* number of elements */
-        int t;                  /* bit size of largest exponent */
-        int i, j, idx;
-        MPI *G = NULL;          /* table with precomputed values of size 2^k */
-        MPI tmp = NULL;
-
-        for (k = 0; basearray[k]; k++)
-                ;
-        if (!k) {
-                pr_emerg("mpi_mulpowm: assert(k) failed\n");
-                BUG();
-        }
-        for (t = 0, i = 0; (tmp = exparray[i]); i++) {
-                j = mpi_get_nbits(tmp);
-                if (j > t)
-                        t = j;
-        }
-        if (i != k) {
-                pr_emerg("mpi_mulpowm: assert(i==k) failed\n");
-                BUG();
-        }
-        if (!t) {
-                pr_emerg("mpi_mulpowm: assert(t) failed\n");
-                BUG();
-        }
-        if (k >= 10) {
-                pr_emerg("mpi_mulpowm: assert(k<10) failed\n");
-                BUG();
-        }
-
-        G = kzalloc((1 << k) * sizeof *G, GFP_KERNEL);
-        if (!G)
-                goto err_out;
-
-        /* and calculate */
-        tmp = mpi_alloc(mpi_get_nlimbs(m) + 1);
-        if (!tmp)
-                goto nomem;
-        if (mpi_set_ui(res, 1) < 0)
-                goto nomem;
-        for (i = 1; i <= t; i++) {
-                if (mpi_mulm(tmp, res, res, m) < 0)
-                        goto nomem;
-                idx = build_index(exparray, k, i, t);
-                if (!(idx >= 0 && idx < (1 << k))) {
-                        pr_emerg("mpi_mulpowm: assert(idx >= 0 && idx < (1<<k)) failed\n");
-                        BUG();
-                }
-                if (!G[idx]) {
-                        if (!idx) {
-                                G[0] = mpi_alloc_set_ui(1);
-                                if (!G[0])
-                                        goto nomem;
-                        } else {
-                                for (j = 0; j < k; j++) {
-                                        if ((idx & (1 << j))) {
-                                                if (!G[idx]) {
-                                                        if (mpi_copy
-                                                            (&G[idx],
-                                                             basearray[j]) < 0)
-                                                                goto nomem;
-                                                } else {
-                                                        if (mpi_mulm
-                                                            (G[idx], G[idx],
-                                                             basearray[j],
-                                                             m) < 0)
-                                                                goto nomem;
-                                                }
-                                        }
-                                }
-                                if (!G[idx]) {
-                                        G[idx] = mpi_alloc(0);
-                                        if (!G[idx])
-                                                goto nomem;
-                                }
-                        }
-                }
-                if (mpi_mulm(res, tmp, G[idx], m) < 0)
-                        goto nomem;
-        }
-
-        rc = 0;
-nomem:
-        /* cleanup */
-        mpi_free(tmp);
-        for (i = 0; i < (1 << k); i++)
-                mpi_free(G[i]);
-        kfree(G);
-err_out:
-        return rc;
-}
diff --git a/lib/mpi/mpi-mul.c b/lib/mpi/mpi-mul.c
deleted file mode 100644
index 1f3219e27292..000000000000
--- a/lib/mpi/mpi-mul.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/* mpi-mul.c  -  MPI functions
- *      Copyright (C) 1994, 1996 Free Software Foundation, Inc.
- *      Copyright (C) 1998, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- *
- * Note: This code is heavily based on the GNU MP Library.
- *       Actually it's the same code with only minor changes in the
- *       way the data is stored; this is to support the abstraction
- *       of an optional secure memory allocation which may be used
- *       to avoid revealing of sensitive data due to paging etc.
- *       The GNU MP Library itself is published under the LGPL;
- *       however I decided to publish this code under the plain GPL.
- */
-
-#include "mpi-internal.h"
-
-int mpi_mul_ui(MPI prod, MPI mult, unsigned long small_mult)
-{
-        mpi_size_t size, prod_size;
-        mpi_ptr_t prod_ptr;
-        mpi_limb_t cy;
-        int sign;
-
-        size = mult->nlimbs;
-        sign = mult->sign;
-
-        if (!size || !small_mult) {
-                prod->nlimbs = 0;
-                prod->sign = 0;
-                return 0;
-        }
-
-        prod_size = size + 1;
-        if (prod->alloced < prod_size)
-                if (mpi_resize(prod, prod_size) < 0)
-                        return -ENOMEM;
-        prod_ptr = prod->d;
-
-        cy = mpihelp_mul_1(prod_ptr, mult->d, size, (mpi_limb_t) small_mult);
-        if (cy)
-                prod_ptr[size++] = cy;
-        prod->nlimbs = size;
-        prod->sign = sign;
-        return 0;
-}
-
-int mpi_mul_2exp(MPI w, MPI u, unsigned long cnt)
-{
-        mpi_size_t usize, wsize, limb_cnt;
-        mpi_ptr_t wp;
-        mpi_limb_t wlimb;
-        int usign, wsign;
-
-        usize = u->nlimbs;
-        usign = u->sign;
-
-        if (!usize) {
-                w->nlimbs = 0;
-                w->sign = 0;
-                return 0;
-        }
-
-        limb_cnt = cnt / BITS_PER_MPI_LIMB;
-        wsize = usize + limb_cnt + 1;
-        if (w->alloced < wsize)
-                if (mpi_resize(w, wsize) < 0)
-                        return -ENOMEM;
-        wp = w->d;
-        wsize = usize + limb_cnt;
-        wsign = usign;
-
-        cnt %= BITS_PER_MPI_LIMB;
-        if (cnt) {
-                wlimb = mpihelp_lshift(wp + limb_cnt, u->d, usize, cnt);
-                if (wlimb) {
-                        wp[wsize] = wlimb;
-                        wsize++;
-                }
-        } else {
-                MPN_COPY_DECR(wp + limb_cnt, u->d, usize);
-        }
-
-        /* Zero all whole limbs at low end.  Do it here and not before calling
-         * mpn_lshift, not to lose for U == W.  */
-        MPN_ZERO(wp, limb_cnt);
-
-        w->nlimbs = wsize;
-        w->sign = wsign;
-        return 0;
-}
-
-int mpi_mul(MPI w, MPI u, MPI v)
-{
-        int rc = -ENOMEM;
-        mpi_size_t usize, vsize, wsize;
-        mpi_ptr_t up, vp, wp;
-        mpi_limb_t cy;
-        int usign, vsign, sign_product;
-        int assign_wp = 0;
-        mpi_ptr_t tmp_limb = NULL;
-
-        if (u->nlimbs < v->nlimbs) {    /* Swap U and V. */
-                usize = v->nlimbs;
-                usign = v->sign;
-                up = v->d;
-                vsize = u->nlimbs;
-                vsign = u->sign;
-                vp = u->d;
-        } else {
-                usize = u->nlimbs;
-                usign = u->sign;
-                up = u->d;
-                vsize = v->nlimbs;
-                vsign = v->sign;
-                vp = v->d;
-        }
-        sign_product = usign ^ vsign;
-        wp = w->d;
-
-        /* Ensure W has space enough to store the result.  */
-        wsize = usize + vsize;
-        if (w->alloced < (size_t) wsize) {
-                if (wp == up || wp == vp) {
-                        wp = mpi_alloc_limb_space(wsize);
-                        if (!wp)
-                                goto nomem;
-                        assign_wp = 1;
-                } else {
-                        if (mpi_resize(w, wsize) < 0)
-                                goto nomem;
-                        wp = w->d;
-                }
-        } else {                /* Make U and V not overlap with W.      */
-                if (wp == up) {
-                        /* W and U are identical.  Allocate temporary space for U.      */
-                        up = tmp_limb = mpi_alloc_limb_space(usize);
-                        if (!up)
-                                goto nomem;
-                        /* Is V identical too?  Keep it identical with U.  */
-                        if (wp == vp)
-                                vp = up;
-                        /* Copy to the temporary space.  */
-                        MPN_COPY(up, wp, usize);
-                } else if (wp == vp) {
-                        /* W and V are identical.  Allocate temporary space for V.      */
-                        vp = tmp_limb = mpi_alloc_limb_space(vsize);
-                        if (!vp)
-                                goto nomem;
-                        /* Copy to the temporary space.  */
-                        MPN_COPY(vp, wp, vsize);
-                }
-        }
-
-        if (!vsize)
-                wsize = 0;
-        else {
-                if (mpihelp_mul(wp, up, usize, vp, vsize, &cy) < 0)
-                        goto nomem;
-                wsize -= cy ? 0 : 1;
-        }
-
-        if (assign_wp)
-                mpi_assign_limb_space(w, wp, wsize);
-
-        w->nlimbs = wsize;
-        w->sign = sign_product;
-        rc = 0;
-nomem:
-        if (tmp_limb)
-                mpi_free_limb_space(tmp_limb);
-        return rc;
-}
-
-int mpi_mulm(MPI w, MPI u, MPI v, MPI m)
-{
-        if (mpi_mul(w, u, v) < 0)
-                return -ENOMEM;
-        return mpi_fdiv_r(w, w, m);
-}
diff --git a/lib/mpi/mpi-scan.c b/lib/mpi/mpi-scan.c
deleted file mode 100644
index b2da5ad96199..000000000000
--- a/lib/mpi/mpi-scan.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/* mpi-scan.c  -  MPI functions
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- *
- * This file is part of GnuPG.
- *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * GnuPG is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "mpi-internal.h"
-#include "longlong.h"
-
-/****************
- * Scan through an mpi and return byte for byte. a -1 is returned to indicate
- * the end of the mpi. Scanning is done from the lsb to the msb, returned
- * values are in the range of 0 .. 255.
- *
- * FIXME: This code is VERY ugly!
- */
-int mpi_getbyte(const MPI a, unsigned idx)
-{
-        int i, j;
-        unsigned n;
-        mpi_ptr_t ap;
-        mpi_limb_t limb;
-
-        ap = a->d;
-        for (n = 0, i = 0; i < a->nlimbs; i++) {
-                limb = ap[i];
-                for (j = 0; j < BYTES_PER_MPI_LIMB; j++, n++)
-                        if (n == idx)
-                                return (limb >> j * 8) & 0xff;
-        }
-        return -1;
-}
-
-/****************
- * Put a value at position IDX into A. idx counts from lsb to msb
- */
-void mpi_putbyte(MPI a, unsigned idx, int xc)
-{
-        int i, j;
-        unsigned n;
-        mpi_ptr_t ap;
-        mpi_limb_t limb, c;
-
-        c = xc & 0xff;
-        ap = a->d;
-        for (n = 0, i = 0; i < a->alloced; i++) {
-                limb = ap[i];
-                for (j = 0; j < BYTES_PER_MPI_LIMB; j++, n++)
-                        if (n == idx) {
-#if BYTES_PER_MPI_LIMB == 4
-                                if (j == 0)
-                                        limb = (limb & 0xffffff00) | c;
-                                else if (j == 1)
-                                        limb = (limb & 0xffff00ff) | (c << 8);
-                                else if (j == 2)
-                                        limb = (limb & 0xff00ffff) | (c << 16);
-                                else
-                                        limb = (limb & 0x00ffffff) | (c << 24);
-#elif BYTES_PER_MPI_LIMB == 8
-                                if (j == 0)
-                                        limb = (limb & 0xffffffffffffff00) | c;
-                                else if (j == 1)
-                                        limb =
-                                            (limb & 0xffffffffffff00ff) | (c <<
-                                                                           8);
-                                else if (j == 2)
-                                        limb =
-                                            (limb & 0xffffffffff00ffff) | (c <<
-                                                                           16);
-                                else if (j == 3)
-                                        limb =
-                                            (limb & 0xffffffff00ffffff) | (c <<
-                                                                           24);
-                                else if (j == 4)
-                                        limb =
-                                            (limb & 0xffffff00ffffffff) | (c <<
-                                                                           32);
-                                else if (j == 5)
-                                        limb =
-                                            (limb & 0xffff00ffffffffff) | (c <<
-                                                                           40);
-                                else if (j == 6)
-                                        limb =
-                                            (limb & 0xff00ffffffffffff) | (c <<
-                                                                           48);
-                                else
-                                        limb =
-                                            (limb & 0x00ffffffffffffff) | (c <<
-                                                                           56);
-#else
-#error please enhance this function, its ugly - i know.
-#endif
-                                if (a->nlimbs <= i)
-                                        a->nlimbs = i + 1;
-                                ap[i] = limb;
-                                return;
-                        }
-        }
-        log_bug("index out of range\n");
-}
-
-/****************
- * Count the number of zerobits at the low end of A
- */
-unsigned mpi_trailing_zeros(const MPI a)
-{
-        unsigned n, count = 0;
-
-        for (n = 0; n < a->nlimbs; n++) {
-                if (a->d[n]) {
-                        unsigned nn;
-                        mpi_limb_t alimb = a->d[n];
-
-                        count_trailing_zeros(nn, alimb);
-                        count += nn;
-                        break;
-                }
-                count += BITS_PER_MPI_LIMB;
-        }
-        return count;
-
-}
diff --git a/lib/mpi/mpicoder.c b/lib/mpi/mpicoder.c
index f26b41fcb48c..f0fa65995800 100644
--- a/lib/mpi/mpicoder.c
+++ b/lib/mpi/mpicoder.c
@@ -74,81 +74,6 @@ leave:
 EXPORT_SYMBOL_GPL(mpi_read_from_buffer);
 
 /****************
- * Make an mpi from a character string.
- */
-int mpi_fromstr(MPI val, const char *str)
-{
-        int hexmode = 0, sign = 0, prepend_zero = 0, i, j, c, c1, c2;
-        unsigned nbits, nbytes, nlimbs;
-        mpi_limb_t a;
-
-        if (*str == '-') {
-                sign = 1;
-                str++;
-        }
-        if (*str == '0' && str[1] == 'x')
-                hexmode = 1;
-        else
-                return -EINVAL; /* other bases are not yet supported */
-        str += 2;
-
-        nbits = strlen(str) * 4;
-        if (nbits % 8)
-                prepend_zero = 1;
-        nbytes = (nbits + 7) / 8;
-        nlimbs = (nbytes + BYTES_PER_MPI_LIMB - 1) / BYTES_PER_MPI_LIMB;
-        if (val->alloced < nlimbs)
-                if (!mpi_resize(val, nlimbs))
-                        return -ENOMEM;
-        i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
-        i %= BYTES_PER_MPI_LIMB;
-        j = val->nlimbs = nlimbs;
-        val->sign = sign;
-        for (; j > 0; j--) {
-                a = 0;
-                for (; i < BYTES_PER_MPI_LIMB; i++) {
-                        if (prepend_zero) {
-                                c1 = '0';
-                                prepend_zero = 0;
-                        } else
-                                c1 = *str++;
-                        assert(c1);
-                        c2 = *str++;
-                        assert(c2);
-                        if (c1 >= '0' && c1 <= '9')
-                                c = c1 - '0';
-                        else if (c1 >= 'a' && c1 <= 'f')
-                                c = c1 - 'a' + 10;
-                        else if (c1 >= 'A' && c1 <= 'F')
-                                c = c1 - 'A' + 10;
-                        else {
-                                mpi_clear(val);
-                                return 1;
-                        }
-                        c <<= 4;
-                        if (c2 >= '0' && c2 <= '9')
-                                c |= c2 - '0';
-                        else if (c2 >= 'a' && c2 <= 'f')
-                                c |= c2 - 'a' + 10;
-                        else if (c2 >= 'A' && c2 <= 'F')
-                                c |= c2 - 'A' + 10;
-                        else {
-                                mpi_clear(val);
-                                return 1;
-                        }
-                        a <<= 8;
-                        a |= c;
-                }
-                i = 0;
-
-                val->d[j - 1] = a;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(mpi_fromstr);
-
-/****************
  * Return an allocated buffer with the MPI (msb first).
  * NBYTES receives the length of this buffer. Caller must free the
  * return string (This function does return a 0 byte buffer with NBYTES
diff --git a/lib/mpi/mpih-div.c b/lib/mpi/mpih-div.c
index cde1aaec18da..c57d1d46295e 100644
--- a/lib/mpi/mpih-div.c
+++ b/lib/mpi/mpih-div.c
@@ -37,159 +37,6 @@
 #define UDIV_TIME UMUL_TIME
 #endif
 
-/* FIXME: We should be using invert_limb (or invert_normalized_limb)
- * here (not udiv_qrnnd).
- */
-
-mpi_limb_t
-mpihelp_mod_1(mpi_ptr_t dividend_ptr, mpi_size_t dividend_size,
-              mpi_limb_t divisor_limb)
-{
-        mpi_size_t i;
-        mpi_limb_t n1, n0, r;
-        int dummy;
-
-        /* Botch: Should this be handled at all?  Rely on callers?  */
-        if (!dividend_size)
-                return 0;
-
-        /* If multiplication is much faster than division, and the
-         * dividend is large, pre-invert the divisor, and use
-         * only multiplications in the inner loop.
-         *
-         * This test should be read:
-         *   Does it ever help to use udiv_qrnnd_preinv?
-         *     && Does what we save compensate for the inversion overhead?
-         */
-        if (UDIV_TIME > (2 * UMUL_TIME + 6)
-            && (UDIV_TIME - (2 * UMUL_TIME + 6)) * dividend_size > UDIV_TIME) {
-                int normalization_steps;
-
-                count_leading_zeros(normalization_steps, divisor_limb);
-                if (normalization_steps) {
-                        mpi_limb_t divisor_limb_inverted;
-
-                        divisor_limb <<= normalization_steps;
-
-                        /* Compute (2**2N - 2**N * DIVISOR_LIMB) / DIVISOR_LIMB.  The
-                         * result is a (N+1)-bit approximation to 1/DIVISOR_LIMB, with the
-                         * most significant bit (with weight 2**N) implicit.
-                         *
-                         * Special case for DIVISOR_LIMB == 100...000.
-                         */
-                        if (!(divisor_limb << 1))
-                                divisor_limb_inverted = ~(mpi_limb_t) 0;
-                        else
-                                udiv_qrnnd(divisor_limb_inverted, dummy,
-                                           -divisor_limb, 0, divisor_limb);
-
-                        n1 = dividend_ptr[dividend_size - 1];
-                        r = n1 >> (BITS_PER_MPI_LIMB - normalization_steps);
-
-                        /* Possible optimization:
-                         * if (r == 0
-                         * && divisor_limb > ((n1 << normalization_steps)
-                         *                 | (dividend_ptr[dividend_size - 2] >> ...)))
-                         * ...one division less...
-                         */
-                        for (i = dividend_size - 2; i >= 0; i--) {
-                                n0 = dividend_ptr[i];
-                                UDIV_QRNND_PREINV(dummy, r, r,
-                                                  ((n1 << normalization_steps)
-                                                   | (n0 >>
-                                                      (BITS_PER_MPI_LIMB -
-                                                       normalization_steps))),
-                                                  divisor_limb,
-                                                  divisor_limb_inverted);
-                                n1 = n0;
-                        }
-                        UDIV_QRNND_PREINV(dummy, r, r,
-                                          n1 << normalization_steps,
-                                          divisor_limb, divisor_limb_inverted);
-                        return r >> normalization_steps;
-                } else {
-                        mpi_limb_t divisor_limb_inverted;
-
-                        /* Compute (2**2N - 2**N * DIVISOR_LIMB) / DIVISOR_LIMB.  The
-                         * result is a (N+1)-bit approximation to 1/DIVISOR_LIMB, with the
-                         * most significant bit (with weight 2**N) implicit.
-                         *
-                         * Special case for DIVISOR_LIMB == 100...000.
-                         */
-                        if (!(divisor_limb << 1))
-                                divisor_limb_inverted = ~(mpi_limb_t) 0;
-                        else
-                                udiv_qrnnd(divisor_limb_inverted, dummy,
-                                           -divisor_limb, 0, divisor_limb);
-
-                        i = dividend_size - 1;
-                        r = dividend_ptr[i];
-
-                        if (r >= divisor_limb)
-                                r = 0;
-                        else
-                                i--;
-
-                        for (; i >= 0; i--) {
-                                n0 = dividend_ptr[i];
-                                UDIV_QRNND_PREINV(dummy, r, r,
-                                                  n0, divisor_limb,
-                                                  divisor_limb_inverted);
-                        }
-                        return r;
-                }
-        } else {
-                if (UDIV_NEEDS_NORMALIZATION) {
-                        int normalization_steps;
-
-                        count_leading_zeros(normalization_steps, divisor_limb);
-                        if (normalization_steps) {
-                                divisor_limb <<= normalization_steps;
-
-                                n1 = dividend_ptr[dividend_size - 1];
-                                r = n1 >> (BITS_PER_MPI_LIMB -
-                                           normalization_steps);
-
-                                /* Possible optimization:
-                                 * if (r == 0
-                                 * && divisor_limb > ((n1 << normalization_steps)
-                                 *                 | (dividend_ptr[dividend_size - 2] >> ...)))
-                                 * ...one division less...
-                                 */
-                                for (i = dividend_size - 2; i >= 0; i--) {
-                                        n0 = dividend_ptr[i];
-                                        udiv_qrnnd(dummy, r, r,
-                                                   ((n1 << normalization_steps)
-                                                    | (n0 >>
-                                                       (BITS_PER_MPI_LIMB -
-                                                        normalization_steps))),
-                                                   divisor_limb);
-                                        n1 = n0;
-                                }
-                                udiv_qrnnd(dummy, r, r,
-                                           n1 << normalization_steps,
-                                           divisor_limb);
-                                return r >> normalization_steps;
-                        }
-                }
-                /* No normalization needed, either because udiv_qrnnd doesn't require
-                 * it, or because DIVISOR_LIMB is already normalized.  */
-                i = dividend_size - 1;
-                r = dividend_ptr[i];
-
-                if (r >= divisor_limb)
-                        r = 0;
-                else
-                        i--;
-
-                for (; i >= 0; i--) {
-                        n0 = dividend_ptr[i];
-                        udiv_qrnnd(dummy, r, r, n0, divisor_limb);
-                }
-                return r;
-        }
-}
-
 /* Divide num (NP/NSIZE) by den (DP/DSIZE) and write
  * the NSIZE-DSIZE least significant quotient limbs at QP
  * and the DSIZE long remainder at NP.  If QEXTRA_LIMBS is
@@ -387,159 +234,3 @@ q_test:
 
         return most_significant_q_limb;
 }
-
-/****************
- * Divide (DIVIDEND_PTR,,DIVIDEND_SIZE) by DIVISOR_LIMB.
- * Write DIVIDEND_SIZE limbs of quotient at QUOT_PTR.
- * Return the single-limb remainder.
- * There are no constraints on the value of the divisor.
- *
- * QUOT_PTR and DIVIDEND_PTR might point to the same limb.
- */
-
-mpi_limb_t
-mpihelp_divmod_1(mpi_ptr_t quot_ptr,
-                 mpi_ptr_t dividend_ptr, mpi_size_t dividend_size,
-                 mpi_limb_t divisor_limb)
-{
-        mpi_size_t i;
-        mpi_limb_t n1, n0, r;
-        int dummy;
-
-        if (!dividend_size)
-                return 0;
-
-        /* If multiplication is much faster than division, and the
-         * dividend is large, pre-invert the divisor, and use
-         * only multiplications in the inner loop.
-         *
-         * This test should be read:
-         * Does it ever help to use udiv_qrnnd_preinv?
-         * && Does what we save compensate for the inversion overhead?
-         */
-        if (UDIV_TIME > (2 * UMUL_TIME + 6)
-            && (UDIV_TIME - (2 * UMUL_TIME + 6)) * dividend_size > UDIV_TIME) {
-                int normalization_steps;
-
-                count_leading_zeros(normalization_steps, divisor_limb);
-                if (normalization_steps) {
-                        mpi_limb_t divisor_limb_inverted;
-
-                        divisor_limb <<= normalization_steps;
-
-                        /* Compute (2**2N - 2**N * DIVISOR_LIMB) / DIVISOR_LIMB.  The
-                         * result is a (N+1)-bit approximation to 1/DIVISOR_LIMB, with the
-                         * most significant bit (with weight 2**N) implicit.
-                         */
-                        /* Special case for DIVISOR_LIMB == 100...000.  */
-                        if (!(divisor_limb << 1))
-                                divisor_limb_inverted = ~(mpi_limb_t) 0;
-                        else
-                                udiv_qrnnd(divisor_limb_inverted, dummy,
-                                           -divisor_limb, 0, divisor_limb);
-
-                        n1 = dividend_ptr[dividend_size - 1];
-                        r = n1 >> (BITS_PER_MPI_LIMB - normalization_steps);
-
-                        /* Possible optimization:
-                         * if (r == 0
-                         * && divisor_limb > ((n1 << normalization_steps)
-                         *                 | (dividend_ptr[dividend_size - 2] >> ...)))
-                         * ...one division less...
-                         */
-                        for (i = dividend_size - 2; i >= 0; i--) {
-                                n0 = dividend_ptr[i];
-                                UDIV_QRNND_PREINV(quot_ptr[i + 1], r, r,
-                                                  ((n1 << normalization_steps)
-                                                   | (n0 >>
-                                                      (BITS_PER_MPI_LIMB -
-                                                       normalization_steps))),
-                                                  divisor_limb,
-                                                  divisor_limb_inverted);
-                                n1 = n0;
-                        }
-                        UDIV_QRNND_PREINV(quot_ptr[0], r, r,
-                                          n1 << normalization_steps,
-                                          divisor_limb, divisor_limb_inverted);
-                        return r >> normalization_steps;
-                } else {
-                        mpi_limb_t divisor_limb_inverted;
-
-                        /* Compute (2**2N - 2**N * DIVISOR_LIMB) / DIVISOR_LIMB.  The
-                         * result is a (N+1)-bit approximation to 1/DIVISOR_LIMB, with the
-                         * most significant bit (with weight 2**N) implicit.
-                         */
-                        /* Special case for DIVISOR_LIMB == 100...000.  */
-                        if (!(divisor_limb << 1))
-                                divisor_limb_inverted = ~(mpi_limb_t) 0;
-                        else
-                                udiv_qrnnd(divisor_limb_inverted, dummy,
-                                           -divisor_limb, 0, divisor_limb);
-
-                        i = dividend_size - 1;
-                        r = dividend_ptr[i];
-
-                        if (r >= divisor_limb)
-                                r = 0;
-                        else
-                                quot_ptr[i--] = 0;
-
-                        for (; i >= 0; i--) {
-                                n0 = dividend_ptr[i];
-                                UDIV_QRNND_PREINV(quot_ptr[i], r, r,
-                                                  n0, divisor_limb,
-                                                  divisor_limb_inverted);
-                        }
-                        return r;
-                }
-        } else {
-                if (UDIV_NEEDS_NORMALIZATION) {
-                        int normalization_steps;
-
-                        count_leading_zeros(normalization_steps, divisor_limb);
-                        if (normalization_steps) {
-                                divisor_limb <<= normalization_steps;
-
-                                n1 = dividend_ptr[dividend_size - 1];
-                                r = n1 >> (BITS_PER_MPI_LIMB -
-                                           normalization_steps);
-
-                                /* Possible optimization:
-                                 * if (r == 0
-                                 * && divisor_limb > ((n1 << normalization_steps)
-                                 *                 | (dividend_ptr[dividend_size - 2] >> ...)))
-                                 * ...one division less...
-                                 */
-                                for (i = dividend_size - 2; i >= 0; i--) {
-                                        n0 = dividend_ptr[i];
-                                        udiv_qrnnd(quot_ptr[i + 1], r, r,
-                                                   ((n1 << normalization_steps)
-                                                    | (n0 >>
-                                                       (BITS_PER_MPI_LIMB -
-                                                        normalization_steps))),
-                                                   divisor_limb);
-                                        n1 = n0;
-                                }
-                                udiv_qrnnd(quot_ptr[0], r, r,
-                                           n1 << normalization_steps,
-                                           divisor_limb);
-                                return r >> normalization_steps;
-                        }
-                }
-                /* No normalization needed, either because udiv_qrnnd doesn't require
-                 * it, or because DIVISOR_LIMB is already normalized.  */
-                i = dividend_size - 1;
-                r = dividend_ptr[i];
-
-                if (r >= divisor_limb)
-                        r = 0;
-                else
-                        quot_ptr[i--] = 0;
-
-                for (; i >= 0; i--) {
-                        n0 = dividend_ptr[i];
-                        udiv_qrnnd(quot_ptr[i], r, r, n0, divisor_limb);
-                }
-                return r;
-        }
-}
diff --git a/lib/mpi/mpih-mul.c b/lib/mpi/mpih-mul.c
index c69c5eef233b..7c841719fdfb 100644
--- a/lib/mpi/mpih-mul.c
+++ b/lib/mpi/mpih-mul.c
@@ -330,36 +330,6 @@ mpih_sqr_n(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size, mpi_ptr_t tspace)
         }
 }
 
-/* This should be made into an inline function in gmp.h.  */
-int mpihelp_mul_n(mpi_ptr_t prodp, mpi_ptr_t up, mpi_ptr_t vp, mpi_size_t size)
-{
-        if (up == vp) {
-                if (size < KARATSUBA_THRESHOLD)
-                        mpih_sqr_n_basecase(prodp, up, size);
-                else {
-                        mpi_ptr_t tspace;
-                        tspace = mpi_alloc_limb_space(2 * size);
-                        if (!tspace)
-                                return -ENOMEM;
-                        mpih_sqr_n(prodp, up, size, tspace);
-                        mpi_free_limb_space(tspace);
-                }
-        } else {
-                if (size < KARATSUBA_THRESHOLD)
-                        mul_n_basecase(prodp, up, vp, size);
-                else {
-                        mpi_ptr_t tspace;
-                        tspace = mpi_alloc_limb_space(2 * size);
-                        if (!tspace)
-                                return -ENOMEM;
-                        mul_n(prodp, up, vp, size, tspace);
-                        mpi_free_limb_space(tspace);
-                }
-        }
-
-        return 0;
-}
-
 int
 mpihelp_mul_karatsuba_case(mpi_ptr_t prodp,
                            mpi_ptr_t up, mpi_size_t usize,
diff --git a/lib/mpi/mpiutil.c b/lib/mpi/mpiutil.c
index 26e4ed31e256..657979f71bef 100644
--- a/lib/mpi/mpiutil.c
+++ b/lib/mpi/mpiutil.c
@@ -106,13 +106,6 @@ int mpi_resize(MPI a, unsigned nlimbs)
         return 0;
 }
 
-void mpi_clear(MPI a)
-{
-        a->nlimbs = 0;
-        a->nbits = 0;
-        a->flags = 0;
-}
-
 void mpi_free(MPI a)
 {
         if (!a)
@@ -128,84 +121,3 @@ void mpi_free(MPI a)
         kfree(a);
 }
 EXPORT_SYMBOL_GPL(mpi_free);
-
-/****************
- * Note: This copy function should not interpret the MPI
- *       but copy it transparently.
- */
-int mpi_copy(MPI *copied, const MPI a)
-{
-        size_t i;
-        MPI b;
-
-        *copied = NULL;
-
-        if (a) {
-                b = mpi_alloc(a->nlimbs);
-                if (!b)
-                        return -ENOMEM;
-
-                b->nlimbs = a->nlimbs;
-                b->sign = a->sign;
-                b->flags = a->flags;
-                b->nbits = a->nbits;
-
-                for (i = 0; i < b->nlimbs; i++)
-                        b->d[i] = a->d[i];
-
-                *copied = b;
-        }
-
-        return 0;
-}
-
-int mpi_set(MPI w, const MPI u)
-{
-        mpi_ptr_t wp, up;
-        mpi_size_t usize = u->nlimbs;
-        int usign = u->sign;
-
-        if (RESIZE_IF_NEEDED(w, (size_t) usize) < 0)
-                return -ENOMEM;
-
-        wp = w->d;
-        up = u->d;
-        MPN_COPY(wp, up, usize);
-        w->nlimbs = usize;
-        w->nbits = u->nbits;
-        w->flags = u->flags;
-        w->sign = usign;
-        return 0;
-}
-
-int mpi_set_ui(MPI w, unsigned long u)
-{
-        if (RESIZE_IF_NEEDED(w, 1) < 0)
-                return -ENOMEM;
-        w->d[0] = u;
-        w->nlimbs = u ? 1 : 0;
-        w->sign = 0;
-        w->nbits = 0;
-        w->flags = 0;
-        return 0;
-}
-
-MPI mpi_alloc_set_ui(unsigned long u)
-{
-        MPI w = mpi_alloc(1);
-        if (!w)
-                return w;
-        w->d[0] = u;
-        w->nlimbs = u ? 1 : 0;
-        w->sign = 0;
-        return w;
-}
-
-void mpi_swap(MPI a, MPI b)
-{
-        struct gcry_mpi tmp;
-
-        tmp = *a;
-        *a = *b;
-        *b = tmp;
-}
diff --git a/lib/notifier-error-inject.c b/lib/notifier-error-inject.c
new file mode 100644
index 000000000000..44b92cb6224f
--- /dev/null
+++ b/lib/notifier-error-inject.c
@@ -0,0 +1,112 @@
+#include <linux/module.h>
+
+#include "notifier-error-inject.h"
+
+static int debugfs_errno_set(void *data, u64 val)
+{
+        *(int *)data = clamp_t(int, val, -MAX_ERRNO, 0);
+        return 0;
+}
+
+static int debugfs_errno_get(void *data, u64 *val)
+{
+        *val = *(int *)data;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_errno, debugfs_errno_get, debugfs_errno_set,
+                        "%lld\n");
+
+static struct dentry *debugfs_create_errno(const char *name, mode_t mode,
+                                struct dentry *parent, int *value)
+{
+        return debugfs_create_file(name, mode, parent, value, &fops_errno);
+}
+
+static int notifier_err_inject_callback(struct notifier_block *nb,
+                                unsigned long val, void *p)
+{
+        int err = 0;
+        struct notifier_err_inject *err_inject =
+                container_of(nb, struct notifier_err_inject, nb);
+        struct notifier_err_inject_action *action;
+
+        for (action = err_inject->actions; action->name; action++) {
+                if (action->val == val) {
+                        err = action->error;
+                        break;
+                }
+        }
+        if (err)
+                pr_info("Injecting error (%d) to %s\n", err, action->name);
+
+        return notifier_from_errno(err);
+}
+
+struct dentry *notifier_err_inject_dir;
+EXPORT_SYMBOL_GPL(notifier_err_inject_dir);
+
+struct dentry *notifier_err_inject_init(const char *name, struct dentry *parent,
+                        struct notifier_err_inject *err_inject, int priority)
+{
+        struct notifier_err_inject_action *action;
+        mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
+        struct dentry *dir;
+        struct dentry *actions_dir;
+
+        err_inject->nb.notifier_call = notifier_err_inject_callback;
+        err_inject->nb.priority = priority;
+
+        dir = debugfs_create_dir(name, parent);
+        if (!dir)
+                return ERR_PTR(-ENOMEM);
+
+        actions_dir = debugfs_create_dir("actions", dir);
+        if (!actions_dir)
+                goto fail;
+
+        for (action = err_inject->actions; action->name; action++) {
+                struct dentry *action_dir;
+
+                action_dir = debugfs_create_dir(action->name, actions_dir);
+                if (!action_dir)
+                        goto fail;
+
+                /*
+                 * Create debugfs r/w file containing action->error. If
+                 * notifier call chain is called with action->val, it will
+                 * fail with the error code
+                 */
+                if (!debugfs_create_errno("error", mode, action_dir,
+                                        &action->error))
+                        goto fail;
+        }
+        return dir;
+fail:
+        debugfs_remove_recursive(dir);
+        return ERR_PTR(-ENOMEM);
+}
+EXPORT_SYMBOL_GPL(notifier_err_inject_init);
+
+static int __init err_inject_init(void)
+{
+        notifier_err_inject_dir =
+                debugfs_create_dir("notifier-error-inject", NULL);
+
+        if (!notifier_err_inject_dir)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void __exit err_inject_exit(void)
+{
+        debugfs_remove_recursive(notifier_err_inject_dir);
+}
+
+module_init(err_inject_init);
+module_exit(err_inject_exit);
+
+MODULE_DESCRIPTION("Notifier error injection module");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
diff --git a/lib/notifier-error-inject.h b/lib/notifier-error-inject.h
new file mode 100644
index 000000000000..99b3b6fc470b
--- /dev/null
+++ b/lib/notifier-error-inject.h
@@ -0,0 +1,24 @@
+#include <linux/atomic.h>
+#include <linux/debugfs.h>
+#include <linux/notifier.h>
+
+struct notifier_err_inject_action {
+        unsigned long val;
+        int error;
+        const char *name;
+};
+
+#define NOTIFIER_ERR_INJECT_ACTION(action)      \
+        .name = #action, .val = (action),
+
+struct notifier_err_inject {
+        struct notifier_block nb;
+        struct notifier_err_inject_action actions[];
+        /* The last slot must be terminated with zero sentinel */
+};
+
+extern struct dentry *notifier_err_inject_dir;
+
+extern struct dentry *notifier_err_inject_init(const char *name,
+                struct dentry *parent, struct notifier_err_inject *err_inject,
+                int priority);
diff --git a/lib/pSeries-reconfig-notifier-error-inject.c b/lib/pSeries-reconfig-notifier-error-inject.c
new file mode 100644
index 000000000000..7f7c98dcd5c4
--- /dev/null
+++ b/lib/pSeries-reconfig-notifier-error-inject.c
@@ -0,0 +1,51 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <asm/pSeries_reconfig.h>
+
+#include "notifier-error-inject.h"
+
+static int priority;
+module_param(priority, int, 0);
+MODULE_PARM_DESC(priority, "specify pSeries reconfig notifier priority");
+
+static struct notifier_err_inject reconfig_err_inject = {
+        .actions = {
+                { NOTIFIER_ERR_INJECT_ACTION(PSERIES_RECONFIG_ADD) },
+                { NOTIFIER_ERR_INJECT_ACTION(PSERIES_RECONFIG_REMOVE) },
+                { NOTIFIER_ERR_INJECT_ACTION(PSERIES_DRCONF_MEM_ADD) },
+                { NOTIFIER_ERR_INJECT_ACTION(PSERIES_DRCONF_MEM_REMOVE) },
+                {}
+        }
+};
+
+static struct dentry *dir;
+
+static int err_inject_init(void)
+{
+        int err;
+
+        dir = notifier_err_inject_init("pSeries-reconfig",
+                notifier_err_inject_dir, &reconfig_err_inject, priority);
+        if (IS_ERR(dir))
+                return PTR_ERR(dir);
+
+        err = pSeries_reconfig_notifier_register(&reconfig_err_inject.nb);
+        if (err)
+                debugfs_remove_recursive(dir);
+
+        return err;
+}
+
+static void err_inject_exit(void)
+{
+        pSeries_reconfig_notifier_unregister(&reconfig_err_inject.nb);
+        debugfs_remove_recursive(dir);
+}
+
+module_init(err_inject_init);
+module_exit(err_inject_exit);
+
+MODULE_DESCRIPTION("pSeries reconfig notifier error injection module");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
diff --git a/lib/pm-notifier-error-inject.c b/lib/pm-notifier-error-inject.c
new file mode 100644
index 000000000000..c094b2dedc23
--- /dev/null
+++ b/lib/pm-notifier-error-inject.c
@@ -0,0 +1,49 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/suspend.h>
+
+#include "notifier-error-inject.h"
+
+static int priority;
+module_param(priority, int, 0);
+MODULE_PARM_DESC(priority, "specify PM notifier priority");
+
+static struct notifier_err_inject pm_notifier_err_inject = {
+        .actions = {
+                { NOTIFIER_ERR_INJECT_ACTION(PM_HIBERNATION_PREPARE) },
+                { NOTIFIER_ERR_INJECT_ACTION(PM_SUSPEND_PREPARE) },
+                { NOTIFIER_ERR_INJECT_ACTION(PM_RESTORE_PREPARE) },
+                {}
+        }
+};
+
+static struct dentry *dir;
+
+static int err_inject_init(void)
+{
+        int err;
+
+        dir = notifier_err_inject_init("pm", notifier_err_inject_dir,
+                                        &pm_notifier_err_inject, priority);
+        if (IS_ERR(dir))
+                return PTR_ERR(dir);
+
+        err = register_pm_notifier(&pm_notifier_err_inject.nb);
+        if (err)
+                debugfs_remove_recursive(dir);
+
+        return err;
+}
+
+static void err_inject_exit(void)
+{
+        unregister_pm_notifier(&pm_notifier_err_inject.nb);
+        debugfs_remove_recursive(dir);
+}
+
+module_init(err_inject_init);
+module_exit(err_inject_exit);
+
+MODULE_DESCRIPTION("PM notifier error injection module");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 86516f5588e3..e7964296fd50 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -73,11 +73,24 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH + 1] __read_mostly;
 static struct kmem_cache *radix_tree_node_cachep;
 
 /*
+ * The radix tree is variable-height, so an insert operation not only has
+ * to build the branch to its corresponding item, it also has to build the
+ * branch to existing items if the size has to be increased (by
+ * radix_tree_extend).
+ *
+ * The worst case is a zero height tree with just a single item at index 0,
+ * and then inserting an item at index ULONG_MAX. This requires 2 new branches
+ * of RADIX_TREE_MAX_PATH size to be created, with only the root node shared.
+ * Hence:
+ */
+#define RADIX_TREE_PRELOAD_SIZE (RADIX_TREE_MAX_PATH * 2 - 1)
+
+/*
  * Per-cpu pool of preloaded nodes
  */
 struct radix_tree_preload {
         int nr;
-        struct radix_tree_node *nodes[RADIX_TREE_MAX_PATH];
+        struct radix_tree_node *nodes[RADIX_TREE_PRELOAD_SIZE];
 };
 static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };
 
@@ -673,6 +686,9 @@ void **radix_tree_next_chunk(struct radix_tree_root *root,
          * during iterating; it can be zero only at the beginning.
          * And we cannot overflow iter->next_index in a single step,
          * because RADIX_TREE_MAP_SHIFT < BITS_PER_LONG.
+         *
+         * This condition also used by radix_tree_next_slot() to stop
+         * contiguous iterating, and forbid swithing to the next chunk.
          */
         index = iter->next_index;
         if (!index && iter->index)
diff --git a/lib/raid6/Makefile b/lib/raid6/Makefile
index 8a38102770f3..de06dfe165b8 100644
--- a/lib/raid6/Makefile
+++ b/lib/raid6/Makefile
@@ -1,6 +1,6 @@
 obj-$(CONFIG_RAID6_PQ)  += raid6_pq.o
 
-raid6_pq-y      += algos.o recov.o tables.o int1.o int2.o int4.o \
+raid6_pq-y      += algos.o recov.o recov_ssse3.o tables.o int1.o int2.o int4.o \
                    int8.o int16.o int32.o altivec1.o altivec2.o altivec4.o \
                    altivec8.o mmx.o sse1.o sse2.o
 hostprogs-y     += mktables
diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c
index 8b02f60ffc86..589f5f50ad2e 100644
--- a/lib/raid6/algos.c
+++ b/lib/raid6/algos.c
@@ -17,11 +17,11 @@
  */
 
 #include <linux/raid/pq.h>
-#include <linux/module.h>
 #ifndef __KERNEL__
 #include <sys/mman.h>
 #include <stdio.h>
 #else
+#include <linux/module.h>
 #include <linux/gfp.h>
 #if !RAID6_USE_EMPTY_ZERO_PAGE
 /* In .bss so it's zeroed */
@@ -34,10 +34,6 @@ struct raid6_calls raid6_call;
 EXPORT_SYMBOL_GPL(raid6_call);
 
 const struct raid6_calls * const raid6_algos[] = {
-        &raid6_intx1,
-        &raid6_intx2,
-        &raid6_intx4,
-        &raid6_intx8,
 #if defined(__ia64__)
         &raid6_intx16,
         &raid6_intx32,
@@ -61,6 +57,24 @@ const struct raid6_calls * const raid6_algos[] = {
         &raid6_altivec4,
         &raid6_altivec8,
 #endif
+        &raid6_intx1,
+        &raid6_intx2,
+        &raid6_intx4,
+        &raid6_intx8,
+        NULL
+};
+
+void (*raid6_2data_recov)(int, size_t, int, int, void **);
+EXPORT_SYMBOL_GPL(raid6_2data_recov);
+
+void (*raid6_datap_recov)(int, size_t, int, void **);
+EXPORT_SYMBOL_GPL(raid6_datap_recov);
+
+const struct raid6_recov_calls *const raid6_recov_algos[] = {
+#if (defined(__i386__) || defined(__x86_64__)) && !defined(__arch_um__)
+        &raid6_recov_ssse3,
+#endif
+        &raid6_recov_intx1,
         NULL
 };
 
@@ -72,59 +86,55 @@ const struct raid6_calls * const raid6_algos[] = {
 #define time_before(x, y) ((x) < (y))
 #endif
 
-/* Try to pick the best algorithm */
-/* This code uses the gfmul table as convenient data set to abuse */
-
-int __init raid6_select_algo(void)
+static inline const struct raid6_recov_calls *raid6_choose_recov(void)
 {
-        const struct raid6_calls * const * algo;
-        const struct raid6_calls * best;
-        char *syndromes;
-        void *dptrs[(65536/PAGE_SIZE)+2];
-        int i, disks;
-        unsigned long perf, bestperf;
-        int bestprefer;
-        unsigned long j0, j1;
+        const struct raid6_recov_calls *const *algo;
+        const struct raid6_recov_calls *best;
 
-        disks = (65536/PAGE_SIZE)+2;
-        for ( i = 0 ; i < disks-2 ; i++ ) {
-                dptrs[i] = ((char *)raid6_gfmul) + PAGE_SIZE*i;
-        }
+        for (best = NULL, algo = raid6_recov_algos; *algo; algo++)
+                if (!best || (*algo)->priority > best->priority)
+                        if (!(*algo)->valid || (*algo)->valid())
+                                best = *algo;
 
-        /* Normal code - use a 2-page allocation to avoid D$ conflict */
-        syndromes = (void *) __get_free_pages(GFP_KERNEL, 1);
+        if (best) {
+                raid6_2data_recov = best->data2;
+                raid6_datap_recov = best->datap;
 
-        if ( !syndromes ) {
-                printk("raid6: Yikes!  No memory available.\n");
-                return -ENOMEM;
-        }
+                printk("raid6: using %s recovery algorithm\n", best->name);
+        } else
+                printk("raid6: Yikes! No recovery algorithm found!\n");
 
-        dptrs[disks-2] = syndromes;
-        dptrs[disks-1] = syndromes + PAGE_SIZE;
+        return best;
+}
+
+static inline const struct raid6_calls *raid6_choose_gen(
+        void *(*const dptrs)[(65536/PAGE_SIZE)+2], const int disks)
+{
+        unsigned long perf, bestperf, j0, j1;
+        const struct raid6_calls *const *algo;
+        const struct raid6_calls *best;
 
-        bestperf = 0;  bestprefer = 0;  best = NULL;
+        for (bestperf = 0, best = NULL, algo = raid6_algos; *algo; algo++) {
+                if (!best || (*algo)->prefer >= best->prefer) {
+                        if ((*algo)->valid && !(*algo)->valid())
+                                continue;
 
-        for ( algo = raid6_algos ; *algo ; algo++ ) {
-                if ( !(*algo)->valid || (*algo)->valid() ) {
                         perf = 0;
 
                         preempt_disable();
                         j0 = jiffies;
-                        while ( (j1 = jiffies) == j0 )
+                        while ((j1 = jiffies) == j0)
                                 cpu_relax();
                         while (time_before(jiffies,
                                             j1 + (1<<RAID6_TIME_JIFFIES_LG2))) {
-                                (*algo)->gen_syndrome(disks, PAGE_SIZE, dptrs);
+                                (*algo)->gen_syndrome(disks, PAGE_SIZE, *dptrs);
                                 perf++;
                         }
                         preempt_enable();
 
-                        if ( (*algo)->prefer > bestprefer ||
-                             ((*algo)->prefer == bestprefer &&
-                              perf > bestperf) ) {
-                                best = *algo;
-                                bestprefer = best->prefer;
+                        if (perf > bestperf) {
                                 bestperf = perf;
+                                best = *algo;
                         }
                         printk("raid6: %-8s %5ld MB/s\n", (*algo)->name,
                                (perf*HZ) >> (20-16+RAID6_TIME_JIFFIES_LG2));
@@ -139,9 +149,46 @@ int __init raid6_select_algo(void)
         } else
                 printk("raid6: Yikes!  No algorithm found!\n");
 
+        return best;
+}
+
+
+/* Try to pick the best algorithm */
+/* This code uses the gfmul table as convenient data set to abuse */
+
+int __init raid6_select_algo(void)
+{
+        const int disks = (65536/PAGE_SIZE)+2;
+
+        const struct raid6_calls *gen_best;
+        const struct raid6_recov_calls *rec_best;
+        char *syndromes;
+        void *dptrs[(65536/PAGE_SIZE)+2];
+        int i;
+
+        for (i = 0; i < disks-2; i++)
+                dptrs[i] = ((char *)raid6_gfmul) + PAGE_SIZE*i;
+
+        /* Normal code - use a 2-page allocation to avoid D$ conflict */
+        syndromes = (void *) __get_free_pages(GFP_KERNEL, 1);
+
+        if (!syndromes) {
+                printk("raid6: Yikes!  No memory available.\n");
+                return -ENOMEM;
+        }
+
+        dptrs[disks-2] = syndromes;
+        dptrs[disks-1] = syndromes + PAGE_SIZE;
+
+        /* select raid gen_syndrome function */
+        gen_best = raid6_choose_gen(&dptrs, disks);
+
+        /* select raid recover functions */
+        rec_best = raid6_choose_recov();
+
         free_pages((unsigned long)syndromes, 1);
 
-        return best ? 0 : -EINVAL;
+        return gen_best && rec_best ? 0 : -EINVAL;
 }
 
 static void raid6_exit(void)
diff --git a/lib/raid6/mktables.c b/lib/raid6/mktables.c
index 8a3780902cec..39787db588b0 100644
--- a/lib/raid6/mktables.c
+++ b/lib/raid6/mktables.c
@@ -81,6 +81,31 @@ int main(int argc, char *argv[])
         printf("EXPORT_SYMBOL(raid6_gfmul);\n");
         printf("#endif\n");
 
+        /* Compute vector multiplication table */
+        printf("\nconst u8  __attribute__((aligned(256)))\n"
+                "raid6_vgfmul[256][32] =\n"
+                "{\n");
+        for (i = 0; i < 256; i++) {
+                printf("\t{\n");
+                for (j = 0; j < 16; j += 8) {
+                        printf("\t\t");
+                        for (k = 0; k < 8; k++)
+                                printf("0x%02x,%c", gfmul(i, j + k),
+                                       (k == 7) ? '\n' : ' ');
+                }
+                for (j = 0; j < 16; j += 8) {
+                        printf("\t\t");
+                        for (k = 0; k < 8; k++)
+                                printf("0x%02x,%c", gfmul(i, (j + k) << 4),
+                                       (k == 7) ? '\n' : ' ');
+                }
+                printf("\t},\n");
+        }
+        printf("};\n");
+        printf("#ifdef __KERNEL__\n");
+        printf("EXPORT_SYMBOL(raid6_vgfmul);\n");
+        printf("#endif\n");
+
         /* Compute power-of-2 table (exponent) */
         v = 1;
         printf("\nconst u8 __attribute__((aligned(256)))\n"
diff --git a/lib/raid6/recov.c b/lib/raid6/recov.c
index fe275d7b6b36..a95bccb8497d 100644
--- a/lib/raid6/recov.c
+++ b/lib/raid6/recov.c
@@ -22,8 +22,8 @@
 #include <linux/raid/pq.h>
 
 /* Recover two failed data blocks. */
-void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
-                       void **ptrs)
+static void raid6_2data_recov_intx1(int disks, size_t bytes, int faila,
+                int failb, void **ptrs)
 {
         u8 *p, *q, *dp, *dq;
         u8 px, qx, db;
@@ -64,10 +64,10 @@ void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
                 p++; q++;
         }
 }
-EXPORT_SYMBOL_GPL(raid6_2data_recov);
 
 /* Recover failure of one data block plus the P block */
-void raid6_datap_recov(int disks, size_t bytes, int faila, void **ptrs)
+static void raid6_datap_recov_intx1(int disks, size_t bytes, int faila,
+                void **ptrs)
 {
         u8 *p, *q, *dq;
         const u8 *qmul;         /* Q multiplier table */
@@ -96,7 +96,15 @@ void raid6_datap_recov(int disks, size_t bytes, int faila, void **ptrs)
                 q++; dq++;
         }
 }
-EXPORT_SYMBOL_GPL(raid6_datap_recov);
+
+
+const struct raid6_recov_calls raid6_recov_intx1 = {
+        .data2 = raid6_2data_recov_intx1,
+        .datap = raid6_datap_recov_intx1,
+        .valid = NULL,
+        .name = "intx1",
+        .priority = 0,
+};
 
 #ifndef __KERNEL__
 /* Testing only */
diff --git a/lib/raid6/recov_ssse3.c b/lib/raid6/recov_ssse3.c
new file mode 100644
index 000000000000..ecb710c0b4d9
--- /dev/null
+++ b/lib/raid6/recov_ssse3.c
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2012 Intel Corporation
+ *
+ * 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
+ * of the License.
+ */
+
+#if (defined(__i386__) || defined(__x86_64__)) && !defined(__arch_um__)
+
+#include <linux/raid/pq.h>
+#include "x86.h"
+
+static int raid6_has_ssse3(void)
+{
+        return boot_cpu_has(X86_FEATURE_XMM) &&
+                boot_cpu_has(X86_FEATURE_XMM2) &&
+                boot_cpu_has(X86_FEATURE_SSSE3);
+}
+
+static void raid6_2data_recov_ssse3(int disks, size_t bytes, int faila,
+                int failb, void **ptrs)
+{
+        u8 *p, *q, *dp, *dq;
+        const u8 *pbmul;        /* P multiplier table for B data */
+        const u8 *qmul;         /* Q multiplier table (for both) */
+        static const u8 __aligned(16) x0f[16] = {
+                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f};
+
+        p = (u8 *)ptrs[disks-2];
+        q = (u8 *)ptrs[disks-1];
+
+        /* Compute syndrome with zero for the missing data pages
+           Use the dead data pages as temporary storage for
+           delta p and delta q */
+        dp = (u8 *)ptrs[faila];
+        ptrs[faila] = (void *)raid6_empty_zero_page;
+        ptrs[disks-2] = dp;
+        dq = (u8 *)ptrs[failb];
+        ptrs[failb] = (void *)raid6_empty_zero_page;
+        ptrs[disks-1] = dq;
+
+        raid6_call.gen_syndrome(disks, bytes, ptrs);
+
+        /* Restore pointer table */
+        ptrs[faila]   = dp;
+        ptrs[failb]   = dq;
+        ptrs[disks-2] = p;
+        ptrs[disks-1] = q;
+
+        /* Now, pick the proper data tables */
+        pbmul = raid6_vgfmul[raid6_gfexi[failb-faila]];
+        qmul  = raid6_vgfmul[raid6_gfinv[raid6_gfexp[faila] ^
+                raid6_gfexp[failb]]];
+
+        kernel_fpu_begin();
+
+        asm volatile("movdqa %0,%%xmm7" : : "m" (x0f[0]));
+
+#ifdef CONFIG_X86_64
+        asm volatile("movdqa %0,%%xmm6" : : "m" (qmul[0]));
+        asm volatile("movdqa %0,%%xmm14" : : "m" (pbmul[0]));
+        asm volatile("movdqa %0,%%xmm15" : : "m" (pbmul[16]));
+#endif
+
+        /* Now do it... */
+        while (bytes) {
+#ifdef CONFIG_X86_64
+                /* xmm6, xmm14, xmm15 */
+
+                asm volatile("movdqa %0,%%xmm1" : : "m" (q[0]));
+                asm volatile("movdqa %0,%%xmm9" : : "m" (q[16]));
+                asm volatile("movdqa %0,%%xmm0" : : "m" (p[0]));
+                asm volatile("movdqa %0,%%xmm8" : : "m" (p[16]));
+                asm volatile("pxor   %0,%%xmm1" : : "m" (dq[0]));
+                asm volatile("pxor   %0,%%xmm9" : : "m" (dq[16]));
+                asm volatile("pxor   %0,%%xmm0" : : "m" (dp[0]));
+                asm volatile("pxor   %0,%%xmm8" : : "m" (dp[16]));
+
+                /* xmm0/8 = px */
+
+                asm volatile("movdqa %xmm6,%xmm4");
+                asm volatile("movdqa %0,%%xmm5" : : "m" (qmul[16]));
+                asm volatile("movdqa %xmm6,%xmm12");
+                asm volatile("movdqa %xmm5,%xmm13");
+                asm volatile("movdqa %xmm1,%xmm3");
+                asm volatile("movdqa %xmm9,%xmm11");
+                asm volatile("movdqa %xmm0,%xmm2"); /* xmm2/10 = px */
+                asm volatile("movdqa %xmm8,%xmm10");
+                asm volatile("psraw  $4,%xmm1");
+                asm volatile("psraw  $4,%xmm9");
+                asm volatile("pand   %xmm7,%xmm3");
+                asm volatile("pand   %xmm7,%xmm11");
+                asm volatile("pand   %xmm7,%xmm1");
+                asm volatile("pand   %xmm7,%xmm9");
+                asm volatile("pshufb %xmm3,%xmm4");
+                asm volatile("pshufb %xmm11,%xmm12");
+                asm volatile("pshufb %xmm1,%xmm5");
+                asm volatile("pshufb %xmm9,%xmm13");
+                asm volatile("pxor   %xmm4,%xmm5");
+                asm volatile("pxor   %xmm12,%xmm13");
+
+                /* xmm5/13 = qx */
+
+                asm volatile("movdqa %xmm14,%xmm4");
+                asm volatile("movdqa %xmm15,%xmm1");
+                asm volatile("movdqa %xmm14,%xmm12");
+                asm volatile("movdqa %xmm15,%xmm9");
+                asm volatile("movdqa %xmm2,%xmm3");
+                asm volatile("movdqa %xmm10,%xmm11");
+                asm volatile("psraw  $4,%xmm2");
+                asm volatile("psraw  $4,%xmm10");
+                asm volatile("pand   %xmm7,%xmm3");
+                asm volatile("pand   %xmm7,%xmm11");
+                asm volatile("pand   %xmm7,%xmm2");
+                asm volatile("pand   %xmm7,%xmm10");
+                asm volatile("pshufb %xmm3,%xmm4");
+                asm volatile("pshufb %xmm11,%xmm12");
+                asm volatile("pshufb %xmm2,%xmm1");
+                asm volatile("pshufb %xmm10,%xmm9");
+                asm volatile("pxor   %xmm4,%xmm1");
+                asm volatile("pxor   %xmm12,%xmm9");
+
+                /* xmm1/9 = pbmul[px] */
+                asm volatile("pxor   %xmm5,%xmm1");
+                asm volatile("pxor   %xmm13,%xmm9");
+                /* xmm1/9 = db = DQ */
+                asm volatile("movdqa %%xmm1,%0" : "=m" (dq[0]));
+                asm volatile("movdqa %%xmm9,%0" : "=m" (dq[16]));
+
+                asm volatile("pxor   %xmm1,%xmm0");
+                asm volatile("pxor   %xmm9,%xmm8");
+                asm volatile("movdqa %%xmm0,%0" : "=m" (dp[0]));
+                asm volatile("movdqa %%xmm8,%0" : "=m" (dp[16]));
+
+                bytes -= 32;
+                p += 32;
+                q += 32;
+                dp += 32;
+                dq += 32;
+#else
+                asm volatile("movdqa %0,%%xmm1" : : "m" (*q));
+                asm volatile("movdqa %0,%%xmm0" : : "m" (*p));
+                asm volatile("pxor   %0,%%xmm1" : : "m" (*dq));
+                asm volatile("pxor   %0,%%xmm0" : : "m" (*dp));
+
+                /* 1 = dq ^ q
+                 * 0 = dp ^ p
+                 */
+                asm volatile("movdqa %0,%%xmm4" : : "m" (qmul[0]));
+                asm volatile("movdqa %0,%%xmm5" : : "m" (qmul[16]));
+
+                asm volatile("movdqa %xmm1,%xmm3");
+                asm volatile("psraw  $4,%xmm1");
+                asm volatile("pand   %xmm7,%xmm3");
+                asm volatile("pand   %xmm7,%xmm1");
+                asm volatile("pshufb %xmm3,%xmm4");
+                asm volatile("pshufb %xmm1,%xmm5");
+                asm volatile("pxor   %xmm4,%xmm5");
+
+                asm volatile("movdqa %xmm0,%xmm2"); /* xmm2 = px */
+
+                /* xmm5 = qx */
+
+                asm volatile("movdqa %0,%%xmm4" : : "m" (pbmul[0]));
+                asm volatile("movdqa %0,%%xmm1" : : "m" (pbmul[16]));
+                asm volatile("movdqa %xmm2,%xmm3");
+                asm volatile("psraw  $4,%xmm2");
+                asm volatile("pand   %xmm7,%xmm3");
+                asm volatile("pand   %xmm7,%xmm2");
+                asm volatile("pshufb %xmm3,%xmm4");
+                asm volatile("pshufb %xmm2,%xmm1");
+                asm volatile("pxor   %xmm4,%xmm1");
+
+                /* xmm1 = pbmul[px] */
+                asm volatile("pxor   %xmm5,%xmm1");
+                /* xmm1 = db = DQ */
+                asm volatile("movdqa %%xmm1,%0" : "=m" (*dq));
+
+                asm volatile("pxor   %xmm1,%xmm0");
+                asm volatile("movdqa %%xmm0,%0" : "=m" (*dp));
+
+                bytes -= 16;
+                p += 16;
+                q += 16;
+                dp += 16;
+                dq += 16;
+#endif
+        }
+
+        kernel_fpu_end();
+}
+
+
+static void raid6_datap_recov_ssse3(int disks, size_t bytes, int faila,
+                void **ptrs)
+{
+        u8 *p, *q, *dq;
+        const u8 *qmul;         /* Q multiplier table */
+        static const u8 __aligned(16) x0f[16] = {
+                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f};
+
+        p = (u8 *)ptrs[disks-2];
+        q = (u8 *)ptrs[disks-1];
+
+        /* Compute syndrome with zero for the missing data page
+           Use the dead data page as temporary storage for delta q */
+        dq = (u8 *)ptrs[faila];
+        ptrs[faila] = (void *)raid6_empty_zero_page;
+        ptrs[disks-1] = dq;
+
+        raid6_call.gen_syndrome(disks, bytes, ptrs);
+
+        /* Restore pointer table */
+        ptrs[faila]   = dq;
+        ptrs[disks-1] = q;
+
+        /* Now, pick the proper data tables */
+        qmul  = raid6_vgfmul[raid6_gfinv[raid6_gfexp[faila]]];
+
+        kernel_fpu_begin();
+
+        asm volatile("movdqa %0, %%xmm7" : : "m" (x0f[0]));
+
+        while (bytes) {
+#ifdef CONFIG_X86_64
+                asm volatile("movdqa %0, %%xmm3" : : "m" (dq[0]));
+                asm volatile("movdqa %0, %%xmm4" : : "m" (dq[16]));
+                asm volatile("pxor %0, %%xmm3" : : "m" (q[0]));
+                asm volatile("movdqa %0, %%xmm0" : : "m" (qmul[0]));
+
+                /* xmm3 = q[0] ^ dq[0] */
+
+                asm volatile("pxor %0, %%xmm4" : : "m" (q[16]));
+                asm volatile("movdqa %0, %%xmm1" : : "m" (qmul[16]));
+
+                /* xmm4 = q[16] ^ dq[16] */
+
+                asm volatile("movdqa %xmm3, %xmm6");
+                asm volatile("movdqa %xmm4, %xmm8");
+
+                /* xmm4 = xmm8 = q[16] ^ dq[16] */
+
+                asm volatile("psraw $4, %xmm3");
+                asm volatile("pand %xmm7, %xmm6");
+                asm volatile("pand %xmm7, %xmm3");
+                asm volatile("pshufb %xmm6, %xmm0");
+                asm volatile("pshufb %xmm3, %xmm1");
+                asm volatile("movdqa %0, %%xmm10" : : "m" (qmul[0]));
+                asm volatile("pxor %xmm0, %xmm1");
+                asm volatile("movdqa %0, %%xmm11" : : "m" (qmul[16]));
+
+                /* xmm1 = qmul[q[0] ^ dq[0]] */
+
+                asm volatile("psraw $4, %xmm4");
+                asm volatile("pand %xmm7, %xmm8");
+                asm volatile("pand %xmm7, %xmm4");
+                asm volatile("pshufb %xmm8, %xmm10");
+                asm volatile("pshufb %xmm4, %xmm11");
+                asm volatile("movdqa %0, %%xmm2" : : "m" (p[0]));
+                asm volatile("pxor %xmm10, %xmm11");
+                asm volatile("movdqa %0, %%xmm12" : : "m" (p[16]));
+
+                /* xmm11 = qmul[q[16] ^ dq[16]] */
+
+                asm volatile("pxor %xmm1, %xmm2");
+
+                /* xmm2 = p[0] ^ qmul[q[0] ^ dq[0]] */
+
+                asm volatile("pxor %xmm11, %xmm12");
+
+                /* xmm12 = p[16] ^ qmul[q[16] ^ dq[16]] */
+
+                asm volatile("movdqa %%xmm1, %0" : "=m" (dq[0]));
+                asm volatile("movdqa %%xmm11, %0" : "=m" (dq[16]));
+
+                asm volatile("movdqa %%xmm2, %0" : "=m" (p[0]));
+                asm volatile("movdqa %%xmm12, %0" : "=m" (p[16]));
+
+                bytes -= 32;
+                p += 32;
+                q += 32;
+                dq += 32;
+
+#else
+                asm volatile("movdqa %0, %%xmm3" : : "m" (dq[0]));
+                asm volatile("movdqa %0, %%xmm0" : : "m" (qmul[0]));
+                asm volatile("pxor %0, %%xmm3" : : "m" (q[0]));
+                asm volatile("movdqa %0, %%xmm1" : : "m" (qmul[16]));
+
+                /* xmm3 = *q ^ *dq */
+
+                asm volatile("movdqa %xmm3, %xmm6");
+                asm volatile("movdqa %0, %%xmm2" : : "m" (p[0]));
+                asm volatile("psraw $4, %xmm3");
+                asm volatile("pand %xmm7, %xmm6");
+                asm volatile("pand %xmm7, %xmm3");
+                asm volatile("pshufb %xmm6, %xmm0");
+                asm volatile("pshufb %xmm3, %xmm1");
+                asm volatile("pxor %xmm0, %xmm1");
+
+                /* xmm1 = qmul[*q ^ *dq */
+
+                asm volatile("pxor %xmm1, %xmm2");
+
+                /* xmm2 = *p ^ qmul[*q ^ *dq] */
+
+                asm volatile("movdqa %%xmm1, %0" : "=m" (dq[0]));
+                asm volatile("movdqa %%xmm2, %0" : "=m" (p[0]));
+
+                bytes -= 16;
+                p += 16;
+                q += 16;
+                dq += 16;
+#endif
+        }
+
+        kernel_fpu_end();
+}
+
+const struct raid6_recov_calls raid6_recov_ssse3 = {
+        .data2 = raid6_2data_recov_ssse3,
+        .datap = raid6_datap_recov_ssse3,
+        .valid = raid6_has_ssse3,
+#ifdef CONFIG_X86_64
+        .name = "ssse3x2",
+#else
+        .name = "ssse3x1",
+#endif
+        .priority = 1,
+};
+
+#endif
diff --git a/lib/raid6/test/Makefile b/lib/raid6/test/Makefile
index aa651697b6dc..c76151d94764 100644
--- a/lib/raid6/test/Makefile
+++ b/lib/raid6/test/Makefile
@@ -23,7 +23,7 @@ RANLIB	 = ranlib
 all:    raid6.a raid6test
 
 raid6.a: int1.o int2.o int4.o int8.o int16.o int32.o mmx.o sse1.o sse2.o \
-         altivec1.o altivec2.o altivec4.o altivec8.o recov.o algos.o \
+         altivec1.o altivec2.o altivec4.o altivec8.o recov.o recov_ssse3.o algos.o \
          tables.o
          rm -f $@
          $(AR) cq $@ $^
diff --git a/lib/raid6/test/test.c b/lib/raid6/test/test.c
index 7a930318b17d..5a485b7a7d3c 100644
--- a/lib/raid6/test/test.c
+++ b/lib/raid6/test/test.c
@@ -90,25 +90,35 @@ static int test_disks(int i, int j)
 int main(int argc, char *argv[])
 {
         const struct raid6_calls *const *algo;
+        const struct raid6_recov_calls *const *ra;
         int i, j;
         int err = 0;
 
         makedata();
 
-        for (algo = raid6_algos; *algo; algo++) {
-                if (!(*algo)->valid || (*algo)->valid()) {
-                        raid6_call = **algo;
+        for (ra = raid6_recov_algos; *ra; ra++) {
+                if ((*ra)->valid  && !(*ra)->valid())
+                        continue;
+                raid6_2data_recov = (*ra)->data2;
+                raid6_datap_recov = (*ra)->datap;
 
-                        /* Nuke syndromes */
-                        memset(data[NDISKS-2], 0xee, 2*PAGE_SIZE);
+                printf("using recovery %s\n", (*ra)->name);
 
-                        /* Generate assumed good syndrome */
-                        raid6_call.gen_syndrome(NDISKS, PAGE_SIZE,
-                                                (void **)&dataptrs);
+                for (algo = raid6_algos; *algo; algo++) {
+                        if (!(*algo)->valid || (*algo)->valid()) {
+                                raid6_call = **algo;
 
-                        for (i = 0; i < NDISKS-1; i++)
-                                for (j = i+1; j < NDISKS; j++)
-                                        err += test_disks(i, j);
+                                /* Nuke syndromes */
+                                memset(data[NDISKS-2], 0xee, 2*PAGE_SIZE);
+
+                                /* Generate assumed good syndrome */
+                                raid6_call.gen_syndrome(NDISKS, PAGE_SIZE,
+                                                        (void **)&dataptrs);
+
+                                for (i = 0; i < NDISKS-1; i++)
+                                        for (j = i+1; j < NDISKS; j++)
+                                                err += test_disks(i, j);
+                        }
                 }
                 printf("\n");
         }
diff --git a/lib/raid6/x86.h b/lib/raid6/x86.h
index cb2a8c91c886..d55d63232c55 100644
--- a/lib/raid6/x86.h
+++ b/lib/raid6/x86.h
@@ -35,24 +35,29 @@ static inline void kernel_fpu_end(void)
 {
 }
 
+#define __aligned(x) __attribute__((aligned(x)))
+
 #define X86_FEATURE_MMX         (0*32+23) /* Multimedia Extensions */
 #define X86_FEATURE_FXSR        (0*32+24) /* FXSAVE and FXRSTOR instructions
                                            * (fast save and restore) */
 #define X86_FEATURE_XMM         (0*32+25) /* Streaming SIMD Extensions */
 #define X86_FEATURE_XMM2        (0*32+26) /* Streaming SIMD Extensions-2 */
+#define X86_FEATURE_XMM3        (4*32+ 0) /* "pni" SSE-3 */
+#define X86_FEATURE_SSSE3       (4*32+ 9) /* Supplemental SSE-3 */
+#define X86_FEATURE_AVX (4*32+28) /* Advanced Vector Extensions */
 #define X86_FEATURE_MMXEXT      (1*32+22) /* AMD MMX extensions */
 
 /* Should work well enough on modern CPUs for testing */
 static inline int boot_cpu_has(int flag)
 {
-        u32 eax = (flag >> 5) ? 0x80000001 : 1;
-        u32 edx;
+        u32 eax = (flag & 0x20) ? 0x80000001 : 1;
+        u32 ecx, edx;
 
         asm volatile("cpuid"
-                     : "+a" (eax), "=d" (edx)
-                     : : "ecx", "ebx");
+                     : "+a" (eax), "=d" (edx), "=c" (ecx)
+                     : : "ebx");
 
-        return (edx >> (flag & 31)) & 1;
+        return ((flag & 0x80 ? ecx : edx) >> (flag & 31)) & 1;
 }
 
 #endif /* ndef __KERNEL__ */
diff --git a/lib/rational.c b/lib/rational.c
index d326da3976f5..f0aa21c2a762 100644
--- a/lib/rational.c
+++ b/lib/rational.c
@@ -1,7 +1,7 @@
 /*
  * rational fractions
  *
- * Copyright (C) 2009 emlix GmbH, Oskar Schirmer <os@emlix.com>
+ * Copyright (C) 2009 emlix GmbH, Oskar Schirmer <oskar@scara.com>
  *
  * helper functions when coping with rational numbers
  */
diff --git a/lib/scatterlist.c b/lib/scatterlist.c
index 6096e89bee55..fadae774a20c 100644
--- a/lib/scatterlist.c
+++ b/lib/scatterlist.c
@@ -279,14 +279,6 @@ int __sg_alloc_table(struct sg_table *table, unsigned int nents,
                 if (!left)
                         sg_mark_end(&sg[sg_size - 1]);
 
-                /*
-                 * only really needed for mempool backed sg allocations (like
-                 * SCSI), a possible improvement here would be to pass the
-                 * table pointer into the allocator and let that clear these
-                 * flags
-                 */
-                gfp_mask &= ~__GFP_WAIT;
-                gfp_mask |= __GFP_HIGH;
                 prv = sg;
         } while (left);
 
@@ -319,6 +311,70 @@ int sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask)
 EXPORT_SYMBOL(sg_alloc_table);
 
 /**
+ * sg_alloc_table_from_pages - Allocate and initialize an sg table from
+ *                             an array of pages
+ * @sgt:        The sg table header to use
+ * @pages:      Pointer to an array of page pointers
+ * @n_pages:    Number of pages in the pages array
+ * @offset:     Offset from start of the first page to the start of a buffer
+ * @size:       Number of valid bytes in the buffer (after offset)
+ * @gfp_mask:   GFP allocation mask
+ *
+ *  Description:
+ *    Allocate and initialize an sg table from a list of pages. Contiguous
+ *    ranges of the pages are squashed into a single scatterlist node. A user
+ *    may provide an offset at a start and a size of valid data in a buffer
+ *    specified by the page array. The returned sg table is released by
+ *    sg_free_table.
+ *
+ * Returns:
+ *   0 on success, negative error on failure
+ */
+int sg_alloc_table_from_pages(struct sg_table *sgt,
+        struct page **pages, unsigned int n_pages,
+        unsigned long offset, unsigned long size,
+        gfp_t gfp_mask)
+{
+        unsigned int chunks;
+        unsigned int i;
+        unsigned int cur_page;
+        int ret;
+        struct scatterlist *s;
+
+        /* compute number of contiguous chunks */
+        chunks = 1;
+        for (i = 1; i < n_pages; ++i)
+                if (page_to_pfn(pages[i]) != page_to_pfn(pages[i - 1]) + 1)
+                        ++chunks;
+
+        ret = sg_alloc_table(sgt, chunks, gfp_mask);
+        if (unlikely(ret))
+                return ret;
+
+        /* merging chunks and putting them into the scatterlist */
+        cur_page = 0;
+        for_each_sg(sgt->sgl, s, sgt->orig_nents, i) {
+                unsigned long chunk_size;
+                unsigned int j;
+
+                /* look for the end of the current chunk */
+                for (j = cur_page + 1; j < n_pages; ++j)
+                        if (page_to_pfn(pages[j]) !=
+                            page_to_pfn(pages[j - 1]) + 1)
+                                break;
+
+                chunk_size = ((j - cur_page) << PAGE_SHIFT) - offset;
+                sg_set_page(s, pages[cur_page], min(size, chunk_size), offset);
+                size -= chunk_size;
+                offset = 0;
+                cur_page = j;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(sg_alloc_table_from_pages);
+
+/**
  * sg_miter_start - start mapping iteration over a sg list
  * @miter: sg mapping iter to be started
  * @sgl: sg list to iterate over
diff --git a/lib/spinlock_debug.c b/lib/spinlock_debug.c
index 525d160d44f0..eb10578ae055 100644
--- a/lib/spinlock_debug.c
+++ b/lib/spinlock_debug.c
@@ -58,7 +58,7 @@ static void spin_dump(raw_spinlock_t *lock, const char *msg)
         printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
                 msg, raw_smp_processor_id(),
                 current->comm, task_pid_nr(current));
-        printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, "
+        printk(KERN_EMERG " lock: %pS, .magic: %08x, .owner: %s/%d, "
                         ".owner_cpu: %d\n",
                 lock, lock->magic,
                 owner ? owner->comm : "<none>",
@@ -118,7 +118,7 @@ static void __spin_lock_debug(raw_spinlock_t *lock)
                 /* lockup suspected: */
                 if (print_once) {
                         print_once = 0;
-                        spin_dump(lock, "lockup");
+                        spin_dump(lock, "lockup suspected");
 #ifdef CONFIG_SMP
                         trigger_all_cpu_backtrace();
 #endif
diff --git a/lib/stmp_device.c b/lib/stmp_device.c
new file mode 100644
index 000000000000..8ac9bcc4289a
--- /dev/null
+++ b/lib/stmp_device.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 1999 ARM Limited
+ * Copyright (C) 2000 Deep Blue Solutions Ltd
+ * Copyright 2006-2007,2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
+ * Copyright 2009 Ilya Yanok, Emcraft Systems Ltd, yanok@emcraft.com
+ * Copyright (C) 2011 Wolfram Sang, Pengutronix e.K.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/io.h>
+#include <linux/errno.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/stmp_device.h>
+
+#define STMP_MODULE_CLKGATE     (1 << 30)
+#define STMP_MODULE_SFTRST      (1 << 31)
+
+/*
+ * Clear the bit and poll it cleared.  This is usually called with
+ * a reset address and mask being either SFTRST(bit 31) or CLKGATE
+ * (bit 30).
+ */
+static int stmp_clear_poll_bit(void __iomem *addr, u32 mask)
+{
+        int timeout = 0x400;
+
+        writel(mask, addr + STMP_OFFSET_REG_CLR);
+        udelay(1);
+        while ((readl(addr) & mask) && --timeout)
+                /* nothing */;
+
+        return !timeout;
+}
+
+int stmp_reset_block(void __iomem *reset_addr)
+{
+        int ret;
+        int timeout = 0x400;
+
+        /* clear and poll SFTRST */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_SFTRST);
+        if (unlikely(ret))
+                goto error;
+
+        /* clear CLKGATE */
+        writel(STMP_MODULE_CLKGATE, reset_addr + STMP_OFFSET_REG_CLR);
+
+        /* set SFTRST to reset the block */
+        writel(STMP_MODULE_SFTRST, reset_addr + STMP_OFFSET_REG_SET);
+        udelay(1);
+
+        /* poll CLKGATE becoming set */
+        while ((!(readl(reset_addr) & STMP_MODULE_CLKGATE)) && --timeout)
+                /* nothing */;
+        if (unlikely(!timeout))
+                goto error;
+
+        /* clear and poll SFTRST */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_SFTRST);
+        if (unlikely(ret))
+                goto error;
+
+        /* clear and poll CLKGATE */
+        ret = stmp_clear_poll_bit(reset_addr, STMP_MODULE_CLKGATE);
+        if (unlikely(ret))
+                goto error;
+
+        return 0;
+
+error:
+        pr_err("%s(%p): module reset timeout\n", __func__, reset_addr);
+        return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(stmp_reset_block);
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index dd4ece372699..1cffc223bff5 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -23,15 +23,15 @@
 int string_get_size(u64 size, const enum string_size_units units,
                     char *buf, int len)
 {
-        const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
+        static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
                                    "EB", "ZB", "YB", NULL};
-        const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
+        static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
                                  "EiB", "ZiB", "YiB", NULL };
-        const char **units_str[] = {
+        static const char **units_str[] = {
                 [STRING_UNITS_10] =  units_10,
                 [STRING_UNITS_2] = units_2,
         };
-        const unsigned int divisor[] = {
+        static const unsigned int divisor[] = {
                 [STRING_UNITS_10] = 1000,
                 [STRING_UNITS_2] = 1024,
         };
diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c
new file mode 100644
index 000000000000..bb2b201d6ad0
--- /dev/null
+++ b/lib/strncpy_from_user.c
@@ -0,0 +1,113 @@
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+
+#include <asm/byteorder.h>
+#include <asm/word-at-a-time.h>
+
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+#define IS_UNALIGNED(src, dst)  0
+#else
+#define IS_UNALIGNED(src, dst)  \
+        (((long) dst | (long) src) & (sizeof(long) - 1))
+#endif
+
+/*
+ * Do a strncpy, return length of string without final '\0'.
+ * 'count' is the user-supplied count (return 'count' if we
+ * hit it), 'max' is the address space maximum (and we return
+ * -EFAULT if we hit it).
+ */
+static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)
+{
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+        long res = 0;
+
+        /*
+         * Truncate 'max' to the user-specified limit, so that
+         * we only have one limit we need to check in the loop
+         */
+        if (max > count)
+                max = count;
+
+        if (IS_UNALIGNED(src, dst))
+                goto byte_at_a_time;
+
+        while (max >= sizeof(unsigned long)) {
+                unsigned long c, data;
+
+                /* Fall back to byte-at-a-time if we get a page fault */
+                if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
+                        break;
+                *(unsigned long *)(dst+res) = c;
+                if (has_zero(c, &data, &constants)) {
+                        data = prep_zero_mask(c, data, &constants);
+                        data = create_zero_mask(data);
+                        return res + find_zero(data);
+                }
+                res += sizeof(unsigned long);
+                max -= sizeof(unsigned long);
+        }
+
+byte_at_a_time:
+        while (max) {
+                char c;
+
+                if (unlikely(__get_user(c,src+res)))
+                        return -EFAULT;
+                dst[res] = c;
+                if (!c)
+                        return res;
+                res++;
+                max--;
+        }
+
+        /*
+         * Uhhuh. We hit 'max'. But was that the user-specified maximum
+         * too? If so, that's ok - we got as much as the user asked for.
+         */
+        if (res >= count)
+                return res;
+
+        /*
+         * Nope: we hit the address space limit, and we still had more
+         * characters the caller would have wanted. That's an EFAULT.
+         */
+        return -EFAULT;
+}
+
+/**
+ * strncpy_from_user: - Copy a NUL terminated string from userspace.
+ * @dst:   Destination address, in kernel space.  This buffer must be at
+ *         least @count bytes long.
+ * @src:   Source address, in user space.
+ * @count: Maximum number of bytes to copy, including the trailing NUL.
+ *
+ * Copies a NUL-terminated string from userspace to kernel space.
+ *
+ * On success, returns the length of the string (not including the trailing
+ * NUL).
+ *
+ * If access to userspace fails, returns -EFAULT (some data may have been
+ * copied).
+ *
+ * If @count is smaller than the length of the string, copies @count bytes
+ * and returns @count.
+ */
+long strncpy_from_user(char *dst, const char __user *src, long count)
+{
+        unsigned long max_addr, src_addr;
+
+        if (unlikely(count <= 0))
+                return 0;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)src;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strncpy_from_user(dst, src, count, max);
+        }
+        return -EFAULT;
+}
+EXPORT_SYMBOL(strncpy_from_user);
diff --git a/lib/strnlen_user.c b/lib/strnlen_user.c
new file mode 100644
index 000000000000..a28df5206d95
--- /dev/null
+++ b/lib/strnlen_user.c
@@ -0,0 +1,138 @@
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <linux/uaccess.h>
+
+#include <asm/word-at-a-time.h>
+
+/* Set bits in the first 'n' bytes when loaded from memory */
+#ifdef __LITTLE_ENDIAN
+#  define aligned_byte_mask(n) ((1ul << 8*(n))-1)
+#else
+#  define aligned_byte_mask(n) (~0xfful << (BITS_PER_LONG - 8 - 8*(n)))
+#endif
+
+/*
+ * Do a strnlen, return length of string *with* final '\0'.
+ * 'count' is the user-supplied count, while 'max' is the
+ * address space maximum.
+ *
+ * Return 0 for exceptions (which includes hitting the address
+ * space maximum), or 'count+1' if hitting the user-supplied
+ * maximum count.
+ *
+ * NOTE! We can sometimes overshoot the user-supplied maximum
+ * if it fits in a aligned 'long'. The caller needs to check
+ * the return value against "> max".
+ */
+static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)
+{
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+        long align, res = 0;
+        unsigned long c;
+
+        /*
+         * Truncate 'max' to the user-specified limit, so that
+         * we only have one limit we need to check in the loop
+         */
+        if (max > count)
+                max = count;
+
+        /*
+         * Do everything aligned. But that means that we
+         * need to also expand the maximum..
+         */
+        align = (sizeof(long) - 1) & (unsigned long)src;
+        src -= align;
+        max += align;
+
+        if (unlikely(__get_user(c,(unsigned long __user *)src)))
+                return 0;
+        c |= aligned_byte_mask(align);
+
+        for (;;) {
+                unsigned long data;
+                if (has_zero(c, &data, &constants)) {
+                        data = prep_zero_mask(c, data, &constants);
+                        data = create_zero_mask(data);
+                        return res + find_zero(data) + 1 - align;
+                }
+                res += sizeof(unsigned long);
+                if (unlikely(max < sizeof(unsigned long)))
+                        break;
+                max -= sizeof(unsigned long);
+                if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
+                        return 0;
+        }
+        res -= align;
+
+        /*
+         * Uhhuh. We hit 'max'. But was that the user-specified maximum
+         * too? If so, return the marker for "too long".
+         */
+        if (res >= count)
+                return count+1;
+
+        /*
+         * Nope: we hit the address space limit, and we still had more
+         * characters the caller would have wanted. That's 0.
+         */
+        return 0;
+}
+
+/**
+ * strnlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ * @count: Maximum count (including NUL character)
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * If the string is too long, returns 'count+1'.
+ * On exception (or invalid count), returns 0.
+ */
+long strnlen_user(const char __user *str, long count)
+{
+        unsigned long max_addr, src_addr;
+
+        if (unlikely(count <= 0))
+                return 0;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, count, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strnlen_user);
+
+/**
+ * strlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * On exception, returns 0.
+ *
+ * If there is a limit on the length of a valid string, you may wish to
+ * consider using strnlen_user() instead.
+ */
+long strlen_user(const char __user *str)
+{
+        unsigned long max_addr, src_addr;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, ~0ul, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strlen_user);
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 414f46ed1dcd..45bc1f83a5ad 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -130,11 +130,9 @@ void swiotlb_print_info(void)
         pstart = virt_to_phys(io_tlb_start);
         pend = virt_to_phys(io_tlb_end);
 
-        printk(KERN_INFO "Placing %luMB software IO TLB between %p - %p\n",
-               bytes >> 20, io_tlb_start, io_tlb_end);
-        printk(KERN_INFO "software IO TLB at phys %#llx - %#llx\n",
-               (unsigned long long)pstart,
-               (unsigned long long)pend);
+        printk(KERN_INFO "software IO TLB [mem %#010llx-%#010llx] (%luMB) mapped at [%p-%p]\n",
+               (unsigned long long)pstart, (unsigned long long)pend - 1,
+               bytes >> 20, io_tlb_start, io_tlb_end - 1);
 }
 
 void __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose)
diff --git a/lib/test-kstrtox.c b/lib/test-kstrtox.c
index d55769d63cb8..bea3f3fa3f02 100644
--- a/lib/test-kstrtox.c
+++ b/lib/test-kstrtox.c
@@ -11,7 +11,7 @@ struct test_fail {
 };
 
 #define DEFINE_TEST_FAIL(test)  \
-        const struct test_fail test[] __initdata
+        const struct test_fail test[] __initconst
 
 #define DECLARE_TEST_OK(type, test_type)        \
         test_type {                             \
@@ -21,7 +21,7 @@ struct test_fail {
         }
 
 #define DEFINE_TEST_OK(type, test)      \
-        const type test[] __initdata
+        const type test[] __initconst
 
 #define TEST_FAIL(fn, type, fmt, test)                                  \
 {                                                                       \
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index abbabec9720a..0e337541f005 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -112,106 +112,199 @@ int skip_atoi(const char **s)
 /* Decimal conversion is by far the most typical, and is used
  * for /proc and /sys data. This directly impacts e.g. top performance
  * with many processes running. We optimize it for speed
- * using code from
- * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
- * (with permission from the author, Douglas W. Jones). */
+ * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
+ * (with permission from the author, Douglas W. Jones).
+ */
 
-/* Formats correctly any integer in [0,99999].
- * Outputs from one to five digits depending on input.
- * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
+#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
+/* Formats correctly any integer in [0, 999999999] */
 static noinline_for_stack
-char *put_dec_trunc(char *buf, unsigned q)
+char *put_dec_full9(char *buf, unsigned q)
 {
-        unsigned d3, d2, d1, d0;
-        d1 = (q>>4) & 0xf;
-        d2 = (q>>8) & 0xf;
-        d3 = (q>>12);
-
-        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
-        q = (d0 * 0xcd) >> 11;
-        d0 = d0 - 10*q;
-        *buf++ = d0 + '0'; /* least significant digit */
-        d1 = q + 9*d3 + 5*d2 + d1;
-        if (d1 != 0) {
-                q = (d1 * 0xcd) >> 11;
-                d1 = d1 - 10*q;
-                *buf++ = d1 + '0'; /* next digit */
-
-                d2 = q + 2*d2;
-                if ((d2 != 0) || (d3 != 0)) {
-                        q = (d2 * 0xd) >> 7;
-                        d2 = d2 - 10*q;
-                        *buf++ = d2 + '0'; /* next digit */
-
-                        d3 = q + 4*d3;
-                        if (d3 != 0) {
-                                q = (d3 * 0xcd) >> 11;
-                                d3 = d3 - 10*q;
-                                *buf++ = d3 + '0';  /* next digit */
-                                if (q != 0)
-                                        *buf++ = q + '0'; /* most sign. digit */
-                        }
-                }
-        }
+        unsigned r;
 
+        /*
+         * Possible ways to approx. divide by 10
+         * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
+         * (x * 0xcccd) >> 19     x <      81920 (x < 262149 when 64-bit mul)
+         * (x * 0x6667) >> 18     x <      43699
+         * (x * 0x3334) >> 17     x <      16389
+         * (x * 0x199a) >> 16     x <      16389
+         * (x * 0x0ccd) >> 15     x <      16389
+         * (x * 0x0667) >> 14     x <       2739
+         * (x * 0x0334) >> 13     x <       1029
+         * (x * 0x019a) >> 12     x <       1029
+         * (x * 0x00cd) >> 11     x <       1029 shorter code than * 0x67 (on i386)
+         * (x * 0x0067) >> 10     x <        179
+         * (x * 0x0034) >>  9     x <         69 same
+         * (x * 0x001a) >>  8     x <         69 same
+         * (x * 0x000d) >>  7     x <         69 same, shortest code (on i386)
+         * (x * 0x0007) >>  6     x <         19
+         * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
+         */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 1 */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 2 */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 3 */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 4 */
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 5 */
+        /* Now value is under 10000, can avoid 64-bit multiply */
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0'; /* 6 */
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0'; /* 7 */
+        q      = (r * 0xcd) >> 11;
+        *buf++ = (r - 10 * q) + '0'; /* 8 */
+        *buf++ = q + '0'; /* 9 */
         return buf;
 }
-/* Same with if's removed. Always emits five digits */
+#endif
+
+/* Similar to above but do not pad with zeros.
+ * Code can be easily arranged to print 9 digits too, but our callers
+ * always call put_dec_full9() instead when the number has 9 decimal digits.
+ */
 static noinline_for_stack
-char *put_dec_full(char *buf, unsigned q)
+char *put_dec_trunc8(char *buf, unsigned r)
 {
-        /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
-        /* but anyway, gcc produces better code with full-sized ints */
-        unsigned d3, d2, d1, d0;
-        d1 = (q>>4) & 0xf;
-        d2 = (q>>8) & 0xf;
-        d3 = (q>>12);
+        unsigned q;
+
+        /* Copy of previous function's body with added early returns */
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 2 */
+        if (q == 0)
+                return buf;
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 3 */
+        if (r == 0)
+                return buf;
+        q      = (r * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (r - 10 * q) + '0'; /* 4 */
+        if (q == 0)
+                return buf;
+        r      = (q * (uint64_t)0x1999999a) >> 32;
+        *buf++ = (q - 10 * r) + '0'; /* 5 */
+        if (r == 0)
+                return buf;
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0'; /* 6 */
+        if (q == 0)
+                return buf;
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0'; /* 7 */
+        if (r == 0)
+                return buf;
+        q      = (r * 0xcd) >> 11;
+        *buf++ = (r - 10 * q) + '0'; /* 8 */
+        if (q == 0)
+                return buf;
+        *buf++ = q + '0'; /* 9 */
+        return buf;
+}
 
-        /*
-         * Possible ways to approx. divide by 10
-         * gcc -O2 replaces multiply with shifts and adds
-         * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
-         * (x * 0x67) >> 10:  1100111
-         * (x * 0x34) >> 9:    110100 - same
-         * (x * 0x1a) >> 8:     11010 - same
-         * (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
-         */
-        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
-        q = (d0 * 0xcd) >> 11;
-        d0 = d0 - 10*q;
-        *buf++ = d0 + '0';
-        d1 = q + 9*d3 + 5*d2 + d1;
-                q = (d1 * 0xcd) >> 11;
-                d1 = d1 - 10*q;
-                *buf++ = d1 + '0';
-
-                d2 = q + 2*d2;
-                        q = (d2 * 0xd) >> 7;
-                        d2 = d2 - 10*q;
-                        *buf++ = d2 + '0';
-
-                        d3 = q + 4*d3;
-                                q = (d3 * 0xcd) >> 11; /* - shorter code */
-                                /* q = (d3 * 0x67) >> 10; - would also work */
-                                d3 = d3 - 10*q;
-                                *buf++ = d3 + '0';
-                                        *buf++ = q + '0';
+/* There are two algorithms to print larger numbers.
+ * One is generic: divide by 1000000000 and repeatedly print
+ * groups of (up to) 9 digits. It's conceptually simple,
+ * but requires a (unsigned long long) / 1000000000 division.
+ *
+ * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
+ * manipulates them cleverly and generates groups of 4 decimal digits.
+ * It so happens that it does NOT require long long division.
+ *
+ * If long is > 32 bits, division of 64-bit values is relatively easy,
+ * and we will use the first algorithm.
+ * If long long is > 64 bits (strange architecture with VERY large long long),
+ * second algorithm can't be used, and we again use the first one.
+ *
+ * Else (if long is 32 bits and long long is 64 bits) we use second one.
+ */
 
-        return buf;
+#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
+
+/* First algorithm: generic */
+
+static
+char *put_dec(char *buf, unsigned long long n)
+{
+        if (n >= 100*1000*1000) {
+                while (n >= 1000*1000*1000)
+                        buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
+                if (n >= 100*1000*1000)
+                        return put_dec_full9(buf, n);
+        }
+        return put_dec_trunc8(buf, n);
 }
-/* No inlining helps gcc to use registers better */
+
+#else
+
+/* Second algorithm: valid only for 64-bit long longs */
+
 static noinline_for_stack
-char *put_dec(char *buf, unsigned long long num)
+char *put_dec_full4(char *buf, unsigned q)
 {
-        while (1) {
-                unsigned rem;
-                if (num < 100000)
-                        return put_dec_trunc(buf, num);
-                rem = do_div(num, 100000);
-                buf = put_dec_full(buf, rem);
-        }
+        unsigned r;
+        r      = (q * 0xcccd) >> 19;
+        *buf++ = (q - 10 * r) + '0';
+        q      = (r * 0x199a) >> 16;
+        *buf++ = (r - 10 * q)  + '0';
+        r      = (q * 0xcd) >> 11;
+        *buf++ = (q - 10 * r)  + '0';
+        *buf++ = r + '0';
+        return buf;
 }
 
+/* Based on code by Douglas W. Jones found at
+ * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
+ * (with permission from the author).
+ * Performs no 64-bit division and hence should be fast on 32-bit machines.
+ */
+static
+char *put_dec(char *buf, unsigned long long n)
+{
+        uint32_t d3, d2, d1, q, h;
+
+        if (n < 100*1000*1000)
+                return put_dec_trunc8(buf, n);
+
+        d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
+        h   = (n >> 32);
+        d2  = (h      ) & 0xffff;
+        d3  = (h >> 16); /* implicit "& 0xffff" */
+
+        q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
+
+        buf = put_dec_full4(buf, q % 10000);
+        q   = q / 10000;
+
+        d1  = q + 7671 * d3 + 9496 * d2 + 6 * d1;
+        buf = put_dec_full4(buf, d1 % 10000);
+        q   = d1 / 10000;
+
+        d2  = q + 4749 * d3 + 42 * d2;
+        buf = put_dec_full4(buf, d2 % 10000);
+        q   = d2 / 10000;
+
+        d3  = q + 281 * d3;
+        if (!d3)
+                goto done;
+        buf = put_dec_full4(buf, d3 % 10000);
+        q   = d3 / 10000;
+        if (!q)
+                goto done;
+        buf = put_dec_full4(buf, q);
+ done:
+        while (buf[-1] == '0')
+                --buf;
+
+        return buf;
+}
+
+#endif
+
 /*
  * Convert passed number to decimal string.
  * Returns the length of string.  On buffer overflow, returns 0.
@@ -220,16 +313,22 @@ char *put_dec(char *buf, unsigned long long num)
  */
 int num_to_str(char *buf, int size, unsigned long long num)
 {
-        char tmp[21];           /* Enough for 2^64 in decimal */
+        char tmp[sizeof(num) * 3];
         int idx, len;
 
-        len = put_dec(tmp, num) - tmp;
+        /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
+        if (num <= 9) {
+                tmp[0] = '0' + num;
+                len = 1;
+        } else {
+                len = put_dec(tmp, num) - tmp;
+        }
 
         if (len > size)
                 return 0;
         for (idx = 0; idx < len; ++idx)
                 buf[idx] = tmp[len - idx - 1];
-        return  len;
+        return len;
 }
 
 #define ZEROPAD 1               /* pad with zero */
@@ -284,6 +383,7 @@ char *number(char *buf, char *end, unsigned long long num,
         char locase;
         int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
         int i;
+        bool is_zero = num == 0LL;
 
         /* locase = 0 or 0x20. ORing digits or letters with 'locase'
          * produces same digits or (maybe lowercased) letters */
@@ -305,15 +405,16 @@ char *number(char *buf, char *end, unsigned long long num,
                 }
         }
         if (need_pfx) {
-                spec.field_width--;
                 if (spec.base == 16)
+                        spec.field_width -= 2;
+                else if (!is_zero)
                         spec.field_width--;
         }
 
         /* generate full string in tmp[], in reverse order */
         i = 0;
-        if (num == 0)
-                tmp[i++] = '0';
+        if (num < spec.base)
+                tmp[i++] = digits[num] | locase;
         /* Generic code, for any base:
         else do {
                 tmp[i++] = (digits[do_div(num,base)] | locase);
@@ -353,9 +454,11 @@ char *number(char *buf, char *end, unsigned long long num,
         }
         /* "0x" / "0" prefix */
         if (need_pfx) {
-                if (buf < end)
-                        *buf = '0';
-                ++buf;
+                if (spec.base == 16 || !is_zero) {
+                        if (buf < end)
+                                *buf = '0';
+                        ++buf;
+                }
                 if (spec.base == 16) {
                         if (buf < end)
                                 *buf = ('X' | locase);
@@ -436,7 +539,7 @@ char *symbol_string(char *buf, char *end, void *ptr,
         else if (ext != 'f' && ext != 's')
                 sprint_symbol(sym, value);
         else
-                kallsyms_lookup(value, NULL, NULL, NULL, sym);
+                sprint_symbol_no_offset(sym, value);
 
         return string(buf, end, sym, spec);
 #else
@@ -552,6 +655,50 @@ char *resource_string(char *buf, char *end, struct resource *res,
 }
 
 static noinline_for_stack
+char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
+                 const char *fmt)
+{
+        int i, len = 1;         /* if we pass '%ph[CDN]', field witdh remains
+                                   negative value, fallback to the default */
+        char separator;
+
+        if (spec.field_width == 0)
+                /* nothing to print */
+                return buf;
+
+        if (ZERO_OR_NULL_PTR(addr))
+                /* NULL pointer */
+                return string(buf, end, NULL, spec);
+
+        switch (fmt[1]) {
+        case 'C':
+                separator = ':';
+                break;
+        case 'D':
+                separator = '-';
+                break;
+        case 'N':
+                separator = 0;
+                break;
+        default:
+                separator = ' ';
+                break;
+        }
+
+        if (spec.field_width > 0)
+                len = min_t(int, spec.field_width, 64);
+
+        for (i = 0; i < len && buf < end - 1; i++) {
+                buf = hex_byte_pack(buf, addr[i]);
+
+                if (buf < end && separator && i != len - 1)
+                        *buf++ = separator;
+        }
+
+        return buf;
+}
+
+static noinline_for_stack
 char *mac_address_string(char *buf, char *end, u8 *addr,
                          struct printf_spec spec, const char *fmt)
 {
@@ -559,15 +706,28 @@ char *mac_address_string(char *buf, char *end, u8 *addr,
         char *p = mac_addr;
         int i;
         char separator;
+        bool reversed = false;
 
-        if (fmt[1] == 'F') {            /* FDDI canonical format */
+        switch (fmt[1]) {
+        case 'F':
                 separator = '-';
-        } else {
+                break;
+
+        case 'R':
+                reversed = true;
+                /* fall through */
+
+        default:
                 separator = ':';
+                break;
         }
 
         for (i = 0; i < 6; i++) {
-                p = hex_byte_pack(p, addr[i]);
+                if (reversed)
+                        p = hex_byte_pack(p, addr[5 - i]);
+                else
+                        p = hex_byte_pack(p, addr[i]);
+
                 if (fmt[0] == 'M' && i != 5)
                         *p++ = separator;
         }
@@ -607,7 +767,7 @@ char *ip4_string(char *p, const u8 *addr, const char *fmt)
         }
         for (i = 0; i < 4; i++) {
                 char temp[3];   /* hold each IP quad in reverse order */
-                int digits = put_dec_trunc(temp, addr[index]) - temp;
+                int digits = put_dec_trunc8(temp, addr[index]) - temp;
                 if (leading_zeros) {
                         if (digits < 3)
                                 *p++ = '0';
@@ -830,6 +990,7 @@ int kptr_restrict __read_mostly;
  * - 'm' For a 6-byte MAC address, it prints the hex address without colons
  * - 'MF' For a 6-byte MAC FDDI address, it prints the address
  *       with a dash-separated hex notation
+ * - '[mM]R For a 6-byte MAC address, Reverse order (Bluetooth)
  * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
  *       IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
  *       IPv6 uses colon separated network-order 16 bit hex with leading 0's
@@ -857,6 +1018,13 @@ int kptr_restrict __read_mostly;
  *       correctness of the format string and va_list arguments.
  * - 'K' For a kernel pointer that should be hidden from unprivileged users
  * - 'NF' For a netdev_features_t
+ * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
+ *            a certain separator (' ' by default):
+ *              C colon
+ *              D dash
+ *              N no separator
+ *            The maximum supported length is 64 bytes of the input. Consider
+ *            to use print_hex_dump() for the larger input.
  *
  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
  * function pointers are really function descriptors, which contain a
@@ -866,13 +1034,15 @@ static noinline_for_stack
 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
               struct printf_spec spec)
 {
+        int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
+
         if (!ptr && *fmt != 'K') {
                 /*
                  * Print (null) with the same width as a pointer so it makes
                  * tabular output look nice.
                  */
                 if (spec.field_width == -1)
-                        spec.field_width = 2 * sizeof(void *);
+                        spec.field_width = default_width;
                 return string(buf, end, "(null)", spec);
         }
 
@@ -888,9 +1058,12 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         case 'R':
         case 'r':
                 return resource_string(buf, end, ptr, spec, fmt);
+        case 'h':
+                return hex_string(buf, end, ptr, spec, fmt);
         case 'M':                       /* Colon separated: 00:01:02:03:04:05 */
         case 'm':                       /* Contiguous: 000102030405 */
-                                        /* [mM]F (FDDI, bit reversed) */
+                                        /* [mM]F (FDDI) */
+                                        /* [mM]R (Reverse order; Bluetooth) */
                 return mac_address_string(buf, end, ptr, spec, fmt);
         case 'I':                       /* Formatted IP supported
                                          * 4:   1.2.3.4
@@ -925,9 +1098,10 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
                  * %pK cannot be used in IRQ context because its test
                  * for CAP_SYSLOG would be meaningless.
                  */
-                if (in_irq() || in_serving_softirq() || in_nmi()) {
+                if (kptr_restrict && (in_irq() || in_serving_softirq() ||
+                                      in_nmi())) {
                         if (spec.field_width == -1)
-                                spec.field_width = 2 * sizeof(void *);
+                                spec.field_width = default_width;
                         return string(buf, end, "pK-error", spec);
                 }
                 if (!((kptr_restrict == 0) ||
@@ -944,7 +1118,7 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         }
         spec.flags |= SMALL;
         if (spec.field_width == -1) {
-                spec.field_width = 2 * sizeof(void *);
+                spec.field_width = default_width;
                 spec.flags |= ZEROPAD;
         }
         spec.base = 16;
@@ -1175,8 +1349,12 @@ qualifier:
  * %pI6c print an IPv6 address as specified by RFC 5952
  * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
  *   case.
+ * %*ph[CDN] a variable-length hex string with a separator (supports up to 64
+ *           bytes of the input)
  * %n is ignored
  *
+ * ** Please update Documentation/printk-formats.txt when making changes **
+ *
  * The return value is the number of characters which would
  * be generated for the given input, excluding the trailing
  * '\0', as per ISO C99. If you want to have the exact