25 files changed, 599 insertions, 494 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index a8a775730c09..a5ce0c7f6c30 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -396,6 +396,39 @@ config CPU_RMAP
 config DQL
         bool
 
+config GLOB
+        bool
+#       This actually supports modular compilation, but the module overhead
+#       is ridiculous for the amount of code involved.  Until an out-of-tree
+#       driver asks for it, we'll just link it directly it into the kernel
+#       when required.  Since we're ignoring out-of-tree users, there's also
+#       no need bother prompting for a manual decision:
+#       prompt "glob_match() function"
+        help
+          This option provides a glob_match function for performing
+          simple text pattern matching.  It originated in the ATA code
+          to blacklist particular drive models, but other device drivers
+          may need similar functionality.
+
+          All drivers in the Linux kernel tree that require this function
+          should automatically select this option.  Say N unless you
+          are compiling an out-of tree driver which tells you that it
+          depends on this.
+
+config GLOB_SELFTEST
+        bool "glob self-test on init"
+        default n
+        depends on GLOB
+        help
+          This option enables a simple self-test of the glob_match
+          function on startup.  It is primarily useful for people
+          working on the code to ensure they haven't introduced any
+          regressions.
+
+          It only adds a little bit of code and slows kernel boot (or
+          module load) by a small amount, so you're welcome to play with
+          it, but you probably don't need it.
+
 #
 # Netlink attribute parsing support is select'ed if needed
 #
@@ -475,4 +508,11 @@ config UCS2_STRING
 
 source "lib/fonts/Kconfig"
 
+#
+# sg chaining option
+#
+
+config ARCH_HAS_SG_CHAIN
+        def_bool n
+
 endmenu
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index cfe7df8f62cc..07c28323f88f 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -15,7 +15,7 @@ config PRINTK_TIME
           The behavior is also controlled by the kernel command line
           parameter printk.time=1. See Documentation/kernel-parameters.txt
 
-config DEFAULT_MESSAGE_LOGLEVEL
+config MESSAGE_LOGLEVEL_DEFAULT
         int "Default message log level (1-7)"
         range 1 7
         default "4"
@@ -143,6 +143,30 @@ config DEBUG_INFO_REDUCED
           DEBUG_INFO build and compile times are reduced too.
           Only works with newer gcc versions.
 
+config DEBUG_INFO_SPLIT
+        bool "Produce split debuginfo in .dwo files"
+        depends on DEBUG_INFO
+        help
+          Generate debug info into separate .dwo files. This significantly
+          reduces the build directory size for builds with DEBUG_INFO,
+          because it stores the information only once on disk in .dwo
+          files instead of multiple times in object files and executables.
+          In addition the debug information is also compressed.
+
+          Requires recent gcc (4.7+) and recent gdb/binutils.
+          Any tool that packages or reads debug information would need
+          to know about the .dwo files and include them.
+          Incompatible with older versions of ccache.
+
+config DEBUG_INFO_DWARF4
+        bool "Generate dwarf4 debuginfo"
+        depends on DEBUG_INFO
+        help
+          Generate dwarf4 debug info. This requires recent versions
+          of gcc and gdb. It makes the debug information larger.
+          But it significantly improves the success of resolving
+          variables in gdb on optimized code.
+
 config ENABLE_WARN_DEPRECATED
         bool "Enable __deprecated logic"
         default y
diff --git a/lib/Makefile b/lib/Makefile
index 8427df95dade..d6b4bc496408 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -137,6 +137,8 @@ obj-$(CONFIG_CORDIC) += cordic.o
 
 obj-$(CONFIG_DQL) += dynamic_queue_limits.o
 
+obj-$(CONFIG_GLOB) += glob.o
+
 obj-$(CONFIG_MPILIB) += mpi/
 obj-$(CONFIG_SIGNATURE) += digsig.o
 
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 06f7e4fe8d2d..1e031f2c9aba 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -40,9 +40,9 @@
  * for the best explanations of this ordering.
  */
 
-int __bitmap_empty(const unsigned long *bitmap, int bits)
+int __bitmap_empty(const unsigned long *bitmap, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 if (bitmap[k])
                         return 0;
@@ -55,9 +55,9 @@ int __bitmap_empty(const unsigned long *bitmap, int bits)
 }
 EXPORT_SYMBOL(__bitmap_empty);
 
-int __bitmap_full(const unsigned long *bitmap, int bits)
+int __bitmap_full(const unsigned long *bitmap, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 if (~bitmap[k])
                         return 0;
@@ -71,9 +71,9 @@ int __bitmap_full(const unsigned long *bitmap, int bits)
 EXPORT_SYMBOL(__bitmap_full);
 
 int __bitmap_equal(const unsigned long *bitmap1,
-                const unsigned long *bitmap2, int bits)
+                const unsigned long *bitmap2, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 if (bitmap1[k] != bitmap2[k])
                         return 0;
@@ -86,14 +86,14 @@ int __bitmap_equal(const unsigned long *bitmap1,
 }
 EXPORT_SYMBOL(__bitmap_equal);
 
-void __bitmap_complement(unsigned long *dst, const unsigned long *src, int bits)
+void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 dst[k] = ~src[k];
 
         if (bits % BITS_PER_LONG)
-                dst[k] = ~src[k] & BITMAP_LAST_WORD_MASK(bits);
+                dst[k] = ~src[k];
 }
 EXPORT_SYMBOL(__bitmap_complement);
 
