15 files changed, 247 insertions, 151 deletions

diff --git a/lib/atomic64.c b/lib/atomic64.c
index a21c12bc727c..e12ae0dd08a8 100644
--- a/lib/atomic64.c
+++ b/lib/atomic64.c
@@ -14,7 +14,7 @@
 #include <linux/spinlock.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * We use a hashed array of spinlocks to provide exclusive access
diff --git a/lib/atomic64_test.c b/lib/atomic64_test.c
index 44524cc8c32a..0c33cde2a1e6 100644
--- a/lib/atomic64_test.c
+++ b/lib/atomic64_test.c
@@ -10,7 +10,7 @@
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define INIT(c) do { atomic64_set(&v, c); r = c; } while (0)
 static __init int test_atomic64(void)
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 3f3b68199d74..37ef4b048795 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -756,7 +756,7 @@ static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)
  *
  * The bit positions 0 through @bits are valid positions in @buf.
  */
-static int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
+int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
 {
         int pos = 0;
 
diff --git a/lib/cpumask.c b/lib/cpumask.c
index 05d6aca7fc19..af3e5817de98 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -30,7 +30,7 @@ int __any_online_cpu(const cpumask_t *mask)
 {
         int cpu;
 
-        for_each_cpu_mask(cpu, *mask) {
+        for_each_cpu(cpu, mask) {
                 if (cpu_online(cpu))
                         break;
         }
@@ -131,7 +131,7 @@ EXPORT_SYMBOL(zalloc_cpumask_var_node);
  */
 bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 {
-        return alloc_cpumask_var_node(mask, flags, numa_node_id());
+        return alloc_cpumask_var_node(mask, flags, NUMA_NO_NODE);
 }
 EXPORT_SYMBOL(alloc_cpumask_var);
 
diff --git a/lib/crc32.c b/lib/crc32.c
index 4855995fcde9..a6e633a48cea 100644
--- a/lib/crc32.c
+++ b/lib/crc32.c
@@ -26,7 +26,7 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <linux/init.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include "crc32defs.h"
 #if CRC_LE_BITS == 8
 # define tole(x) __constant_cpu_to_le32(x)
diff --git a/lib/dec_and_lock.c b/lib/dec_and_lock.c
index e73822aa6e9a..b5257725daad 100644
--- a/lib/dec_and_lock.c
+++ b/lib/dec_and_lock.c
@@ -1,6 +1,6 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * This is an implementation of the notion of "decrement a
diff --git a/lib/devres.c b/lib/devres.c
index 6efddf53b90c..7c0e953a7486 100644
--- a/lib/devres.c
+++ b/lib/devres.c
@@ -79,9 +79,9 @@ EXPORT_SYMBOL(devm_ioremap_nocache);
  */
 void devm_iounmap(struct device *dev, void __iomem *addr)
 {
-        iounmap(addr);
         WARN_ON(devres_destroy(dev, devm_ioremap_release, devm_ioremap_match,
                                (void *)addr));
+        iounmap(addr);
 }
 EXPORT_SYMBOL(devm_iounmap);
 
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index 7e65af70635e..f193b7796449 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -8,7 +8,6 @@
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/stacktrace.h>
-#include <linux/kallsyms.h>
 #include <linux/fault-inject.h>
 
 /*
@@ -140,16 +139,6 @@ static int debugfs_ul_set(void *data, u64 val)
         return 0;
 }
 
-#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
-static int debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data, u64 val)
-{
-        *(unsigned long *)data =
-                val < MAX_STACK_TRACE_DEPTH ?
-                val : MAX_STACK_TRACE_DEPTH;
-        return 0;
-}
-#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
-
 static int debugfs_ul_get(void *data, u64 *val)
 {
         *val = *(unsigned long *)data;
@@ -165,16 +154,26 @@ static struct dentry *debugfs_create_ul(const char *name, mode_t mode,
 }
 
 #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
-DEFINE_SIMPLE_ATTRIBUTE(fops_ul_MAX_STACK_TRACE_DEPTH, debugfs_ul_get,
-                        debugfs_ul_set_MAX_STACK_TRACE_DEPTH, "%llu\n");
 
-static struct dentry *debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
+static int debugfs_stacktrace_depth_set(void *data, u64 val)
+{
+        *(unsigned long *)data =
+                min_t(unsigned long, val, MAX_STACK_TRACE_DEPTH);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_stacktrace_depth, debugfs_ul_get,
+                        debugfs_stacktrace_depth_set, "%llu\n");
+
+static struct dentry *debugfs_create_stacktrace_depth(
         const char *name, mode_t mode,
         struct dentry *parent, unsigned long *value)
 {
         return debugfs_create_file(name, mode, parent, value,
-                                   &fops_ul_MAX_STACK_TRACE_DEPTH);
+                                   &fops_stacktrace_depth);
 }
+
 #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
 
 static int debugfs_atomic_t_set(void *data, u64 val)
@@ -198,118 +197,51 @@ static struct dentry *debugfs_create_atomic_t(const char *name, mode_t mode,
         return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
 }
 
-void cleanup_fault_attr_dentries(struct fault_attr *attr)
-{
-        debugfs_remove(attr->dentries.probability_file);
-        attr->dentries.probability_file = NULL;
-
-        debugfs_remove(attr->dentries.interval_file);
-        attr->dentries.interval_file = NULL;
-
-        debugfs_remove(attr->dentries.times_file);
-        attr->dentries.times_file = NULL;
-
-        debugfs_remove(attr->dentries.space_file);
-        attr->dentries.space_file = NULL;
-
-        debugfs_remove(attr->dentries.verbose_file);
-        attr->dentries.verbose_file = NULL;
-
-        debugfs_remove(attr->dentries.task_filter_file);
-        attr->dentries.task_filter_file = NULL;
-
-#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
-
-        debugfs_remove(attr->dentries.stacktrace_depth_file);
-        attr->dentries.stacktrace_depth_file = NULL;
-
-        debugfs_remove(attr->dentries.require_start_file);
-        attr->dentries.require_start_file = NULL;
-
-        debugfs_remove(attr->dentries.require_end_file);
-        attr->dentries.require_end_file = NULL;
-
-        debugfs_remove(attr->dentries.reject_start_file);
-        attr->dentries.reject_start_file = NULL;
-
-        debugfs_remove(attr->dentries.reject_end_file);
-        attr->dentries.reject_end_file = NULL;
-
-#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
-
-        if (attr->dentries.dir)
-                WARN_ON(!simple_empty(attr->dentries.dir));
-
-        debugfs_remove(attr->dentries.dir);
-        attr->dentries.dir = NULL;
-}
-
-int init_fault_attr_dentries(struct fault_attr *attr, const char *name)
+struct dentry *fault_create_debugfs_attr(const char *name,
+                        struct dentry *parent, struct fault_attr *attr)
 {
         mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
         struct dentry *dir;
 
-        memset(&attr->dentries, 0, sizeof(attr->dentries));
-
-        dir = debugfs_create_dir(name, NULL);
+        dir = debugfs_create_dir(name, parent);
         if (!dir)
-                goto fail;
-        attr->dentries.dir = dir;
-
-        attr->dentries.probability_file =
-                debugfs_create_ul("probability", mode, dir, &attr->probability);
+                return ERR_PTR(-ENOMEM);
 
-        attr->dentries.interval_file =
-                debugfs_create_ul("interval", mode, dir, &attr->interval);
-
-        attr->dentries.times_file =
-                debugfs_create_atomic_t("times", mode, dir, &attr->times);
-
-        attr->dentries.space_file =
-                debugfs_create_atomic_t("space", mode, dir, &attr->space);
-
-        attr->dentries.verbose_file =
-                debugfs_create_ul("verbose", mode, dir, &attr->verbose);
-
-        attr->dentries.task_filter_file = debugfs_create_bool("task-filter",
-                                                mode, dir, &attr->task_filter);
-
-        if (!attr->dentries.probability_file || !attr->dentries.interval_file ||
-            !attr->dentries.times_file || !attr->dentries.space_file ||
-            !attr->dentries.verbose_file || !attr->dentries.task_filter_file)
+        if (!debugfs_create_ul("probability", mode, dir, &attr->probability))
+                goto fail;
+        if (!debugfs_create_ul("interval", mode, dir, &attr->interval))
+                goto fail;
+        if (!debugfs_create_atomic_t("times", mode, dir, &attr->times))
+                goto fail;
+        if (!debugfs_create_atomic_t("space", mode, dir, &attr->space))
+                goto fail;
+        if (!debugfs_create_ul("verbose", mode, dir, &attr->verbose))
+                goto fail;
+        if (!debugfs_create_bool("task-filter", mode, dir, &attr->task_filter))
                 goto fail;
 
 #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
 
-        attr->dentries.stacktrace_depth_file =
-                debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
-                        "stacktrace-depth", mode, dir, &attr->stacktrace_depth);
-
-        attr->dentries.require_start_file =
-                debugfs_create_ul("require-start", mode, dir, &attr->require_start);
-
-        attr->dentries.require_end_file =
-                debugfs_create_ul("require-end", mode, dir, &attr->require_end);
-
-        attr->dentries.reject_start_file =
-                debugfs_create_ul("reject-start", mode, dir, &attr->reject_start);
-
-        attr->dentries.reject_end_file =
-                debugfs_create_ul("reject-end", mode, dir, &attr->reject_end);
-
-        if (!attr->dentries.stacktrace_depth_file ||
-            !attr->dentries.require_start_file ||
-            !attr->dentries.require_end_file ||
-            !attr->dentries.reject_start_file ||
-            !attr->dentries.reject_end_file)
+        if (!debugfs_create_stacktrace_depth("stacktrace-depth", mode, dir,
+                                &attr->stacktrace_depth))
+                goto fail;
+        if (!debugfs_create_ul("require-start", mode, dir,
+                                &attr->require_start))
+                goto fail;
+        if (!debugfs_create_ul("require-end", mode, dir, &attr->require_end))
+                goto fail;
+        if (!debugfs_create_ul("reject-start", mode, dir, &attr->reject_start))
+                goto fail;
+        if (!debugfs_create_ul("reject-end", mode, dir, &attr->reject_end))
                 goto fail;
 
 #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
 
-        return 0;
+        return dir;
 fail:
-        cleanup_fault_attr_dentries(attr);
-        return -ENOMEM;
+        debugfs_remove_recursive(dir);
+
+        return ERR_PTR(-ENOMEM);
 }
 
 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
diff --git a/lib/idr.c b/lib/idr.c
index e15502e8b21e..db040ce3fa73 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -34,8 +34,10 @@
 #include <linux/err.h>
 #include <linux/string.h>
 #include <linux/idr.h>
+#include <linux/spinlock.h>
 
 static struct kmem_cache *idr_layer_cache;
+static DEFINE_SPINLOCK(simple_ida_lock);
 
 static struct idr_layer *get_from_free_list(struct idr *idp)
 {
@@ -926,6 +928,71 @@ void ida_destroy(struct ida *ida)
 EXPORT_SYMBOL(ida_destroy);
 
 /**
+ * ida_simple_get - get a new id.
+ * @ida: the (initialized) ida.
+ * @start: the minimum id (inclusive, < 0x8000000)
+ * @end: the maximum id (exclusive, < 0x8000000 or 0)
+ * @gfp_mask: memory allocation flags
+ *
+ * Allocates an id in the range start <= id < end, or returns -ENOSPC.
+ * On memory allocation failure, returns -ENOMEM.
+ *
+ * Use ida_simple_remove() to get rid of an id.
+ */
+int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
+                   gfp_t gfp_mask)
+{
+        int ret, id;
+        unsigned int max;
+
+        BUG_ON((int)start < 0);
+        BUG_ON((int)end < 0);
+
+        if (end == 0)
+                max = 0x80000000;
+        else {
+                BUG_ON(end < start);
+                max = end - 1;
+        }
+
+again:
+        if (!ida_pre_get(ida, gfp_mask))
+                return -ENOMEM;
+
+        spin_lock(&simple_ida_lock);
+        ret = ida_get_new_above(ida, start, &id);
+        if (!ret) {
+                if (id > max) {
+                        ida_remove(ida, id);
+                        ret = -ENOSPC;
+                } else {
+                        ret = id;
+                }
+        }
+        spin_unlock(&simple_ida_lock);
+
+        if (unlikely(ret == -EAGAIN))
+                goto again;
+
+        return ret;
+}
+EXPORT_SYMBOL(ida_simple_get);
+
+/**
+ * ida_simple_remove - remove an allocated id.
+ * @ida: the (initialized) ida.
+ * @id: the id returned by ida_simple_get.
+ */
+void ida_simple_remove(struct ida *ida, unsigned int id)
+{
+        BUG_ON((int)id < 0);
+        spin_lock(&simple_ida_lock);
+        ida_remove(ida, id);
+        spin_unlock(&simple_ida_lock);
+}
+EXPORT_SYMBOL(ida_simple_remove);
+
+/**
  * ida_init - initialize ida handle
  * @ida:        ida handle
  *
diff --git a/lib/iomap.c b/lib/iomap.c
index d32229385151..5dbcb4b2d864 100644
--- a/lib/iomap.c
+++ b/lib/iomap.c
@@ -224,6 +224,7 @@ EXPORT_SYMBOL(iowrite8_rep);
 EXPORT_SYMBOL(iowrite16_rep);
 EXPORT_SYMBOL(iowrite32_rep);
 
+#ifdef CONFIG_HAS_IOPORT
 /* Create a virtual mapping cookie for an IO port range */
 void __iomem *ioport_map(unsigned long port, unsigned int nr)
 {
@@ -238,7 +239,9 @@ void ioport_unmap(void __iomem *addr)
 }
 EXPORT_SYMBOL(ioport_map);
 EXPORT_SYMBOL(ioport_unmap);
+#endif /* CONFIG_HAS_IOPORT */
 
+#ifdef CONFIG_PCI
 /**
  * pci_iomap - create a virtual mapping cookie for a PCI BAR
  * @dev: PCI device that owns the BAR
@@ -280,3 +283,4 @@ void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
 }
 EXPORT_SYMBOL(pci_iomap);
 EXPORT_SYMBOL(pci_iounmap);
+#endif /* CONFIG_PCI */
diff --git a/lib/kstrtox.c b/lib/kstrtox.c
index 2dbae88090ac..5e066759f551 100644
--- a/lib/kstrtox.c
+++ b/lib/kstrtox.c
@@ -19,11 +19,6 @@
 #include <linux/types.h>
 #include <asm/uaccess.h>
 
-static inline char _tolower(const char c)
-{
-        return c | 0x20;
-}
-
 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
 {
         unsigned long long acc;
diff --git a/lib/lcm.c b/lib/lcm.c
index 157cd88a6ffc..10b5cfcacf6b 100644
--- a/lib/lcm.c
+++ b/lib/lcm.c
@@ -1,6 +1,7 @@
 #include <linux/kernel.h>
 #include <linux/gcd.h>
 #include <linux/module.h>
+#include <linux/lcm.h>
 
 /* Lowest common multiple */
 unsigned long lcm(unsigned long a, unsigned long b)
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 7ea2e033d715..a2f9da59c197 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -823,8 +823,8 @@ unsigned long radix_tree_prev_hole(struct radix_tree_root *root,
 EXPORT_SYMBOL(radix_tree_prev_hole);
 
 static unsigned int
-__lookup(struct radix_tree_node *slot, void ***results, unsigned long index,
-        unsigned int max_items, unsigned long *next_index)
+__lookup(struct radix_tree_node *slot, void ***results, unsigned long *indices,
+        unsigned long index, unsigned int max_items, unsigned long *next_index)
 {
         unsigned int nr_found = 0;
         unsigned int shift, height;
@@ -857,12 +857,16 @@ __lookup(struct radix_tree_node *slot, void ***results, unsigned long index,
 
         /* Bottom level: grab some items */
         for (i = index & RADIX_TREE_MAP_MASK; i < RADIX_TREE_MAP_SIZE; i++) {
-                index++;
                 if (slot->slots[i]) {
-                        results[nr_found++] = &(slot->slots[i]);
-                        if (nr_found == max_items)
+                        results[nr_found] = &(slot->slots[i]);
+                        if (indices)
+                                indices[nr_found] = index;
+                        if (++nr_found == max_items) {
+                                index++;
                                 goto out;
+                        }
                 }
+                index++;
         }
 out:
         *next_index = index;
@@ -918,8 +922,8 @@ radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
 
                 if (cur_index > max_index)
                         break;
-                slots_found = __lookup(node, (void ***)results + ret, cur_index,
-                                        max_items - ret, &next_index);
+                slots_found = __lookup(node, (void ***)results + ret, NULL,
+                                cur_index, max_items - ret, &next_index);
                 nr_found = 0;
                 for (i = 0; i < slots_found; i++) {
                         struct radix_tree_node *slot;
@@ -944,6 +948,7 @@ EXPORT_SYMBOL(radix_tree_gang_lookup);
  *      radix_tree_gang_lookup_slot - perform multiple slot lookup on radix tree
  *      @root:          radix tree root
  *      @results:       where the results of the lookup are placed
+ *      @indices:       where their indices should be placed (but usually NULL)
  *      @first_index:   start the lookup from this key
  *      @max_items:     place up to this many items at *results
  *
@@ -958,7 +963,8 @@ EXPORT_SYMBOL(radix_tree_gang_lookup);
  *      protection, radix_tree_deref_slot may fail requiring a retry.
  */
 unsigned int
-radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
+radix_tree_gang_lookup_slot(struct radix_tree_root *root,
+                        void ***results, unsigned long *indices,
                         unsigned long first_index, unsigned int max_items)
 {
         unsigned long max_index;
@@ -974,6 +980,8 @@ radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
                 if (first_index > 0)
                         return 0;
                 results[0] = (void **)&root->rnode;
+                if (indices)
+                        indices[0] = 0;
                 return 1;
         }
         node = indirect_to_ptr(node);
@@ -987,8 +995,9 @@ radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
 
                 if (cur_index > max_index)
                         break;
-                slots_found = __lookup(node, results + ret, cur_index,
-                                        max_items - ret, &next_index);
+                slots_found = __lookup(node, results + ret,
+                                indices ? indices + ret : NULL,
+                                cur_index, max_items - ret, &next_index);
                 ret += slots_found;
                 if (next_index == 0)
                         break;
@@ -1194,6 +1203,98 @@ radix_tree_gang_lookup_tag_slot(struct radix_tree_root *root, void ***results,
 }
 EXPORT_SYMBOL(radix_tree_gang_lookup_tag_slot);
 
+#if defined(CONFIG_SHMEM) && defined(CONFIG_SWAP)
+#include <linux/sched.h> /* for cond_resched() */
+
+/*
+ * This linear search is at present only useful to shmem_unuse_inode().
+ */
+static unsigned long __locate(struct radix_tree_node *slot, void *item,
+                              unsigned long index, unsigned long *found_index)
+{
+        unsigned int shift, height;
+        unsigned long i;
+
+        height = slot->height;
+        shift = (height-1) * RADIX_TREE_MAP_SHIFT;
+
+        for ( ; height > 1; height--) {
+                i = (index >> shift) & RADIX_TREE_MAP_MASK;
+                for (;;) {
+                        if (slot->slots[i] != NULL)
+                                break;
+                        index &= ~((1UL << shift) - 1);
+                        index += 1UL << shift;
+                        if (index == 0)
+                                goto out;       /* 32-bit wraparound */
+                        i++;
+                        if (i == RADIX_TREE_MAP_SIZE)
+                                goto out;
+                }
+
+                shift -= RADIX_TREE_MAP_SHIFT;
+                slot = rcu_dereference_raw(slot->slots[i]);
+                if (slot == NULL)
+                        goto out;
+        }
+
+        /* Bottom level: check items */
+        for (i = 0; i < RADIX_TREE_MAP_SIZE; i++) {
+                if (slot->slots[i] == item) {
+                        *found_index = index + i;
+                        index = 0;
+                        goto out;
+                }
+        }
+        index += RADIX_TREE_MAP_SIZE;
+out:
+        return index;
+}
+
+/**
+ *      radix_tree_locate_item - search through radix tree for item
+ *      @root:          radix tree root
+ *      @item:          item to be found
+ *
+ *      Returns index where item was found, or -1 if not found.
+ *      Caller must hold no lock (since this time-consuming function needs
+ *      to be preemptible), and must check afterwards if item is still there.
+ */
+unsigned long radix_tree_locate_item(struct radix_tree_root *root, void *item)
+{
+        struct radix_tree_node *node;
+        unsigned long max_index;
+        unsigned long cur_index = 0;
+        unsigned long found_index = -1;
+
+        do {
+                rcu_read_lock();
+                node = rcu_dereference_raw(root->rnode);
+                if (!radix_tree_is_indirect_ptr(node)) {
+                        rcu_read_unlock();
+                        if (node == item)
+                                found_index = 0;
+                        break;
+                }
+
+                node = indirect_to_ptr(node);
+                max_index = radix_tree_maxindex(node->height);
+                if (cur_index > max_index)
+                        break;
+
+                cur_index = __locate(node, item, cur_index, &found_index);
+                rcu_read_unlock();
+                cond_resched();
+        } while (cur_index != 0 && cur_index <= max_index);
+
+        return found_index;
+}
+#else
+unsigned long radix_tree_locate_item(struct radix_tree_root *root, void *item)
+{
+        return -1;
+}
+#endif /* CONFIG_SHMEM && CONFIG_SWAP */
 
 /**
  *      radix_tree_shrink    -    shrink height of a radix tree to minimal
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 4365df31a1d5..d7222a9c8267 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -31,13 +31,10 @@
 #include <asm/div64.h>
 #include <asm/sections.h>       /* for dereference_function_descriptor() */
 
-/* Works only for digits and letters, but small and fast */
-#define TOLOWER(x) ((x) | 0x20)
-
 static unsigned int simple_guess_base(const char *cp)
 {
         if (cp[0] == '0') {
-                if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
+                if (_tolower(cp[1]) == 'x' && isxdigit(cp[2]))
                         return 16;
                 else
                         return 8;
@@ -59,13 +56,13 @@ unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int bas
         if (!base)
                 base = simple_guess_base(cp);
 
-        if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
+        if (base == 16 && cp[0] == '0' && _tolower(cp[1]) == 'x')
                 cp += 2;
 
         while (isxdigit(*cp)) {
                 unsigned int value;
 
-                value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
+                value = isdigit(*cp) ? *cp - '0' : _tolower(*cp) - 'a' + 10;
                 if (value >= base)
                         break;
                 result = result * base + value;
@@ -1036,8 +1033,8 @@ precision:
 qualifier:
         /* get the conversion qualifier */
         spec->qualifier = -1;
-        if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
-            TOLOWER(*fmt) == 'z' || *fmt == 't') {
+        if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
+            _tolower(*fmt) == 'z' || *fmt == 't') {
                 spec->qualifier = *fmt++;
                 if (unlikely(spec->qualifier == *fmt)) {
                         if (spec->qualifier == 'l') {
@@ -1104,7 +1101,7 @@ qualifier:
                         spec->type = FORMAT_TYPE_LONG;
                 else
                         spec->type = FORMAT_TYPE_ULONG;
-        } else if (TOLOWER(spec->qualifier) == 'z') {
+        } else if (_tolower(spec->qualifier) == 'z') {
                 spec->type = FORMAT_TYPE_SIZE_T;
         } else if (spec->qualifier == 't') {
                 spec->type = FORMAT_TYPE_PTRDIFF;
@@ -1149,8 +1146,7 @@ qualifier:
  * %pi4 print an IPv4 address with leading zeros
  * %pI6 print an IPv6 address with colons
  * %pi6 print an IPv6 address without colons
- * %pI6c print an IPv6 address as specified by
- *   http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
+ * %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.
  * %n is ignored
@@ -1263,7 +1259,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                         if (qualifier == 'l') {
                                 long *ip = va_arg(args, long *);
                                 *ip = (str - buf);
-                        } else if (TOLOWER(qualifier) == 'z') {
+                        } else if (_tolower(qualifier) == 'z') {
                                 size_t *ip = va_arg(args, size_t *);
                                 *ip = (str - buf);
                         } else {
@@ -1550,7 +1546,7 @@ do {									\
                         void *skip_arg;
                         if (qualifier == 'l')
                                 skip_arg = va_arg(args, long *);
-                        else if (TOLOWER(qualifier) == 'z')
+                        else if (_tolower(qualifier) == 'z')
                                 skip_arg = va_arg(args, size_t *);
                         else
                                 skip_arg = va_arg(args, int *);
@@ -1856,8 +1852,8 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
 
                 /* get conversion qualifier */
                 qualifier = -1;
-                if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
-                    TOLOWER(*fmt) == 'z') {
+                if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
+                    _tolower(*fmt) == 'z') {
                         qualifier = *fmt++;
                         if (unlikely(qualifier == *fmt)) {
                                 if (qualifier == 'h') {
diff --git a/lib/xz/xz_private.h b/lib/xz/xz_private.h
index a65633e06962..482b90f363fe 100644
--- a/lib/xz/xz_private.h
+++ b/lib/xz/xz_private.h
@@ -12,7 +12,7 @@
 
 #ifdef __KERNEL__
 #       include <linux/xz.h>
-#       include <asm/byteorder.h>
+#       include <linux/kernel.h>
 #       include <asm/unaligned.h>
         /* XZ_PREBOOT may be defined only via decompress_unxz.c. */
 #       ifndef XZ_PREBOOT