Merge branch 'akpm' (patches from Andrew Morton)

Merge second patch-bomb from Andrew Morton:
 - a few hotfixes
 - drivers/dma updates
 - MAINTAINERS updates
 - Quite a lot of lib/ updates
 - checkpatch updates
 - binfmt updates
 - autofs4
 - drivers/rtc/
 - various small tweaks to less used filesystems
 - ipc/ updates
 - kernel/watchdog.c changes

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (135 commits)
  mm: softdirty: enable write notifications on VMAs after VM_SOFTDIRTY cleared
  kernel/param: consolidate __{start,stop}___param[] in <linux/moduleparam.h>
  ia64: remove duplicate declarations of __per_cpu_start[] and __per_cpu_end[]
  frv: remove unused declarations of __start___ex_table and __stop___ex_table
  kvm: ensure hard lockup detection is disabled by default
  kernel/watchdog.c: control hard lockup detection default
  staging: rtl8192u: use %*pEn to escape buffer
  staging: rtl8192e: use %*pEn to escape buffer
  staging: wlan-ng: use %*pEhp to print SN
  lib80211: remove unused print_ssid()
  wireless: hostap: proc: print properly escaped SSID
  wireless: ipw2x00: print SSID via %*pE
  wireless: libertas: print esaped string via %*pE
  lib/vsprintf: add %*pE[achnops] format specifier
  lib / string_helpers: introduce string_escape_mem()
  lib / string_helpers: refactoring the test suite
  lib / string_helpers: move documentation to c-file
  include/linux: remove strict_strto* definitions
  arch/x86/mm/numa.c: fix boot failure when all nodes are hotpluggable
  fs: check bh blocknr earlier when searching lru
  ...

9 files changed, 662 insertions, 123 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index e7ad58c5fbeb..4e35a5d767ed 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1648,7 +1648,7 @@ config DMA_API_DEBUG
 
           If unsure, say N.
 
-config TEST_MODULE
+config TEST_LKM
         tristate "Test module loading with 'hello world' module"
         default n
         depends on m
diff --git a/lib/Makefile b/lib/Makefile
index d6b4bc496408..7512dc978f18 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -11,7 +11,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          rbtree.o radix-tree.o dump_stack.o timerqueue.o\
          idr.o int_sqrt.o extable.o \
          sha1.o md5.o irq_regs.o reciprocal_div.o argv_split.o \
-         proportions.o flex_proportions.o prio_heap.o ratelimit.o show_mem.o \
+         proportions.o flex_proportions.o ratelimit.o show_mem.o \
          is_single_threaded.o plist.o decompress.o kobject_uevent.o \
          earlycpio.o
 
@@ -31,7 +31,7 @@ obj-y += string_helpers.o
 obj-$(CONFIG_TEST_STRING_HELPERS) += test-string_helpers.o
 obj-y += kstrtox.o
 obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