@@ -182,23 +182,26 @@ void __bitmap_shift_left(unsigned long *dst,
 EXPORT_SYMBOL(__bitmap_shift_left);
 
 int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                                const unsigned long *bitmap2, unsigned int bits)
 {
-        int k;
-        int nr = BITS_TO_LONGS(bits);
+        unsigned int k;
+        unsigned int lim = bits/BITS_PER_LONG;
         unsigned long result = 0;
 
-        for (k = 0; k < nr; k++)
+        for (k = 0; k < lim; k++)
                 result |= (dst[k] = bitmap1[k] & bitmap2[k]);
+        if (bits % BITS_PER_LONG)
+                result |= (dst[k] = bitmap1[k] & bitmap2[k] &
+                           BITMAP_LAST_WORD_MASK(bits));
         return result != 0;
 }
 EXPORT_SYMBOL(__bitmap_and);
 
 void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                                const unsigned long *bitmap2, unsigned int bits)
 {
-        int k;
-        int nr = BITS_TO_LONGS(bits);
+        unsigned int k;
+        unsigned int nr = BITS_TO_LONGS(bits);
 
         for (k = 0; k < nr; k++)
                 dst[k] = bitmap1[k] | bitmap2[k];
@@ -206,10 +209,10 @@ void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
 EXPORT_SYMBOL(__bitmap_or);
 
 void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                                const unsigned long *bitmap2, unsigned int bits)
 {
-        int k;
-        int nr = BITS_TO_LONGS(bits);
+        unsigned int k;
+        unsigned int nr = BITS_TO_LONGS(bits);
 
         for (k = 0; k < nr; k++)
                 dst[k] = bitmap1[k] ^ bitmap2[k];
@@ -217,22 +220,25 @@ void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
 EXPORT_SYMBOL(__bitmap_xor);
 
 int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                                const unsigned long *bitmap2, unsigned int bits)
 {
-        int k;
-        int nr = BITS_TO_LONGS(bits);
+        unsigned int k;
+        unsigned int lim = bits/BITS_PER_LONG;
         unsigned long result = 0;
 
-        for (k = 0; k < nr; k++)
+        for (k = 0; k < lim; k++)
                 result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
+        if (bits % BITS_PER_LONG)
+                result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &
+                           BITMAP_LAST_WORD_MASK(bits));
         return result != 0;
 }
 EXPORT_SYMBOL(__bitmap_andnot);
 
 int __bitmap_intersects(const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                        const unsigned long *bitmap2, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 if (bitmap1[k] & bitmap2[k])
                         return 1;
@@ -245,9 +251,9 @@ int __bitmap_intersects(const unsigned long *bitmap1,
 EXPORT_SYMBOL(__bitmap_intersects);
 
 int __bitmap_subset(const unsigned long *bitmap1,
-                                const unsigned long *bitmap2, int bits)
+                    const unsigned long *bitmap2, unsigned int bits)
 {
-        int k, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
         for (k = 0; k < lim; ++k)
                 if (bitmap1[k] & ~bitmap2[k])
                         return 0;
@@ -259,9 +265,10 @@ int __bitmap_subset(const unsigned long *bitmap1,
 }
 EXPORT_SYMBOL(__bitmap_subset);
 
-int __bitmap_weight(const unsigned long *bitmap, int bits)
+int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)
 {
-        int k, w = 0, lim = bits/BITS_PER_LONG;
+        unsigned int k, lim = bits/BITS_PER_LONG;
+        int w = 0;
 
         for (k = 0; k < lim; k++)
                 w += hweight_long(bitmap[k]);
@@ -273,42 +280,42 @@ int __bitmap_weight(const unsigned long *bitmap, int bits)
 }
 EXPORT_SYMBOL(__bitmap_weight);
 
-void bitmap_set(unsigned long *map, int start, int nr)
+void bitmap_set(unsigned long *map, unsigned int start, int len)
 {
         unsigned long *p = map + BIT_WORD(start);
-        const int size = start + nr;
+        const unsigned int size = start + len;
         int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
         unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
 
-        while (nr - bits_to_set >= 0) {
+        while (len - bits_to_set >= 0) {
                 *p |= mask_to_set;
-                nr -= bits_to_set;
+                len -= bits_to_set;
                 bits_to_set = BITS_PER_LONG;
                 mask_to_set = ~0UL;
                 p++;
         }
-        if (nr) {
+        if (len) {
                 mask_to_set &= BITMAP_LAST_WORD_MASK(size);
                 *p |= mask_to_set;
         }
 }
 EXPORT_SYMBOL(bitmap_set);
 
-void bitmap_clear(unsigned long *map, int start, int nr)
+void bitmap_clear(unsigned long *map, unsigned int start, int len)
 {
         unsigned long *p = map + BIT_WORD(start);
-        const int size = start + nr;
+        const unsigned int size = start + len;
         int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
         unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
 
-        while (nr - bits_to_clear >= 0) {
+        while (len - bits_to_clear >= 0) {
                 *p &= ~mask_to_clear;
-                nr -= bits_to_clear;
+                len -= bits_to_clear;
                 bits_to_clear = BITS_PER_LONG;
                 mask_to_clear = ~0UL;
                 p++;
         }
-        if (nr) {
+        if (len) {
                 mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
                 *p &= ~mask_to_clear;
         }
@@ -664,13 +671,8 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
 
 int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
 {
-        char *nl  = strchr(bp, '\n');
-        int len;
-
-        if (nl)
-                len = nl - bp;
-        else
-                len = strlen(bp);
+        char *nl  = strchrnul(bp, '\n');
+        int len = nl - bp;
 
         return __bitmap_parselist(bp, len, 0, maskp, nmaskbits);
 }
@@ -716,7 +718,7 @@ EXPORT_SYMBOL(bitmap_parselist_user);
  *
  * If for example, just bits 4 through 7 are set in @buf, then @pos
  * values 4 through 7 will get mapped to 0 through 3, respectively,
- * and other @pos values will get mapped to 0.  When @pos value 7
+ * and other @pos values will get mapped to -1.  When @pos value 7
  * gets mapped to (returns) @ord value 3 in this example, that means
  * that bit 7 is the 3rd (starting with 0th) set bit in @buf.
  *
@@ -1046,7 +1048,7 @@ enum {
         REG_OP_RELEASE,         /* clear all bits in region */
 };
 
-static int __reg_op(unsigned long *bitmap, int pos, int order, int reg_op)
+static int __reg_op(unsigned long *bitmap, unsigned int pos, int order, int reg_op)
 {
         int nbits_reg;          /* number of bits in region */
         int index;              /* index first long of region in bitmap */
@@ -1112,11 +1114,11 @@ done:
  * Return the bit offset in bitmap of the allocated region,
  * or -errno on failure.
  */
-int bitmap_find_free_region(unsigned long *bitmap, int bits, int order)
+int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)
 {
-        int pos, end;           /* scans bitmap by regions of size order */
+        unsigned int pos, end;          /* scans bitmap by regions of size order */
 
-        for (pos = 0 ; (end = pos + (1 << order)) <= bits; pos = end) {
+        for (pos = 0 ; (end = pos + (1U << order)) <= bits; pos = end) {
                 if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
                         continue;
                 __reg_op(bitmap, pos, order, REG_OP_ALLOC);
@@ -1137,7 +1139,7 @@ EXPORT_SYMBOL(bitmap_find_free_region);
  *
  * No return value.
  */
-void bitmap_release_region(unsigned long *bitmap, int pos, int order)
+void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)
 {
         __reg_op(bitmap, pos, order, REG_OP_RELEASE);
 }
@@ -1154,12 +1156,11 @@ EXPORT_SYMBOL(bitmap_release_region);
  * Return 0 on success, or %-EBUSY if specified region wasn't
  * free (not all bits were zero).
  */
-int bitmap_allocate_region(unsigned long *bitmap, int pos, int order)
+int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)
 {
         if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
                 return -EBUSY;
-        __reg_op(bitmap, pos, order, REG_OP_ALLOC);
-        return 0;
+        return __reg_op(bitmap, pos, order, REG_OP_ALLOC);
 }
 EXPORT_SYMBOL(bitmap_allocate_region);
 
diff --git a/lib/cmdline.c b/lib/cmdline.c
index d4932f745e92..76a712e6e20e 100644
--- a/lib/cmdline.c
+++ b/lib/cmdline.c
@@ -121,11 +121,7 @@ EXPORT_SYMBOL(get_options);
  *      @retptr: (output) Optional pointer to next char after parse completes
  *
  *      Parses a string into a number.  The number stored at @ptr is
- *      potentially suffixed with %K (for kilobytes, or 1024 bytes),
- *      %M (for megabytes, or 1048576 bytes), or %G (for gigabytes, or
- *      1073741824).  If the number is suffixed with K, M, or G, then
- *      the return value is the number multiplied by one kilobyte, one
- *      megabyte, or one gigabyte, respectively.
+ *      potentially suffixed with K, M, G, T, P, E.
  */
 
 unsigned long long memparse(const char *ptr, char **retptr)
@@ -135,6 +131,15 @@ unsigned long long memparse(const char *ptr, char **retptr)
         unsigned long long ret = simple_strtoull(ptr, &endptr, 0);
 
         switch (*endptr) {
+        case 'E':
+        case 'e':
+                ret <<= 10;
+        case 'P':
+        case 'p':
+                ret <<= 10;
+        case 'T':
+        case 't':
+                ret <<= 10;
         case 'G':
         case 'g':
                 ret <<= 10;
diff --git a/lib/decompress.c b/lib/decompress.c
index 86069d74c062..37f3c786348f 100644
--- a/lib/decompress.c
+++ b/lib/decompress.c
@@ -54,7 +54,7 @@ static const struct compress_format compressed_formats[] __initconst = {
         { {0, 0}, NULL, NULL }
 };
 
-decompress_fn __init decompress_method(const unsigned char *inbuf, int len,
+decompress_fn __init decompress_method(const unsigned char *inbuf, long len,
                                 const char **name)
 {
         const struct compress_format *cf;
diff --git a/lib/decompress_bunzip2.c b/lib/decompress_bunzip2.c
index 31c5f7675fbf..8290e0bef7ea 100644
--- a/lib/decompress_bunzip2.c
+++ b/lib/decompress_bunzip2.c
@@ -92,8 +92,8 @@ struct bunzip_data {
         /* State for interrupting output loop */
         int writeCopies, writePos, writeRunCountdown, writeCount, writeCurrent;
         /* I/O tracking data (file handles, buffers, positions, etc.) */
-        int (*fill)(void*, unsigned int);
-        int inbufCount, inbufPos /*, outbufPos*/;
+        long (*fill)(void*, unsigned long);
+        long inbufCount, inbufPos /*, outbufPos*/;
         unsigned char *inbuf /*,*outbuf*/;
         unsigned int inbufBitCount, inbufBits;
         /* The CRC values stored in the block header and calculated from the
@@ -617,7 +617,7 @@ decode_next_byte:
         goto decode_next_byte;
 }
 
-static int INIT nofill(void *buf, unsigned int len)
+static long INIT nofill(void *buf, unsigned long len)
 {
         return -1;
 }
@@ -625,8 +625,8 @@ static int INIT nofill(void *buf, unsigned int len)
 /* Allocate the structure, read file header.  If in_fd ==-1, inbuf must contain
    a complete bunzip file (len bytes long).  If in_fd!=-1, inbuf and len are
    ignored, and data is read from file handle into temporary buffer. */
-static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len,
-                             int (*fill)(void*, unsigned int))
+static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, long len,
+                             long (*fill)(void*, unsigned long))
 {
         struct bunzip_data *bd;
         unsigned int i, j, c;
@@ -675,11 +675,11 @@ static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len,
 
 /* Example usage: decompress src_fd to dst_fd.  (Stops at end of bzip2 data,
    not end of file.) */
-STATIC int INIT bunzip2(unsigned char *buf, int len,
-                        int(*fill)(void*, unsigned int),
-                        int(*flush)(void*, unsigned int),
+STATIC int INIT bunzip2(unsigned char *buf, long len,
+                        long (*fill)(void*, unsigned long),
+                        long (*flush)(void*, unsigned long),
                         unsigned char *outbuf,
-                        int *pos,
+                        long *pos,
                         void(*error)(char *x))
 {
         struct bunzip_data *bd;
@@ -743,11 +743,11 @@ exit_0:
 }
 
 #ifdef PREBOOT
-STATIC int INIT decompress(unsigned char *buf, int len,
-                        int(*fill)(void*, unsigned int),
-                        int(*flush)(void*, unsigned int),
+STATIC int INIT decompress(unsigned char *buf, long len,
+                        long (*fill)(void*, unsigned long),
+                        long (*flush)(void*, unsigned long),
                         unsigned char *outbuf,
-                        int *pos,
+                        long *pos,
                         void(*error)(char *x))
 {
         return bunzip2(buf, len - 4, fill, flush, outbuf, pos, error);
diff --git a/lib/decompress_inflate.c b/lib/decompress_inflate.c
index 0edfd742a154..d4c7891635ec 100644
--- a/lib/decompress_inflate.c
+++ b/lib/decompress_inflate.c
@@ -27,17 +27,17 @@
 
 #define GZIP_IOBUF_SIZE (16*1024)
 
-static int INIT nofill(void *buffer, unsigned int len)
+static long INIT nofill(void *buffer, unsigned long len)
 {
         return -1;
 }
 
 /* Included from initramfs et al code */
-STATIC int INIT gunzip(unsigned char *buf, int len,
-                       int(*fill)(void*, unsigned int),
-                       int(*flush)(void*, unsigned int),
+STATIC int INIT gunzip(unsigned char *buf, long len,
+                       long (*fill)(void*, unsigned long),
+                       long (*flush)(void*, unsigned long),
                        unsigned char *out_buf,
-                       int *pos,
+                       long *pos,
                        void(*error)(char *x)) {
         u8 *zbuf;
         struct z_stream_s *strm;
@@ -142,7 +142,7 @@ STATIC int INIT gunzip(unsigned char *buf, int len,
 
                 /* Write any data generated */
                 if (flush && strm->next_out > out_buf) {
-                        int l = strm->next_out - out_buf;
+                        long l = strm->next_out - out_buf;
                         if (l != flush(out_buf, l)) {
                                 rc = -1;
                                 error("write error");
diff --git a/lib/decompress_unlz4.c b/lib/decompress_unlz4.c
index 7d1e83caf8ad..40f66ebe57b7 100644
--- a/lib/decompress_unlz4.c
+++ b/lib/decompress_unlz4.c
@@ -31,10 +31,10 @@
 #define LZ4_DEFAULT_UNCOMPRESSED_CHUNK_SIZE (8 << 20)
 #define ARCHIVE_MAGICNUMBER 0x184C2102
 
-STATIC inline int INIT unlz4(u8 *input, int in_len,
-                                int (*fill) (void *, unsigned int),
-                                int (*flush) (void *, unsigned int),
-                                u8 *output, int *posp,
+STATIC inline int INIT unlz4(u8 *input, long in_len,
+                                long (*fill)(void *, unsigned long),
+                                long (*flush)(void *, unsigned long),
+                                u8 *output, long *posp,
                                 void (*error) (char *x))
 {
         int ret = -1;
@@ -43,7 +43,7 @@ STATIC inline int INIT unlz4(u8 *input, int in_len,
         u8 *inp;
         u8 *inp_start;
         u8 *outp;
-        int size = in_len;
+        long size = in_len;
 #ifdef PREBOOT
         size_t out_len = get_unaligned_le32(input + in_len);
 #endif
@@ -83,13 +83,20 @@ STATIC inline int INIT unlz4(u8 *input, int in_len,
         if (posp)
                 *posp = 0;
 
-        if (fill)
-                fill(inp, 4);
+        if (fill) {
+                size = fill(inp, 4);
+                if (size < 4) {
+                        error("data corrupted");
+                        goto exit_2;
+                }
+        }
 
         chunksize = get_unaligned_le32(inp);
         if (chunksize == ARCHIVE_MAGICNUMBER) {
-                inp += 4;
-                size -= 4;
+                if (!fill) {
+                        inp += 4;
+                        size -= 4;
+                }
         } else {
                 error("invalid header");
                 goto exit_2;
@@ -100,29 +107,44 @@ STATIC inline int INIT unlz4(u8 *input, int in_len,
 
         for (;;) {
 
-                if (fill)
-                        fill(inp, 4);
+                if (fill) {
+                        size = fill(inp, 4);
+                        if (size == 0)
+                                break;
+                        if (size < 4) {
+                                error("data corrupted");
+                                goto exit_2;
+                        }
+                }
 
                 chunksize = get_unaligned_le32(inp);
                 if (chunksize == ARCHIVE_MAGICNUMBER) {
-                        inp += 4;
-                        size -= 4;
+                        if (!fill) {
+                                inp += 4;
+                                size -= 4;
+                        }
                         if (posp)
                                 *posp += 4;
                         continue;
                 }
-                inp += 4;
-                size -= 4;
+
 
                 if (posp)
                         *posp += 4;
 
-                if (fill) {
+                if (!fill) {
+                        inp += 4;
+                        size -= 4;
+                } else {
                         if (chunksize > lz4_compressbound(uncomp_chunksize)) {
                                 error("chunk length is longer than allocated");
                                 goto exit_2;
                         }
-                        fill(inp, chunksize);
+                        size = fill(inp, chunksize);
+                        if (size < chunksize) {
+                                error("data corrupted");
+                                goto exit_2;
+                        }
                 }
 #ifdef PREBOOT
                 if (out_len >= uncomp_chunksize) {
@@ -149,18 +171,17 @@ STATIC inline int INIT unlz4(u8 *input, int in_len,
                 if (posp)
                         *posp += chunksize;
 
-                size -= chunksize;
+                if (!fill) {
+                        size -= chunksize;
 
-                if (size == 0)
-                        break;
-                else if (size < 0) {
-                        error("data corrupted");
-                        goto exit_2;
+                        if (size == 0)
+                                break;
+                        else if (size < 0) {
+                                error("data corrupted");
+                                goto exit_2;
+                        }
+                        inp += chunksize;
                 }
-
-                inp += chunksize;
-                if (fill)
-                        inp = inp_start;
         }
 
         ret = 0;
@@ -175,11 +196,11 @@ exit_0:
 }
 
 #ifdef PREBOOT
-STATIC int INIT decompress(unsigned char *buf, int in_len,
-                              int(*fill)(void*, unsigned int),
-                              int(*flush)(void*, unsigned int),
+STATIC int INIT decompress(unsigned char *buf, long in_len,
+                              long (*fill)(void*, unsigned long),
+                              long (*flush)(void*, unsigned long),
                               unsigned char *output,
-                              int *posp,
+                              long *posp,
                               void(*error)(char *x)
         )
 {
diff --git a/lib/decompress_unlzma.c b/lib/decompress_unlzma.c
index 32adb73a9038..0be83af62b88 100644
--- a/lib/decompress_unlzma.c
+++ b/lib/decompress_unlzma.c
@@ -65,11 +65,11 @@ static long long INIT read_int(unsigned char *ptr, int size)
 #define LZMA_IOBUF_SIZE 0x10000
 
 struct rc {
-        int (*fill)(void*, unsigned int);
+        long (*fill)(void*, unsigned long);
         uint8_t *ptr;
         uint8_t *buffer;
         uint8_t *buffer_end;
-        int buffer_size;
+        long buffer_size;
         uint32_t code;
         uint32_t range;
         uint32_t bound;
@@ -82,7 +82,7 @@ struct rc {
 #define RC_MODEL_TOTAL_BITS 11
 
 
-static int INIT nofill(void *buffer, unsigned int len)
+static long INIT nofill(void *buffer, unsigned long len)
 {
         return -1;
 }
@@ -99,8 +99,8 @@ static void INIT rc_read(struct rc *rc)
 
 /* Called once */
 static inline void INIT rc_init(struct rc *rc,
-                                       int (*fill)(void*, unsigned int),
-                                       char *buffer, int buffer_size)
+                                       long (*fill)(void*, unsigned long),
+                                       char *buffer, long buffer_size)
 {
         if (fill)
                 rc->fill = fill;
@@ -280,7 +280,7 @@ struct writer {
         size_t buffer_pos;
         int bufsize;
         size_t global_pos;
-        int(*flush)(void*, unsigned int);
+        long (*flush)(void*, unsigned long);
         struct lzma_header *header;
 };
 
@@ -534,11 +534,11 @@ static inline int INIT process_bit1(struct writer *wr, struct rc *rc,
 
 
 
-STATIC inline int INIT unlzma(unsigned char *buf, int in_len,
-                              int(*fill)(void*, unsigned int),
-                              int(*flush)(void*, unsigned int),
+STATIC inline int INIT unlzma(unsigned char *buf, long in_len,
+                              long (*fill)(void*, unsigned long),
+                              long (*flush)(void*, unsigned long),
                               unsigned char *output,
-                              int *posp,
+                              long *posp,
                               void(*error)(char *x)
         )
 {
@@ -667,11 +667,11 @@ exit_0:
 }
 
 #ifdef PREBOOT
-STATIC int INIT decompress(unsigned char *buf, int in_len,
-                              int(*fill)(void*, unsigned int),
-                              int(*flush)(void*, unsigned int),
+STATIC int INIT decompress(unsigned char *buf, long in_len,
+                              long (*fill)(void*, unsigned long),
+                              long (*flush)(void*, unsigned long),
                               unsigned char *output,
-                              int *posp,
+                              long *posp,
                               void(*error)(char *x)
         )
 {
diff --git a/lib/decompress_unlzo.c b/lib/decompress_unlzo.c
index 960183d4258f..b94a31bdd87d 100644
--- a/lib/decompress_unlzo.c
+++ b/lib/decompress_unlzo.c
@@ -51,7 +51,7 @@ static const unsigned char lzop_magic[] = {
 #define HEADER_SIZE_MIN       (9 + 7     + 4 + 8     + 1       + 4)
 #define HEADER_SIZE_MAX       (9 + 7 + 1 + 8 + 8 + 4 + 1 + 255 + 4)
 
-STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len)
+STATIC inline long INIT parse_header(u8 *input, long *skip, long in_len)
 {
         int l;
         u8 *parse = input;
@@ -108,14 +108,14 @@ STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len)
         return 1;
 }
 
-STATIC inline int INIT unlzo(u8 *input, int in_len,
-                                int (*fill) (void *, unsigned int),
-                                int (*flush) (void *, unsigned int),
-                                u8 *output, int *posp,
+STATIC int INIT unlzo(u8 *input, long in_len,
+                                long (*fill)(void *, unsigned long),
+                                long (*flush)(void *, unsigned long),
+                                u8 *output, long *posp,
                                 void (*error) (char *x))
 {
         u8 r = 0;
-        int skip = 0;
+        long skip = 0;
         u32 src_len, dst_len;
         size_t tmp;
         u8 *in_buf, *in_buf_save, *out_buf;
diff --git a/lib/decompress_unxz.c b/lib/decompress_unxz.c
index 9f34eb56854d..b07a78340e9d 100644
--- a/lib/decompress_unxz.c
+++ b/lib/decompress_unxz.c
@@ -248,10 +248,10 @@ void *memmove(void *dest, const void *src, size_t size)
  * both input and output buffers are available as a single chunk, i.e. when
  * fill() and flush() won't be used.
  */
-STATIC int INIT unxz(unsigned char *in, int in_size,
-                     int (*fill)(void *dest, unsigned int size),
-                     int (*flush)(void *src, unsigned int size),
-                     unsigned char *out, int *in_used,
+STATIC int INIT unxz(unsigned char *in, long in_size,
+                     long (*fill)(void *dest, unsigned long size),
+                     long (*flush)(void *src, unsigned long size),
+                     unsigned char *out, long *in_used,
                      void (*error)(char *x))
 {
         struct xz_buf b;
@@ -329,7 +329,7 @@ STATIC int INIT unxz(unsigned char *in, int in_size,
                                  * returned by xz_dec_run(), but probably
                                  * it's not too bad.
                                  */
-                                if (flush(b.out, b.out_pos) != (int)b.out_pos)
+                                if (flush(b.out, b.out_pos) != (long)b.out_pos)
                                         ret = XZ_BUF_ERROR;
 
                                 b.out_pos = 0;
diff --git a/lib/glob.c b/lib/glob.c
new file mode 100644
index 000000000000..500fc80d23e1
--- /dev/null
+++ b/lib/glob.c
@@ -0,0 +1,287 @@
+#include <linux/module.h>
+#include <linux/glob.h>
+
+/*
+ * The only reason this code can be compiled as a module is because the
+ * ATA code that depends on it can be as well.  In practice, they're
+ * both usually compiled in and the module overhead goes away.
+ */
+MODULE_DESCRIPTION("glob(7) matching");
+MODULE_LICENSE("Dual MIT/GPL");
+
+/**
+ * glob_match - Shell-style pattern matching, like !fnmatch(pat, str, 0)
+ * @pat: Shell-style pattern to match, e.g. "*.[ch]".
+ * @str: String to match.  The pattern must match the entire string.
+ *
+ * Perform shell-style glob matching, returning true (1) if the match
+ * succeeds, or false (0) if it fails.  Equivalent to !fnmatch(@pat, @str, 0).
+ *
+ * Pattern metacharacters are ?, *, [ and \.
+ * (And, inside character classes, !, - and ].)
+ *
+ * This is small and simple implementation intended for device blacklists
+ * where a string is matched against a number of patterns.  Thus, it
+ * does not preprocess the patterns.  It is non-recursive, and run-time
+ * is at most quadratic: strlen(@str)*strlen(@pat).
+ *
+ * An example of the worst case is glob_match("*aaaaa", "aaaaaaaaaa");
+ * it takes 6 passes over the pattern before matching the string.
+ *
+ * Like !fnmatch(@pat, @str, 0) and unlike the shell, this does NOT
+ * treat / or leading . specially; it isn't actually used for pathnames.
+ *
+ * Note that according to glob(7) (and unlike bash), character classes
+ * are complemented by a leading !; this does not support the regex-style
+ * [^a-z] syntax.
+ *
+ * An opening bracket without a matching close is matched literally.
+ */
+bool __pure glob_match(char const *pat, char const *str)
+{
+        /*
+         * Backtrack to previous * on mismatch and retry starting one
+         * character later in the string.  Because * matches all characters
+         * (no exception for /), it can be easily proved that there's
+         * never a need to backtrack multiple levels.
+         */
+        char const *back_pat = NULL, *back_str = back_str;
+
+        /*
+         * Loop over each token (character or class) in pat, matching
+         * it against the remaining unmatched tail of str.  Return false
+         * on mismatch, or true after matching the trailing nul bytes.
+         */
+        for (;;) {
+                unsigned char c = *str++;
+                unsigned char d = *pat++;
+
+                switch (d) {
+                case '?':       /* Wildcard: anything but nul */
+                        if (c == '\0')
+                                return false;
+                        break;
+                case '*':       /* Any-length wildcard */
+                        if (*pat == '\0')       /* Optimize trailing * case */
+                                return true;
+                        back_pat = pat;
+                        back_str = --str;       /* Allow zero-length match */
+                        break;
+                case '[': {     /* Character class */
+                        bool match = false, inverted = (*pat == '!');
+                        char const *class = pat + inverted;
+                        unsigned char a = *class++;
+
+                        /*
+                         * Iterate over each span in the character class.
+                         * A span is either a single character a, or a
+                         * range a-b.  The first span may begin with ']'.
+                         */
+                        do {
+                                unsigned char b = a;
+
+                                if (a == '\0')  /* Malformed */
+                                        goto literal;
+
+                                if (class[0] == '-' && class[1] != ']') {
+                                        b = class[1];
+
+                                        if (b == '\0')
+                                                goto literal;
+
+                                        class += 2;
+                                        /* Any special action if a > b? */
+                                }
+                                match |= (a <= c && c <= b);
+                        } while ((a = *class++) != ']');
+
+                        if (match == inverted)
+                                goto backtrack;
+                        pat = class;
+                        }
+                        break;
+                case '\\':
+                        d = *pat++;
+                        /*FALLTHROUGH*/
+                default:        /* Literal character */
+literal:
+                        if (c == d) {
+                                if (d == '\0')
+                                        return true;
+                                break;
+                        }
+backtrack:
+                        if (c == '\0' || !back_pat)
+                                return false;   /* No point continuing */
+                        /* Try again from last *, one character later in str. */
+                        pat = back_pat;
+                        str = ++back_str;
+                        break;
+                }
+        }
+}
+EXPORT_SYMBOL(glob_match);
+
+
+#ifdef CONFIG_GLOB_SELFTEST
+
+#include <linux/printk.h>
+#include <linux/moduleparam.h>
+
+/* Boot with "glob.verbose=1" to show successful tests, too */
+static bool verbose = false;
+module_param(verbose, bool, 0);
+
+struct glob_test {
+        char const *pat, *str;
+        bool expected;
+};
+
+static bool __pure __init test(char const *pat, char const *str, bool expected)
+{
+        bool match = glob_match(pat, str);
+        bool success = match == expected;
+
+        /* Can't get string literals into a particular section, so... */
+        static char const msg_error[] __initconst =
+                KERN_ERR "glob: \"%s\" vs. \"%s\": %s *** ERROR ***\n";
+        static char const msg_ok[] __initconst =
+                KERN_DEBUG "glob: \"%s\" vs. \"%s\": %s OK\n";
+        static char const mismatch[] __initconst = "mismatch";
+        char const *message;
+
+        if (!success)
+                message = msg_error;
+        else if (verbose)
+                message = msg_ok;
+        else
+                return success;
+
+        printk(message, pat, str, mismatch + 3*match);
+        return success;
+}
+
+/*
+ * The tests are all jammed together in one array to make it simpler
+ * to place that array in the .init.rodata section.  The obvious
+ * "array of structures containing char *" has no way to force the
+ * pointed-to strings to be in a particular section.
+ *
+ * Anyway, a test consists of:
+ * 1. Expected glob_match result: '1' or '0'.
+ * 2. Pattern to match: null-terminated string
+ * 3. String to match against: null-terminated string
+ *
+ * The list of tests is terminated with a final '\0' instead of
+ * a glob_match result character.
+ */
+static char const glob_tests[] __initconst =
+        /* Some basic tests */
+        "1" "a\0" "a\0"
+        "0" "a\0" "b\0"
+        "0" "a\0" "aa\0"
+        "0" "a\0" "\0"
+        "1" "\0" "\0"
+        "0" "\0" "a\0"
+        /* Simple character class tests */
+        "1" "[a]\0" "a\0"
+        "0" "[a]\0" "b\0"
+        "0" "[!a]\0" "a\0"
+        "1" "[!a]\0" "b\0"
+        "1" "[ab]\0" "a\0"
+        "1" "[ab]\0" "b\0"
+        "0" "[ab]\0" "c\0"
+        "1" "[!ab]\0" "c\0"
+        "1" "[a-c]\0" "b\0"
+        "0" "[a-c]\0" "d\0"
+        /* Corner cases in character class parsing */
+        "1" "[a-c-e-g]\0" "-\0"
+        "0" "[a-c-e-g]\0" "d\0"
+        "1" "[a-c-e-g]\0" "f\0"
+        "1" "[]a-ceg-ik[]\0" "a\0"
+        "1" "[]a-ceg-ik[]\0" "]\0"
+        "1" "[]a-ceg-ik[]\0" "[\0"
+        "1" "[]a-ceg-ik[]\0" "h\0"
+        "0" "[]a-ceg-ik[]\0" "f\0"
+        "0" "[!]a-ceg-ik[]\0" "h\0"
+        "0" "[!]a-ceg-ik[]\0" "]\0"
+        "1" "[!]a-ceg-ik[]\0" "f\0"
+        /* Simple wild cards */
+        "1" "?\0" "a\0"
+        "0" "?\0" "aa\0"
+        "0" "??\0" "a\0"
+        "1" "?x?\0" "axb\0"
+        "0" "?x?\0" "abx\0"
+        "0" "?x?\0" "xab\0"
+        /* Asterisk wild cards (backtracking) */
+        "0" "*??\0" "a\0"
+        "1" "*??\0" "ab\0"
+        "1" "*??\0" "abc\0"
+        "1" "*??\0" "abcd\0"
+        "0" "??*\0" "a\0"
+        "1" "??*\0" "ab\0"
+        "1" "??*\0" "abc\0"
+        "1" "??*\0" "abcd\0"
+        "0" "?*?\0" "a\0"
+        "1" "?*?\0" "ab\0"
+        "1" "?*?\0" "abc\0"
+        "1" "?*?\0" "abcd\0"
+        "1" "*b\0" "b\0"
+        "1" "*b\0" "ab\0"
+        "0" "*b\0" "ba\0"
+        "1" "*b\0" "bb\0"
+        "1" "*b\0" "abb\0"
+        "1" "*b\0" "bab\0"
+        "1" "*bc\0" "abbc\0"
+        "1" "*bc\0" "bc\0"
+        "1" "*bc\0" "bbc\0"
+        "1" "*bc\0" "bcbc\0"
+        /* Multiple asterisks (complex backtracking) */
+        "1" "*ac*\0" "abacadaeafag\0"
+        "1" "*ac*ae*ag*\0" "abacadaeafag\0"
+        "1" "*a*b*[bc]*[ef]*g*\0" "abacadaeafag\0"
+        "0" "*a*b*[ef]*[cd]*g*\0" "abacadaeafag\0"
+        "1" "*abcd*\0" "abcabcabcabcdefg\0"
+        "1" "*ab*cd*\0" "abcabcabcabcdefg\0"
+        "1" "*abcd*abcdef*\0" "abcabcdabcdeabcdefg\0"
+        "0" "*abcd*\0" "abcabcabcabcefg\0"
+        "0" "*ab*cd*\0" "abcabcabcabcefg\0";
+
+static int __init glob_init(void)
+{
+        unsigned successes = 0;
+        unsigned n = 0;
+        char const *p = glob_tests;
+        static char const message[] __initconst =
+                KERN_INFO "glob: %u self-tests passed, %u failed\n";
+
+        /*
+         * Tests are jammed together in a string.  The first byte is '1'
+         * or '0' to indicate the expected outcome, or '\0' to indicate the
+         * end of the tests.  Then come two null-terminated strings: the
+         * pattern and the string to match it against.
+         */
+        while (*p) {
+                bool expected = *p++ & 1;
+                char const *pat = p;
+
+                p += strlen(p) + 1;
+                successes += test(pat, p, expected);
+                p += strlen(p) + 1;
+                n++;
+        }
+
+        n -= successes;
+        printk(message, successes, n);
+
+        /* What's the errno for "kernel bug detected"?  Guess... */
+        return n ? -ECANCELED : 0;
+}
+
+/* We need a dummy exit function to allow unload */
+static void __exit glob_fini(void) { }
+
+module_init(glob_init);
+module_exit(glob_fini);
+
+#endif /* CONFIG_GLOB_SELFTEST */
diff --git a/lib/idr.c b/lib/idr.c
index 39158abebad1..50be3fa9b657 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -590,26 +590,27 @@ static void __idr_remove_all(struct idr *idp)
         struct idr_layer **paa = &pa[0];
 
         n = idp->layers * IDR_BITS;
-        p = idp->top;
+        *paa = idp->top;
         RCU_INIT_POINTER(idp->top, NULL);
         max = idr_max(idp->layers);
 
         id = 0;
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > IDR_BITS && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = p->ary[(id >> n) & IDR_MASK];
+                        *++paa = p;
                 }
 
                 bt_mask = id;
                 id += 1 << n;
                 /* Get the highest bit that the above add changed from 0->1. */
                 while (n < fls(id ^ bt_mask)) {
-                        if (p)
-                                free_layer(idp, p);
+                        if (*paa)
+                                free_layer(idp, *paa);
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
         idp->layers = 0;
@@ -692,15 +693,16 @@ int idr_for_each(struct idr *idp,
         struct idr_layer **paa = &pa[0];
 
         n = idp->layers * IDR_BITS;
-        p = rcu_dereference_raw(idp->top);
+        *paa = rcu_dereference_raw(idp->top);
         max = idr_max(idp->layers);
 
         id = 0;
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > 0 && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = rcu_dereference_raw(p->ary[(id >> n) & IDR_MASK]);
+                        *++paa = p;
                 }
 
                 if (p) {
@@ -712,7 +714,7 @@ int idr_for_each(struct idr *idp,
                 id += 1 << n;
                 while (n < fls(id)) {
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
 
@@ -740,17 +742,18 @@ void *idr_get_next(struct idr *idp, int *nextidp)
         int n, max;
 
         /* find first ent */
-        p = rcu_dereference_raw(idp->top);
+        p = *paa = rcu_dereference_raw(idp->top);
         if (!p)
                 return NULL;
         n = (p->layer + 1) * IDR_BITS;
         max = idr_max(p->layer + 1);
 
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > 0 && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = rcu_dereference_raw(p->ary[(id >> n) & IDR_MASK]);
+                        *++paa = p;
                 }
 
                 if (p) {
@@ -768,7 +771,7 @@ void *idr_get_next(struct idr *idp, int *nextidp)
                 id = round_up(id + 1, 1 << n);
                 while (n < fls(id)) {
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
         return NULL;
diff --git a/lib/kfifo.c b/lib/kfifo.c
index d79b9d222065..90ba1eb1df06 100644
--- a/lib/kfifo.c
+++ b/lib/kfifo.c
@@ -561,8 +561,7 @@ EXPORT_SYMBOL(__kfifo_to_user_r);
 unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
 {
-        if (!nents)
-                BUG();
+        BUG_ON(!nents);
 
         len = __kfifo_max_r(len, recsize);
 
@@ -585,8 +584,7 @@ EXPORT_SYMBOL(__kfifo_dma_in_finish_r);
 unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
 {
-        if (!nents)
-                BUG();
+        BUG_ON(!nents);
 
         len = __kfifo_max_r(len, recsize);
 
diff --git a/lib/klist.c b/lib/klist.c
index 358a368a2947..89b485a2a58d 100644
--- a/lib/klist.c
+++ b/lib/klist.c
@@ -140,11 +140,11 @@ void klist_add_tail(struct klist_node *n, struct klist *k)
 EXPORT_SYMBOL_GPL(klist_add_tail);
 
 /**
- * klist_add_after - Init a klist_node and add it after an existing node
+ * klist_add_behind - Init a klist_node and add it after an existing node
  * @n: node we're adding.
  * @pos: node to put @n after
  */
-void klist_add_after(struct klist_node *n, struct klist_node *pos)
+void klist_add_behind(struct klist_node *n, struct klist_node *pos)
 {
         struct klist *k = knode_klist(pos);
 
@@ -153,7 +153,7 @@ void klist_add_after(struct klist_node *n, struct klist_node *pos)
         list_add(&n->n_node, &pos->n_node);
         spin_unlock(&k->k_lock);
 }
-EXPORT_SYMBOL_GPL(klist_add_after);
+EXPORT_SYMBOL_GPL(klist_add_behind);
 
 /**
  * klist_add_before - Init a klist_node and add it before an existing node
diff --git a/lib/list_sort.c b/lib/list_sort.c
index 1183fa70a44d..12bcba1c8612 100644
--- a/lib/list_sort.c
+++ b/lib/list_sort.c
@@ -1,3 +1,6 @@
+
+#define pr_fmt(fmt) "list_sort_test: " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/list_sort.h>
@@ -47,6 +50,7 @@ static void merge_and_restore_back_links(void *priv,
                                 struct list_head *a, struct list_head *b)
 {
         struct list_head *tail = head;
+        u8 count = 0;
 
         while (a && b) {
                 /* if equal, take 'a' -- important for sort stability */
@@ -70,7 +74,8 @@ static void merge_and_restore_back_links(void *priv,
                  * element comparison is needed, so the client's cmp()
                  * routine can invoke cond_resched() periodically.
                  */
-                (*cmp)(priv, tail->next, tail->next);
+                if (unlikely(!(++count)))
+                        (*cmp)(priv, tail->next, tail->next);
 
                 tail->next->prev = tail;
                 tail = tail->next;
@@ -123,9 +128,7 @@ void list_sort(void *priv, struct list_head *head,
                 }
                 if (lev > max_lev) {
                         if (unlikely(lev >= ARRAY_SIZE(part)-1)) {
-                                printk_once(KERN_DEBUG "list passed to"
-                                        " list_sort() too long for"
-                                        " efficiency\n");
+                                printk_once(KERN_DEBUG "list too long for efficiency\n");
                                 lev--;
                         }
                         max_lev = lev;
@@ -168,27 +171,25 @@ static struct debug_el **elts __initdata;
 static int __init check(struct debug_el *ela, struct debug_el *elb)
 {
         if (ela->serial >= TEST_LIST_LEN) {
-                printk(KERN_ERR "list_sort_test: error: incorrect serial %d\n",
-                                ela->serial);
+                pr_err("error: incorrect serial %d\n", ela->serial);
                 return -EINVAL;
         }
         if (elb->serial >= TEST_LIST_LEN) {
-                printk(KERN_ERR "list_sort_test: error: incorrect serial %d\n",
-                                elb->serial);
+                pr_err("error: incorrect serial %d\n", elb->serial);
                 return -EINVAL;
         }
         if (elts[ela->serial] != ela || elts[elb->serial] != elb) {
-                printk(KERN_ERR "list_sort_test: error: phantom element\n");
+                pr_err("error: phantom element\n");
                 return -EINVAL;
         }
         if (ela->poison1 != TEST_POISON1 || ela->poison2 != TEST_POISON2) {
-                printk(KERN_ERR "list_sort_test: error: bad poison: %#x/%#x\n",
-                                ela->poison1, ela->poison2);
+                pr_err("error: bad poison: %#x/%#x\n",
+                        ela->poison1, ela->poison2);
                 return -EINVAL;
         }
         if (elb->poison1 != TEST_POISON1 || elb->poison2 != TEST_POISON2) {
-                printk(KERN_ERR "list_sort_test: error: bad poison: %#x/%#x\n",
-                                elb->poison1, elb->poison2);
+                pr_err("error: bad poison: %#x/%#x\n",
+                        elb->poison1, elb->poison2);
                 return -EINVAL;
         }
         return 0;
@@ -207,25 +208,23 @@ static int __init cmp(void *priv, struct list_head *a, struct list_head *b)
 
 static int __init list_sort_test(void)
 {
-        int i, count = 1, err = -EINVAL;
+        int i, count = 1, err = -ENOMEM;
         struct debug_el *el;
-        struct list_head *cur, *tmp;
+        struct list_head *cur;
         LIST_HEAD(head);
 
-        printk(KERN_DEBUG "list_sort_test: start testing list_sort()\n");
+        pr_debug("start testing list_sort()\n");
 
-        elts = kmalloc(sizeof(void *) * TEST_LIST_LEN, GFP_KERNEL);
+        elts = kcalloc(TEST_LIST_LEN, sizeof(*elts), GFP_KERNEL);
         if (!elts) {
-                printk(KERN_ERR "list_sort_test: error: cannot allocate "
-                                "memory\n");
-                goto exit;
+                pr_err("error: cannot allocate memory\n");
+                return err;
         }
 
         for (i = 0; i < TEST_LIST_LEN; i++) {
                 el = kmalloc(sizeof(*el), GFP_KERNEL);
                 if (!el) {
-                        printk(KERN_ERR "list_sort_test: error: cannot "
-                                        "allocate memory\n");
+                        pr_err("error: cannot allocate memory\n");
                         goto exit;
                 }
                  /* force some equivalencies */
@@ -239,52 +238,52 @@ static int __init list_sort_test(void)
 
         list_sort(NULL, &head, cmp);
 
+        err = -EINVAL;
         for (cur = head.next; cur->next != &head; cur = cur->next) {
                 struct debug_el *el1;
                 int cmp_result;
 
                 if (cur->next->prev != cur) {
-                        printk(KERN_ERR "list_sort_test: error: list is "
-                                        "corrupted\n");
+                        pr_err("error: list is corrupted\n");
                         goto exit;
                 }
 
                 cmp_result = cmp(NULL, cur, cur->next);
                 if (cmp_result > 0) {
-                        printk(KERN_ERR "list_sort_test: error: list is not "
-                                        "sorted\n");
+                        pr_err("error: list is not sorted\n");
                         goto exit;
                 }
 
                 el = container_of(cur, struct debug_el, list);
                 el1 = container_of(cur->next, struct debug_el, list);
                 if (cmp_result == 0 && el->serial >= el1->serial) {
-                        printk(KERN_ERR "list_sort_test: error: order of "
-                                        "equivalent elements not preserved\n");
+                        pr_err("error: order of equivalent elements not "
+                                "preserved\n");
                         goto exit;
                 }
 
                 if (check(el, el1)) {
-                        printk(KERN_ERR "list_sort_test: error: element check "
-                                        "failed\n");
+                        pr_err("error: element check failed\n");
                         goto exit;
                 }
                 count++;
         }
+        if (head.prev != cur) {
+                pr_err("error: list is corrupted\n");
+                goto exit;
+        }
+
 
         if (count != TEST_LIST_LEN) {
-                printk(KERN_ERR "list_sort_test: error: bad list length %d",
-                                count);
+                pr_err("error: bad list length %d", count);
                 goto exit;
         }
 
         err = 0;
 exit:
+        for (i = 0; i < TEST_LIST_LEN; i++)
+                kfree(elts[i]);
         kfree(elts);
-        list_for_each_safe(cur, tmp, &head) {
-                list_del(cur);
-                kfree(container_of(cur, struct debug_el, list));
-        }
         return err;
 }
 module_init(list_sort_test);
diff --git a/lib/lru_cache.c b/lib/lru_cache.c
index 4a83ecd03650..852c81e3ba9a 100644
--- a/lib/lru_cache.c
+++ b/lib/lru_cache.c
@@ -169,7 +169,7 @@ out_fail:
         return NULL;
 }
 
-void lc_free_by_index(struct lru_cache *lc, unsigned i)
+static void lc_free_by_index(struct lru_cache *lc, unsigned i)
 {
         void *p = lc->lc_element[i];
         WARN_ON(!p);
@@ -643,9 +643,10 @@ void lc_set(struct lru_cache *lc, unsigned int enr, int index)
  * lc_dump - Dump a complete LRU cache to seq in textual form.
  * @lc: the lru cache to operate on
  * @seq: the &struct seq_file pointer to seq_printf into
- * @utext: user supplied "heading" or other info
+ * @utext: user supplied additional "heading" or other info
  * @detail: function pointer the user may provide to dump further details
- * of the object the lc_element is embedded in.
+ * of the object the lc_element is embedded in. May be NULL.
+ * Note: a leading space ' ' and trailing newline '\n' is implied.
  */
 void lc_seq_dump_details(struct seq_file *seq, struct lru_cache *lc, char *utext,
              void (*detail) (struct seq_file *, struct lc_element *))
@@ -654,16 +655,18 @@ void lc_seq_dump_details(struct seq_file *seq, struct lru_cache *lc, char *utext
         struct lc_element *e;
         int i;
 
-        seq_printf(seq, "\tnn: lc_number refcnt %s\n ", utext);
+        seq_printf(seq, "\tnn: lc_number (new nr) refcnt %s\n ", utext);
         for (i = 0; i < nr_elements; i++) {
                 e = lc_element_by_index(lc, i);
-                if (e->lc_number == LC_FREE) {
-                        seq_printf(seq, "\t%2d: FREE\n", i);
-                } else {
-                        seq_printf(seq, "\t%2d: %4u %4u    ", i,
-                                   e->lc_number, e->refcnt);
+                if (e->lc_number != e->lc_new_number)
+                        seq_printf(seq, "\t%5d: %6d %8d %6d ",
+                                i, e->lc_number, e->lc_new_number, e->refcnt);
+                else
+                        seq_printf(seq, "\t%5d: %6d %-8s %6d ",
+                                i, e->lc_number, "-\"-", e->refcnt);
+                if (detail)
                         detail(seq, e);
-                }
+                seq_putc(seq, '\n');
         }
 }
 
diff --git a/lib/rbtree.c b/lib/rbtree.c
index 65f4effd117f..c16c81a3d430 100644
--- a/lib/rbtree.c
+++ b/lib/rbtree.c
@@ -101,7 +101,7 @@ __rb_insert(struct rb_node *node, struct rb_root *root,
                                  *      / \          / \
                                  *     p   u  -->   P   U
                                  *    /            /
-                                 *   n            N
+                                 *   n            n
                                  *
                                  * However, since g's parent might be red, and
                                  * 4) does not allow this, we need to recurse
diff --git a/lib/rhashtable.c b/lib/rhashtable.c
index e6940cf16628..a2c78810ebc1 100644
--- a/lib/rhashtable.c
+++ b/lib/rhashtable.c
@@ -38,16 +38,10 @@ int lockdep_rht_mutex_is_held(const struct rhashtable *ht)
 EXPORT_SYMBOL_GPL(lockdep_rht_mutex_is_held);
 #endif
 
-/**
- * rht_obj - cast hash head to outer object
- * @ht:         hash table
- * @he:         hashed node
- */
-void *rht_obj(const struct rhashtable *ht, const struct rhash_head *he)
+static void *rht_obj(const struct rhashtable *ht, const struct rhash_head *he)
 {
         return (void *) he - ht->p.head_offset;
 }
-EXPORT_SYMBOL_GPL(rht_obj);
 
 static u32 __hashfn(const struct rhashtable *ht, const void *key,
                       u32 len, u32 hsize)
@@ -386,7 +380,7 @@ EXPORT_SYMBOL_GPL(rhashtable_insert);
  * deletion when combined with walking or lookup.
  */
 void rhashtable_remove_pprev(struct rhashtable *ht, struct rhash_head *obj,
-                             struct rhash_head **pprev, gfp_t flags)
+                             struct rhash_head __rcu **pprev, gfp_t flags)
 {
         struct bucket_table *tbl = rht_dereference(ht->tbl, ht);
 
diff --git a/lib/scatterlist.c b/lib/scatterlist.c
index b4415fceb7e7..9cdf62f8accd 100644
--- a/lib/scatterlist.c
+++ b/lib/scatterlist.c
@@ -73,7 +73,7 @@ EXPORT_SYMBOL(sg_nents);
  **/
 struct scatterlist *sg_last(struct scatterlist *sgl, unsigned int nents)
 {
-#ifndef ARCH_HAS_SG_CHAIN
+#ifndef CONFIG_ARCH_HAS_SG_CHAIN
         struct scatterlist *ret = &sgl[nents - 1];
 #else
         struct scatterlist *sg, *ret = NULL;
@@ -255,7 +255,7 @@ int __sg_alloc_table(struct sg_table *table, unsigned int nents,
 
         if (nents == 0)
                 return -EINVAL;
-#ifndef ARCH_HAS_SG_CHAIN
+#ifndef CONFIG_ARCH_HAS_SG_CHAIN
         if (WARN_ON_ONCE(nents > max_ents))
                 return -EINVAL;
 #endif
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index ed5c1454dd62..29033f319aea 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -25,12 +25,15 @@
 int string_get_size(u64 size, const enum string_size_units units,
                     char *buf, int len)
 {
-        static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
-                                   "EB", "ZB", "YB", NULL};
-        static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
-                                 "EiB", "ZiB", "YiB", NULL };
-        static const char **units_str[] = {
-                [STRING_UNITS_10] =  units_10,
+        static const char *const units_10[] = {
+                "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL
+        };
+        static const char *const units_2[] = {
+                "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB",
+                NULL
+        };
+        static const char *const *const units_str[] = {
+                [STRING_UNITS_10] = units_10,
                 [STRING_UNITS_2] = units_2,
         };
         static const unsigned int divisor[] = {
diff --git a/lib/test-kstrtox.c b/lib/test-kstrtox.c
index bea3f3fa3f02..4137bca5f8e8 100644
--- a/lib/test-kstrtox.c
+++ b/lib/test-kstrtox.c
@@ -3,7 +3,7 @@
 #include <linux/module.h>
 
 #define for_each_test(i, test)  \
-        for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)
+        for (i = 0; i < ARRAY_SIZE(test); i++)
 
 struct test_fail {
         const char *str;
diff --git a/lib/zlib_deflate/deflate.c b/lib/zlib_deflate/deflate.c
index d63381e8e333..d20ef458f137 100644
--- a/lib/zlib_deflate/deflate.c
+++ b/lib/zlib_deflate/deflate.c
@@ -250,52 +250,6 @@ int zlib_deflateInit2(
 }
 
 /* ========================================================================= */
-#if 0
-int zlib_deflateSetDictionary(
-        z_streamp strm,
-        const Byte *dictionary,
-        uInt  dictLength
-)
-{
-    deflate_state *s;
-    uInt length = dictLength;
-    uInt n;
-    IPos hash_head = 0;
-
-    if (strm == NULL || strm->state == NULL || dictionary == NULL)
-        return Z_STREAM_ERROR;
-
-    s = (deflate_state *) strm->state;
-    if (s->status != INIT_STATE) return Z_STREAM_ERROR;
-
-    strm->adler = zlib_adler32(strm->adler, dictionary, dictLength);
-
-    if (length < MIN_MATCH) return Z_OK;
-    if (length > MAX_DIST(s)) {
-        length = MAX_DIST(s);
-#ifndef USE_DICT_HEAD
-        dictionary += dictLength - length; /* use the tail of the dictionary */
-#endif
-    }
-    memcpy((char *)s->window, dictionary, length);
-    s->strstart = length;
-    s->block_start = (long)length;
-
-    /* Insert all strings in the hash table (except for the last two bytes).
-     * s->lookahead stays null, so s->ins_h will be recomputed at the next
-     * call of fill_window.
-     */
-    s->ins_h = s->window[0];
-    UPDATE_HASH(s, s->ins_h, s->window[1]);
-    for (n = 0; n <= length - MIN_MATCH; n++) {
-        INSERT_STRING(s, n, hash_head);
-    }
-    if (hash_head) hash_head = 0;  /* to make compiler happy */
-    return Z_OK;
-}
-#endif  /*  0  */
-
-/* ========================================================================= */
 int zlib_deflateReset(
         z_streamp strm
 )
@@ -326,45 +280,6 @@ int zlib_deflateReset(
     return Z_OK;
 }
 
-/* ========================================================================= */
-#if 0
-int zlib_deflateParams(
-        z_streamp strm,
-        int level,
-        int strategy
-)
-{
-    deflate_state *s;
-    compress_func func;
-    int err = Z_OK;
-
-    if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
-    s = (deflate_state *) strm->state;
-
-    if (level == Z_DEFAULT_COMPRESSION) {
-        level = 6;
-    }
-    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
-        return Z_STREAM_ERROR;
-    }
-    func = configuration_table[s->level].func;
-
-    if (func != configuration_table[level].func && strm->total_in != 0) {
-        /* Flush the last buffer: */
-        err = zlib_deflate(strm, Z_PARTIAL_FLUSH);
-    }
-    if (s->level != level) {
-        s->level = level;
-        s->max_lazy_match   = configuration_table[level].max_lazy;
-        s->good_match       = configuration_table[level].good_length;
-        s->nice_match       = configuration_table[level].nice_length;
-        s->max_chain_length = configuration_table[level].max_chain;
-    }
-    s->strategy = strategy;
-    return err;
-}
-#endif  /*  0  */
-
 /* =========================================================================
  * Put a short in the pending buffer. The 16-bit value is put in MSB order.
  * IN assertion: the stream state is correct and there is enough room in
@@ -568,64 +483,6 @@ int zlib_deflateEnd(
     return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
 }
 
-/* =========================================================================
- * Copy the source state to the destination state.
- */
-#if 0
-int zlib_deflateCopy (
-        z_streamp dest,
-        z_streamp source
-)
-{
-#ifdef MAXSEG_64K
-    return Z_STREAM_ERROR;
-#else
-    deflate_state *ds;
-    deflate_state *ss;
-    ush *overlay;
-    deflate_workspace *mem;
-
-
-    if (source == NULL || dest == NULL || source->state == NULL) {
-        return Z_STREAM_ERROR;
-    }
-
-    ss = (deflate_state *) source->state;
-
-    *dest = *source;
-
-    mem = (deflate_workspace *) dest->workspace;
-
-    ds = &(mem->deflate_memory);
-
-    dest->state = (struct internal_state *) ds;
-    *ds = *ss;
-    ds->strm = dest;
-
-    ds->window = (Byte *) mem->window_memory;
-    ds->prev   = (Pos *)  mem->prev_memory;
-    ds->head   = (Pos *)  mem->head_memory;
-    overlay = (ush *) mem->overlay_memory;
-    ds->pending_buf = (uch *) overlay;
-
-    memcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
-    memcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
-    memcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
-    memcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
-
-    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
-    ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
-    ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
-
-    ds->l_desc.dyn_tree = ds->dyn_ltree;
-    ds->d_desc.dyn_tree = ds->dyn_dtree;
-    ds->bl_desc.dyn_tree = ds->bl_tree;
-
-    return Z_OK;
-#endif
-}
-#endif  /*  0  */
-
 /* ===========================================================================
  * Read a new buffer from the current input stream, update the adler32
  * and total number of bytes read.  All deflate() input goes through
diff --git a/lib/zlib_inflate/inflate.c b/lib/zlib_inflate/inflate.c
index f5ce87b0800e..58a733b10387 100644
--- a/lib/zlib_inflate/inflate.c
+++ b/lib/zlib_inflate/inflate.c
@@ -45,21 +45,6 @@ int zlib_inflateReset(z_streamp strm)
     return Z_OK;
 }
 
-#if 0
-int zlib_inflatePrime(z_streamp strm, int bits, int value)
-{
-    struct inflate_state *state;
-
-    if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
-    value &= (1L << bits) - 1;
-    state->hold += value << state->bits;
-    state->bits += bits;
-    return Z_OK;
-}
-#endif
-
 int zlib_inflateInit2(z_streamp strm, int windowBits)
 {
     struct inflate_state *state;
@@ -761,123 +746,6 @@ int zlib_inflateEnd(z_streamp strm)
     return Z_OK;
 }
 
-#if 0
-int zlib_inflateSetDictionary(z_streamp strm, const Byte *dictionary,
-        uInt dictLength)
-{
-    struct inflate_state *state;
-    unsigned long id;
-
-    /* check state */
-    if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (state->wrap != 0 && state->mode != DICT)
-        return Z_STREAM_ERROR;
-
-    /* check for correct dictionary id */
-    if (state->mode == DICT) {
-        id = zlib_adler32(0L, NULL, 0);
-        id = zlib_adler32(id, dictionary, dictLength);
-        if (id != state->check)
-            return Z_DATA_ERROR;
-    }
-
-    /* copy dictionary to window */
-    zlib_updatewindow(strm, strm->avail_out);
-
-    if (dictLength > state->wsize) {
-        memcpy(state->window, dictionary + dictLength - state->wsize,
-                state->wsize);
-        state->whave = state->wsize;
-    }
-    else {
-        memcpy(state->window + state->wsize - dictLength, dictionary,
-                dictLength);
-        state->whave = dictLength;
-    }
-    state->havedict = 1;
-    return Z_OK;
-}
-#endif
-
-#if 0
-/*
-   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
-   or when out of input.  When called, *have is the number of pattern bytes
-   found in order so far, in 0..3.  On return *have is updated to the new
-   state.  If on return *have equals four, then the pattern was found and the
-   return value is how many bytes were read including the last byte of the
-   pattern.  If *have is less than four, then the pattern has not been found
-   yet and the return value is len.  In the latter case, zlib_syncsearch() can be
-   called again with more data and the *have state.  *have is initialized to
-   zero for the first call.
- */
-static unsigned zlib_syncsearch(unsigned *have, unsigned char *buf,
-        unsigned len)
-{
-    unsigned got;
-    unsigned next;
-
-    got = *have;
-    next = 0;
-    while (next < len && got < 4) {
-        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
-            got++;
-        else if (buf[next])
-            got = 0;
-        else
-            got = 4 - got;
-        next++;
-    }
-    *have = got;
-    return next;
-}
-#endif
-
-#if 0
-int zlib_inflateSync(z_streamp strm)
-{
-    unsigned len;               /* number of bytes to look at or looked at */
-    unsigned long in, out;      /* temporary to save total_in and total_out */
-    unsigned char buf[4];       /* to restore bit buffer to byte string */
-    struct inflate_state *state;
-
-    /* check parameters */
-    if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
-
-    /* if first time, start search in bit buffer */
-    if (state->mode != SYNC) {
-        state->mode = SYNC;
-        state->hold <<= state->bits & 7;
-        state->bits -= state->bits & 7;
-        len = 0;
-        while (state->bits >= 8) {
-            buf[len++] = (unsigned char)(state->hold);
-            state->hold >>= 8;
-            state->bits -= 8;
-        }
-        state->have = 0;
-        zlib_syncsearch(&(state->have), buf, len);
-    }
-
-    /* search available input */
-    len = zlib_syncsearch(&(state->have), strm->next_in, strm->avail_in);
-    strm->avail_in -= len;
-    strm->next_in += len;
-    strm->total_in += len;
-
-    /* return no joy or set up to restart inflate() on a new block */
-    if (state->have != 4) return Z_DATA_ERROR;
-    in = strm->total_in;  out = strm->total_out;
-    zlib_inflateReset(strm);
-    strm->total_in = in;  strm->total_out = out;
-    state->mode = TYPE;
-    return Z_OK;
-}
-#endif
-
 /*
  * This subroutine adds the data at next_in/avail_in to the output history
  * without performing any output.  The output buffer must be "caught up";