-obj-$(CONFIG_TEST_MODULE) += test_module.o
+obj-$(CONFIG_TEST_LKM) += test_module.o
 obj-$(CONFIG_TEST_USER_COPY) += test_user_copy.o
 obj-$(CONFIG_TEST_BPF) += test_bpf.o
 obj-$(CONFIG_TEST_FIRMWARE) += test_firmware.o
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index 31fe79e31ab8..dfba05521748 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -819,22 +819,9 @@ static const struct seq_operations ddebug_proc_seqops = {
  */
 static int ddebug_proc_open(struct inode *inode, struct file *file)
 {
-        struct ddebug_iter *iter;
-        int err;
-
         vpr_info("called\n");
-
-        iter = kzalloc(sizeof(*iter), GFP_KERNEL);
-        if (iter == NULL)
-                return -ENOMEM;
-
-        err = seq_open(file, &ddebug_proc_seqops);
-        if (err) {
-                kfree(iter);
-                return err;
-        }
-        ((struct seq_file *)file->private_data)->private = iter;
-        return 0;
+        return seq_open_private(file, &ddebug_proc_seqops,
+                                sizeof(struct ddebug_iter));
 }
 
 static const struct file_operations ddebug_proc_fops = {
diff --git a/lib/prio_heap.c b/lib/prio_heap.c
deleted file mode 100644
index a7af6f85eca8..000000000000
--- a/lib/prio_heap.c
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Simple insertion-only static-sized priority heap containing
- * pointers, based on CLR, chapter 7
- */
-
-#include <linux/slab.h>
-#include <linux/prio_heap.h>
-
-int heap_init(struct ptr_heap *heap, size_t size, gfp_t gfp_mask,
-              int (*gt)(void *, void *))
-{
-        heap->ptrs = kmalloc(size, gfp_mask);
-        if (!heap->ptrs)
-                return -ENOMEM;
-        heap->size = 0;
-        heap->max = size / sizeof(void *);
-        heap->gt = gt;
-        return 0;
-}
-
-void heap_free(struct ptr_heap *heap)
-{
-        kfree(heap->ptrs);
-}
-
-void *heap_insert(struct ptr_heap *heap, void *p)
-{
-        void *res;
-        void **ptrs = heap->ptrs;
-        int pos;
-
-        if (heap->size < heap->max) {
-                /* Heap insertion */
-                pos = heap->size++;
-                while (pos > 0 && heap->gt(p, ptrs[(pos-1)/2])) {
-                        ptrs[pos] = ptrs[(pos-1)/2];
-                        pos = (pos-1)/2;
-                }
-                ptrs[pos] = p;
-                return NULL;
-        }
-
-        /* The heap is full, so something will have to be dropped */
-
-        /* If the new pointer is greater than the current max, drop it */
-        if (heap->gt(p, ptrs[0]))
-                return p;
-
-        /* Replace the current max and heapify */
-        res = ptrs[0];
-        ptrs[0] = p;
-        pos = 0;
-
-        while (1) {
-                int left = 2 * pos + 1;
-                int right = 2 * pos + 2;
-                int largest = pos;
-                if (left < heap->size && heap->gt(ptrs[left], p))
-                        largest = left;
-                if (right < heap->size && heap->gt(ptrs[right], ptrs[largest]))
-                        largest = right;
-                if (largest == pos)
-                        break;
-                /* Push p down the heap one level and bump one up */
-                ptrs[pos] = ptrs[largest];
-                ptrs[largest] = p;
-                pos = largest;
-        }
-        return res;
-}
diff --git a/lib/string.c b/lib/string.c
index f3c6ff596414..2fc20aa06f84 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -27,14 +27,14 @@
 #include <linux/bug.h>
 #include <linux/errno.h>
 
-#ifndef __HAVE_ARCH_STRNICMP
+#ifndef __HAVE_ARCH_STRNCASECMP
 /**
- * strnicmp - Case insensitive, length-limited string comparison
+ * strncasecmp - Case insensitive, length-limited string comparison
  * @s1: One string
  * @s2: The other string
  * @len: the maximum number of characters to compare
  */
-int strnicmp(const char *s1, const char *s2, size_t len)
+int strncasecmp(const char *s1, const char *s2, size_t len)
 {
         /* Yes, Virginia, it had better be unsigned */
         unsigned char c1, c2;
@@ -56,6 +56,14 @@ int strnicmp(const char *s1, const char *s2, size_t len)
         } while (--len);
         return (int)c1 - (int)c2;
 }
+EXPORT_SYMBOL(strncasecmp);
+#endif
+#ifndef __HAVE_ARCH_STRNICMP
+#undef strnicmp
+int strnicmp(const char *s1, const char *s2, size_t len)
+{
+        return strncasecmp(s1, s2, len);
+}
 EXPORT_SYMBOL(strnicmp);
 #endif
 
@@ -73,20 +81,6 @@ int strcasecmp(const char *s1, const char *s2)
 EXPORT_SYMBOL(strcasecmp);
 #endif
 
-#ifndef __HAVE_ARCH_STRNCASECMP
-int strncasecmp(const char *s1, const char *s2, size_t n)
-{
-        int c1, c2;
-
-        do {
-                c1 = tolower(*s1++);
-                c2 = tolower(*s2++);
-        } while ((--n > 0) && c1 == c2 && c1 != 0);
-        return c1 - c2;
-}
-EXPORT_SYMBOL(strncasecmp);
-#endif
-
 #ifndef __HAVE_ARCH_STRCPY
 /**
  * strcpy - Copy a %NUL terminated string
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 29033f319aea..58b78ba57439 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -8,6 +8,8 @@
 #include <linux/math64.h>
 #include <linux/export.h>
 #include <linux/ctype.h>
+#include <linux/errno.h>
+#include <linux/string.h>
 #include <linux/string_helpers.h>
 
 /**
@@ -168,6 +170,44 @@ static bool unescape_special(char **src, char **dst)
         return true;
 }
 
+/**
+ * string_unescape - unquote characters in the given string
+ * @src:        source buffer (escaped)
+ * @dst:        destination buffer (unescaped)
+ * @size:       size of the destination buffer (0 to unlimit)
+ * @flags:      combination of the flags (bitwise OR):
+ *      %UNESCAPE_SPACE:
+ *              '\f' - form feed
+ *              '\n' - new line
+ *              '\r' - carriage return
+ *              '\t' - horizontal tab
+ *              '\v' - vertical tab
+ *      %UNESCAPE_OCTAL:
+ *              '\NNN' - byte with octal value NNN (1 to 3 digits)
+ *      %UNESCAPE_HEX:
+ *              '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
+ *      %UNESCAPE_SPECIAL:
+ *              '\"' - double quote
+ *              '\\' - backslash
+ *              '\a' - alert (BEL)
+ *              '\e' - escape
+ *      %UNESCAPE_ANY:
+ *              all previous together
+ *
+ * Description:
+ * The function unquotes characters in the given string.
+ *
+ * Because the size of the output will be the same as or less than the size of
+ * the input, the transformation may be performed in place.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will always be NULL-terminated. Source string must be
+ * NULL-terminated as well.
+ *
+ * Return:
+ * The amount of the characters processed to the destination buffer excluding
+ * trailing '\0' is returned.
+ */
 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
 {
         char *out = dst;
@@ -202,3 +242,275 @@ int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
         return out - dst;
 }
 EXPORT_SYMBOL(string_unescape);
+
+static int escape_passthrough(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+
+        if (*osz < 1)
+                return -ENOMEM;
+
+        *out++ = c;
+
+        *dst = out;
+        *osz -= 1;
+
+        return 1;
+}
+
+static int escape_space(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+        unsigned char to;
+
+        if (*osz < 2)
+                return -ENOMEM;
+
+        switch (c) {
+        case '\n':
+                to = 'n';
+                break;
+        case '\r':
+                to = 'r';
+                break;
+        case '\t':
+                to = 't';
+                break;
+        case '\v':
+                to = 'v';
+                break;
+        case '\f':
+                to = 'f';
+                break;
+        default:
+                return 0;
+        }
+
+        *out++ = '\\';
+        *out++ = to;
+
+        *dst = out;
+        *osz -= 2;
+
+        return 1;
+}
+
+static int escape_special(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+        unsigned char to;
+
+        if (*osz < 2)
+                return -ENOMEM;
+
+        switch (c) {
+        case '\\':
+                to = '\\';
+                break;
+        case '\a':
+                to = 'a';
+                break;
+        case '\e':
+                to = 'e';
+                break;
+        default:
+                return 0;
+        }
+
+        *out++ = '\\';
+        *out++ = to;
+
+        *dst = out;
+        *osz -= 2;
+
+        return 1;
+}
+
+static int escape_null(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+
+        if (*osz < 2)
+                return -ENOMEM;
+
+        if (c)
+                return 0;
+
+        *out++ = '\\';
+        *out++ = '0';
+
+        *dst = out;
+        *osz -= 2;
+
+        return 1;
+}
+
+static int escape_octal(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+
+        if (*osz < 4)
+                return -ENOMEM;
+
+        *out++ = '\\';
+        *out++ = ((c >> 6) & 0x07) + '0';
+        *out++ = ((c >> 3) & 0x07) + '0';
+        *out++ = ((c >> 0) & 0x07) + '0';
+
+        *dst = out;
+        *osz -= 4;
+
+        return 1;
+}
+
+static int escape_hex(unsigned char c, char **dst, size_t *osz)
+{
+        char *out = *dst;
+
+        if (*osz < 4)
+                return -ENOMEM;
+
+        *out++ = '\\';
+        *out++ = 'x';
+        *out++ = hex_asc_hi(c);
+        *out++ = hex_asc_lo(c);
+
+        *dst = out;
+        *osz -= 4;
+
+        return 1;
+}
+
+/**
+ * string_escape_mem - quote characters in the given memory buffer
+ * @src:        source buffer (unescaped)
+ * @isz:        source buffer size
+ * @dst:        destination buffer (escaped)
+ * @osz:        destination buffer size
+ * @flags:      combination of the flags (bitwise OR):
+ *      %ESCAPE_SPACE:
+ *              '\f' - form feed
+ *              '\n' - new line
+ *              '\r' - carriage return
+ *              '\t' - horizontal tab
+ *              '\v' - vertical tab
+ *      %ESCAPE_SPECIAL:
+ *              '\\' - backslash
+ *              '\a' - alert (BEL)
+ *              '\e' - escape
+ *      %ESCAPE_NULL:
+ *              '\0' - null
+ *      %ESCAPE_OCTAL:
+ *              '\NNN' - byte with octal value NNN (3 digits)
+ *      %ESCAPE_ANY:
+ *              all previous together
+ *      %ESCAPE_NP:
+ *              escape only non-printable characters (checked by isprint)
+ *      %ESCAPE_ANY_NP:
+ *              all previous together
+ *      %ESCAPE_HEX:
+ *              '\xHH' - byte with hexadecimal value HH (2 digits)
+ * @esc:        NULL-terminated string of characters any of which, if found in
+ *              the source, has to be escaped
+ *
+ * Description:
+ * The process of escaping byte buffer includes several parts. They are applied
+ * in the following sequence.
+ *      1. The character is matched to the printable class, if asked, and in
+ *         case of match it passes through to the output.
+ *      2. The character is not matched to the one from @esc string and thus
+ *         must go as is to the output.
+ *      3. The character is checked if it falls into the class given by @flags.
+ *         %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
+ *         character. Note that they actually can't go together, otherwise
+ *         %ESCAPE_HEX will be ignored.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will not be NULL-terminated, thus caller have to append
+ * it if needs.
+ *
+ * Return:
+ * The amount of the characters processed to the destination buffer, or
+ * %-ENOMEM if the size of buffer is not enough to put an escaped character is
+ * returned.
+ *
+ * Even in the case of error @dst pointer will be updated to point to the byte
+ * after the last processed character.
+ */
+int string_escape_mem(const char *src, size_t isz, char **dst, size_t osz,
+                      unsigned int flags, const char *esc)
+{
+        char *out = *dst, *p = out;
+        bool is_dict = esc && *esc;
+        int ret = 0;
+
+        while (isz--) {
+                unsigned char c = *src++;
+
+                /*
+                 * Apply rules in the following sequence:
+                 *      - the character is printable, when @flags has
+                 *        %ESCAPE_NP bit set
+                 *      - the @esc string is supplied and does not contain a
+                 *        character under question
+                 *      - the character doesn't fall into a class of symbols
+                 *        defined by given @flags
+                 * In these cases we just pass through a character to the
+                 * output buffer.
+                 */
+                if ((flags & ESCAPE_NP && isprint(c)) ||
+                    (is_dict && !strchr(esc, c))) {
+                        /* do nothing */
+                } else {
+                        if (flags & ESCAPE_SPACE) {
+                                ret = escape_space(c, &p, &osz);
+                                if (ret < 0)
+                                        break;
+                                if (ret > 0)
+                                        continue;
+                        }
+
+                        if (flags & ESCAPE_SPECIAL) {
+                                ret = escape_special(c, &p, &osz);
+                                if (ret < 0)
+                                        break;
+                                if (ret > 0)
+                                        continue;
+                        }
+
+                        if (flags & ESCAPE_NULL) {
+                                ret = escape_null(c, &p, &osz);
+                                if (ret < 0)
+                                        break;
+                                if (ret > 0)
+                                        continue;
+                        }
+
+                        /* ESCAPE_OCTAL and ESCAPE_HEX always go last */
+                        if (flags & ESCAPE_OCTAL) {
+                                ret = escape_octal(c, &p, &osz);
+                                if (ret < 0)
+                                        break;
+                                continue;
+                        }
+                        if (flags & ESCAPE_HEX) {
+                                ret = escape_hex(c, &p, &osz);
+                                if (ret < 0)
+                                        break;
+                                continue;
+                        }
+                }
+
+                ret = escape_passthrough(c, &p, &osz);
+                if (ret < 0)
+                        break;
+        }
+
+        *dst = p;
+
+        if (ret < 0)
+                return ret;
+
+        return p - out;
+}
+EXPORT_SYMBOL(string_escape_mem);
diff --git a/lib/test-string_helpers.c b/lib/test-string_helpers.c
index 6ac48de04c0e..ab0d30e1e18f 100644
--- a/lib/test-string_helpers.c
+++ b/lib/test-string_helpers.c
@@ -5,11 +5,32 @@
 
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/random.h>
 #include <linux/string.h>
 #include <linux/string_helpers.h>
 
+static __init bool test_string_check_buf(const char *name, unsigned int flags,
+                                         char *in, size_t p,
+                                         char *out_real, size_t q_real,
+                                         char *out_test, size_t q_test)
+{
+        if (q_real == q_test && !memcmp(out_test, out_real, q_test))
+                return true;
+
+        pr_warn("Test '%s' failed: flags = %u\n", name, flags);
+
+        print_hex_dump(KERN_WARNING, "Input: ", DUMP_PREFIX_NONE, 16, 1,
+                       in, p, true);
+        print_hex_dump(KERN_WARNING, "Expected: ", DUMP_PREFIX_NONE, 16, 1,
+                       out_test, q_test, true);
+        print_hex_dump(KERN_WARNING, "Got: ", DUMP_PREFIX_NONE, 16, 1,
+                       out_real, q_real, true);
+
+        return false;
+}
+
 struct test_string {
         const char *in;
         const char *out;
@@ -39,12 +60,17 @@ static const struct test_string strings[] __initconst = {
         },
 };
 
-static void __init test_string_unescape(unsigned int flags, bool inplace)
+static void __init test_string_unescape(const char *name, unsigned int flags,
+                                        bool inplace)
 {
-        char in[256];
-        char out_test[256];
-        char out_real[256];
-        int i, p = 0, q_test = 0, q_real = sizeof(out_real);
+        int q_real = 256;
+        char *in = kmalloc(q_real, GFP_KERNEL);
+        char *out_test = kmalloc(q_real, GFP_KERNEL);
+        char *out_real = kmalloc(q_real, GFP_KERNEL);
+        int i, p = 0, q_test = 0;
+
+        if (!in || !out_test || !out_real)
+                goto out;
 
         for (i = 0; i < ARRAY_SIZE(strings); i++) {
                 const char *s = strings[i].in;
@@ -77,15 +103,225 @@ static void __init test_string_unescape(unsigned int flags, bool inplace)
                 q_real = string_unescape(in, out_real, q_real, flags);
         }
 
-        if (q_real != q_test || memcmp(out_test, out_real, q_test)) {
-                pr_warn("Test failed: flags = %u\n", flags);
-                print_hex_dump(KERN_WARNING, "Input: ",
-                               DUMP_PREFIX_NONE, 16, 1, in, p - 1, true);
-                print_hex_dump(KERN_WARNING, "Expected: ",
-                               DUMP_PREFIX_NONE, 16, 1, out_test, q_test, true);
-                print_hex_dump(KERN_WARNING, "Got: ",
-                               DUMP_PREFIX_NONE, 16, 1, out_real, q_real, true);
+        test_string_check_buf(name, flags, in, p - 1, out_real, q_real,
+                              out_test, q_test);
+out:
+        kfree(out_real);
+        kfree(out_test);
+        kfree(in);
+}
+
+struct test_string_1 {
+        const char *out;
+        unsigned int flags;
+};
+
+#define TEST_STRING_2_MAX_S1            32
+struct test_string_2 {
+        const char *in;
+        struct test_string_1 s1[TEST_STRING_2_MAX_S1];
+};
+
+#define TEST_STRING_2_DICT_0            NULL
+static const struct test_string_2 escape0[] __initconst = {{
+        .in = "\f\\ \n\r\t\v",
+        .s1 = {{
+                .out = "\\f\\ \\n\\r\\t\\v",
+                .flags = ESCAPE_SPACE,
+        },{
+                .out = "\\f\\134\\040\\n\\r\\t\\v",
+                .flags = ESCAPE_SPACE | ESCAPE_OCTAL,
+        },{
+                .out = "\\f\\x5c\\x20\\n\\r\\t\\v",
+                .flags = ESCAPE_SPACE | ESCAPE_HEX,
+        },{
+                /* terminator */
+        }},
+},{
+        .in = "\\h\\\"\a\e\\",
+        .s1 = {{
+                .out = "\\\\h\\\\\"\\a\\e\\\\",
+                .flags = ESCAPE_SPECIAL,
+        },{
+                .out = "\\\\\\150\\\\\\042\\a\\e\\\\",
+                .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
+        },{
+                .out = "\\\\\\x68\\\\\\x22\\a\\e\\\\",
+                .flags = ESCAPE_SPECIAL | ESCAPE_HEX,
+        },{
+                /* terminator */
+        }},
+},{
+        .in = "\eb \\C\007\"\x90\r]",
+        .s1 = {{
+                .out = "\eb \\C\007\"\x90\\r]",
+                .flags = ESCAPE_SPACE,
+        },{
+                .out = "\\eb \\\\C\\a\"\x90\r]",
+                .flags = ESCAPE_SPECIAL,
+        },{
+                .out = "\\eb \\\\C\\a\"\x90\\r]",
+                .flags = ESCAPE_SPACE | ESCAPE_SPECIAL,
+        },{
+                .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\015\\135",
+                .flags = ESCAPE_OCTAL,
+        },{
+                .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\r\\135",
+                .flags = ESCAPE_SPACE | ESCAPE_OCTAL,
+        },{
+                .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\015\\135",
+                .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
+        },{
+                .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\r\\135",
+                .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_OCTAL,
+        },{
+                .out = "\eb \\C\007\"\x90\r]",
+                .flags = ESCAPE_NP,
+        },{
+                .out = "\eb \\C\007\"\x90\\r]",
+                .flags = ESCAPE_SPACE | ESCAPE_NP,
+        },{
+                .out = "\\eb \\C\\a\"\x90\r]",
+                .flags = ESCAPE_SPECIAL | ESCAPE_NP,
+        },{
+                .out = "\\eb \\C\\a\"\x90\\r]",
+                .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NP,
+        },{
+                .out = "\\033b \\C\\007\"\\220\\015]",
+                .flags = ESCAPE_OCTAL | ESCAPE_NP,
+        },{
+                .out = "\\033b \\C\\007\"\\220\\r]",
+                .flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NP,
+        },{
+                .out = "\\eb \\C\\a\"\\220\\r]",
+                .flags = ESCAPE_SPECIAL | ESCAPE_SPACE | ESCAPE_OCTAL |
+                         ESCAPE_NP,
+        },{
+                .out = "\\x1bb \\C\\x07\"\\x90\\x0d]",
+                .flags = ESCAPE_NP | ESCAPE_HEX,
+        },{
+                /* terminator */
+        }},
+},{
+        /* terminator */
+}};
+
+#define TEST_STRING_2_DICT_1            "b\\ \t\r"
+static const struct test_string_2 escape1[] __initconst = {{
+        .in = "\f\\ \n\r\t\v",
+        .s1 = {{
+                .out = "\f\\134\\040\n\\015\\011\v",
+                .flags = ESCAPE_OCTAL,
+        },{
+                .out = "\f\\x5c\\x20\n\\x0d\\x09\v",
+                .flags = ESCAPE_HEX,
+        },{
+                /* terminator */
+        }},
+},{
+        .in = "\\h\\\"\a\e\\",
+        .s1 = {{
+                .out = "\\134h\\134\"\a\e\\134",
+                .flags = ESCAPE_OCTAL,
+        },{
+                /* terminator */
+        }},
+},{
+        .in = "\eb \\C\007\"\x90\r]",
+        .s1 = {{
+                .out = "\e\\142\\040\\134C\007\"\x90\\015]",
+                .flags = ESCAPE_OCTAL,
+        },{
+                /* terminator */
+        }},
+},{
+        /* terminator */
+}};
+
+static __init const char *test_string_find_match(const struct test_string_2 *s2,
+                                                 unsigned int flags)
+{
+        const struct test_string_1 *s1 = s2->s1;
+        unsigned int i;
+
+        if (!flags)
+                return s2->in;
+
+        /* Test cases are NULL-aware */
+        flags &= ~ESCAPE_NULL;
+
+        /* ESCAPE_OCTAL has a higher priority */
+        if (flags & ESCAPE_OCTAL)
+                flags &= ~ESCAPE_HEX;
+
+        for (i = 0; i < TEST_STRING_2_MAX_S1 && s1->out; i++, s1++)
+                if (s1->flags == flags)
+                        return s1->out;
+        return NULL;
+}
+
+static __init void test_string_escape(const char *name,
+                                      const struct test_string_2 *s2,
+                                      unsigned int flags, const char *esc)
+{
+        int q_real = 512;
+        char *out_test = kmalloc(q_real, GFP_KERNEL);
+        char *out_real = kmalloc(q_real, GFP_KERNEL);
+        char *in = kmalloc(256, GFP_KERNEL);
+        char *buf = out_real;
+        int p = 0, q_test = 0;
+
+        if (!out_test || !out_real || !in)
+                goto out;
+
+        for (; s2->in; s2++) {
+                const char *out;
+                int len;
+
+                /* NULL injection */
+                if (flags & ESCAPE_NULL) {
+                        in[p++] = '\0';
+                        out_test[q_test++] = '\\';
+                        out_test[q_test++] = '0';
+                }
+
+                /* Don't try strings that have no output */
+                out = test_string_find_match(s2, flags);
+                if (!out)
+                        continue;
+
+                /* Copy string to in buffer */
+                len = strlen(s2->in);
+                memcpy(&in[p], s2->in, len);
+                p += len;
+
+                /* Copy expected result for given flags */
+                len = strlen(out);
+                memcpy(&out_test[q_test], out, len);
+                q_test += len;
         }
+
+        q_real = string_escape_mem(in, p, &buf, q_real, flags, esc);
+
+        test_string_check_buf(name, flags, in, p, out_real, q_real, out_test,
+                              q_test);
+out:
+        kfree(in);
+        kfree(out_real);
+        kfree(out_test);
+}
+
+static __init void test_string_escape_nomem(void)
+{
+        char *in = "\eb \\C\007\"\x90\r]";
+        char out[64], *buf = out;
+        int rc = -ENOMEM, ret;
+
+        ret = string_escape_str_any_np(in, &buf, strlen(in), NULL);
+        if (ret == rc)
+                return;
+
+        pr_err("Test 'escape nomem' failed: got %d instead of %d\n", ret, rc);
 }
 
 static int __init test_string_helpers_init(void)
@@ -94,8 +330,19 @@ static int __init test_string_helpers_init(void)
 
         pr_info("Running tests...\n");
         for (i = 0; i < UNESCAPE_ANY + 1; i++)
-                test_string_unescape(i, false);
-        test_string_unescape(get_random_int() % (UNESCAPE_ANY + 1), true);
+                test_string_unescape("unescape", i, false);
+        test_string_unescape("unescape inplace",
+                             get_random_int() % (UNESCAPE_ANY + 1), true);
+
+        /* Without dictionary */
+        for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
+                test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0);
+
+        /* With dictionary */
+        for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
+                test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1);
+
+        test_string_escape_nomem();
 
         return -EINVAL;
 }
diff --git a/lib/textsearch.c b/lib/textsearch.c
index 0c7e9ab2d88f..0b79908dfe89 100644
--- a/lib/textsearch.c
+++ b/lib/textsearch.c
@@ -249,9 +249,7 @@ EXPORT_SYMBOL(textsearch_find_continuous);
  * @flags: search flags
  *
  * Looks up the search algorithm module and creates a new textsearch
- * configuration for the specified pattern. Upon completion all
- * necessary refcnts are held and the configuration must be put back
- * using textsearch_put() after usage.
+ * configuration for the specified pattern.
  *
  * Note: The format of the pattern may not be compatible between
  *       the various search algorithms.
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index ba3cd0a35640..ec337f64f52d 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -33,6 +33,7 @@
 #include <asm/page.h>           /* for PAGE_SIZE */
 #include <asm/sections.h>       /* for dereference_function_descriptor() */
 
+#include <linux/string_helpers.h>
 #include "kstrtox.h"
 
 /**
@@ -1101,6 +1102,62 @@ char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
 }
 
 static noinline_for_stack
+char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
+                     const char *fmt)
+{
+        bool found = true;
+        int count = 1;
+        unsigned int flags = 0;
+        int len;
+
+        if (spec.field_width == 0)
+                return buf;                             /* nothing to print */
+
+        if (ZERO_OR_NULL_PTR(addr))
+                return string(buf, end, NULL, spec);    /* NULL pointer */
+
+
+        do {
+                switch (fmt[count++]) {
+                case 'a':
+                        flags |= ESCAPE_ANY;
+                        break;
+                case 'c':
+                        flags |= ESCAPE_SPECIAL;
+                        break;
+                case 'h':
+                        flags |= ESCAPE_HEX;
+                        break;
+                case 'n':
+                        flags |= ESCAPE_NULL;
+                        break;
+                case 'o':
+                        flags |= ESCAPE_OCTAL;
+                        break;
+                case 'p':
+                        flags |= ESCAPE_NP;
+                        break;
+                case 's':
+                        flags |= ESCAPE_SPACE;
+                        break;
+                default:
+                        found = false;
+                        break;
+                }
+        } while (found);
+
+        if (!flags)
+                flags = ESCAPE_ANY_NP;
+
+        len = spec.field_width < 0 ? 1 : spec.field_width;
+
+        /* Ignore the error. We print as many characters as we can */
+        string_escape_mem(addr, len, &buf, end - buf, flags, NULL);
+
+        return buf;
+}
+
+static noinline_for_stack
 char *uuid_string(char *buf, char *end, const u8 *addr,
                   struct printf_spec spec, const char *fmt)
 {
@@ -1221,6 +1278,17 @@ int kptr_restrict __read_mostly;
  * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order
  * - 'I[6S]c' for IPv6 addresses printed as specified by
  *       http://tools.ietf.org/html/rfc5952
+ * - 'E[achnops]' For an escaped buffer, where rules are defined by combination
+ *                of the following flags (see string_escape_mem() for the
+ *                details):
+ *                  a - ESCAPE_ANY
+ *                  c - ESCAPE_SPECIAL
+ *                  h - ESCAPE_HEX
+ *                  n - ESCAPE_NULL
+ *                  o - ESCAPE_OCTAL
+ *                  p - ESCAPE_NP
+ *                  s - ESCAPE_SPACE
+ *                By default ESCAPE_ANY_NP is used.
  * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
  *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  *       Options for %pU are:
@@ -1321,6 +1389,8 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
                         }}
                 }
                 break;
+        case 'E':
+                return escaped_string(buf, end, ptr, spec, fmt);
         case 'U':
                 return uuid_string(buf, end, ptr, spec, fmt);
         case 'V':
@@ -1633,6 +1703,7 @@ qualifier:
  * %piS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address
  * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
  *   case.
+ * %*pE[achnops] print an escaped buffer
  * %*ph[CDN] a variable-length hex string with a separator (supports up to 64
  *           bytes of the input)
  * %n is ignored