194 files changed, 2520 insertions, 1356 deletions
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 661efd4dab6b..a0c5c5f4fce6 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -973,6 +973,9 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
        ignore_loglevel [KNL]
                        Ignore loglevel setting - this will print /all/
                        kernel messages to the console. Useful for debugging.
+                        We also add it as printk module parameter, so users
+                        could change it dynamically, usually by
+                        /sys/module/printk/parameters/ignore_loglevel.
        ihash_entries=  [KNL]
                        Set number of hash buckets for inode cache.
@@ -1666,6 +1669,11 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                        debugging driver suspend/resume hooks).  This may
                        not work reliably with all consoles, but is known
                        to work with serial and VGA consoles.
+                        To facilitate more flexible debugging, we also add
+                        console_suspend, a printk module parameter to control
+                        it. Users could use console_suspend (usually
+                        /sys/module/printk/parameters/console_suspend) to
+                        turn on/off it dynamically.
        noaliencache    [MM, NUMA, SLAB] Disables the allocation of alien
                        caches in the slab allocator.  Saves per-node memory,
diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt
index 704e474a93df..1f2463671a1a 100644
--- a/Documentation/sysctl/kernel.txt
+++ b/Documentation/sysctl/kernel.txt
@@ -24,6 +24,7 @@ show up in /proc/sys/kernel:
 - bootloader_type            [ X86 only ]
 - bootloader_version         [ X86 only ]
 - callhome                   [ S390 only ]
+- cap_last_cap
 - core_pattern
 - core_pipe_limit
 - core_uses_pid
@@ -155,6 +156,13 @@ on has a service contract with IBM.
 ==============================================================
+cap_last_cap
+Highest valid capability of the running kernel.  Exports
+CAP_LAST_CAP from the kernel.
+==============================================================
 core_pattern:
 core_pattern is used to specify a core dumpfile pattern name.
diff --git a/Documentation/trace/postprocess/trace-vmscan-postprocess.pl b/Documentation/trace/postprocess/trace-vmscan-postprocess.pl
index 12cecc83cd91..4a37c4759cd2 100644
--- a/Documentation/trace/postprocess/trace-vmscan-postprocess.pl
+++ b/Documentation/trace/postprocess/trace-vmscan-postprocess.pl
@@ -379,10 +379,10 @@ EVENT_PROCESS:
                        # To closer match vmstat scanning statistics, only count isolate_both
                        # and isolate_inactive as scanning. isolate_active is rotation
-                        # isolate_inactive == 0
+                        # isolate_inactive == 1
-                        # isolate_active   == 1
+                        # isolate_active   == 2
-                        # isolate_both     == 2
+                        # isolate_both     == 3
-                        if ($isolate_mode != 1) {
+                        if ($isolate_mode != 2) {
                                $perprocesspid{$process_pid}->{HIGH_NR_SCANNED} += $nr_scanned;
                        }
                        $perprocesspid{$process_pid}->{HIGH_NR_CONTIG_DIRTY} += $nr_contig_dirty;
diff --git a/MAINTAINERS b/MAINTAINERS
index d498c70e394a..4befa126852e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -316,6 +316,10 @@ W:	http://wiki.analog.com/AD7879
 S:      Supported
 F:      drivers/input/touchscreen/ad7879.c
+ADDRESS SPACE LAYOUT RANDOMIZATION (ASLR)
+M:      Jiri Kosina <jkosina@suse.cz>
+S:      Maintained
 ADM1025 HARDWARE MONITOR DRIVER
 M:      Jean Delvare <khali@linux-fr.org>
 L:      lm-sensors@lm-sensors.org
@@ -4020,6 +4024,7 @@ M:	Eric Piel <eric.piel@tremplin-utc.net>
 S:      Maintained
 F:      Documentation/misc-devices/lis3lv02d
 F:      drivers/misc/lis3lv02d/
+F:      drivers/platform/x86/hp_accel.c
 LLC (802.2)
 M:      Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
@@ -4974,7 +4979,7 @@ F:	include/linux/i2c-algo-pca.h
 F:      include/linux/i2c-pca-platform.h
 PCI ERROR RECOVERY
-M:      Linas Vepstas <linas@austin.ibm.com>
+M:     Linas Vepstas <linasvepstas@gmail.com>
 L:      linux-pci@vger.kernel.org
 S:      Supported
 F:      Documentation/PCI/pci-error-recovery.txt
diff --git a/arch/alpha/include/asm/unistd.h b/arch/alpha/include/asm/unistd.h
index 4ac48a095f3a..2207fc61665d 100644
--- a/arch/alpha/include/asm/unistd.h
+++ b/arch/alpha/include/asm/unistd.h
@@ -457,10 +457,12 @@
 #define __NR_clock_adjtime              499
 #define __NR_syncfs                     500
 #define __NR_setns                      501
+#define __NR_accept4                    502
+#define __NR_sendmmsg                   503
 #ifdef __KERNEL__
-#define NR_SYSCALLS                     502
+#define NR_SYSCALLS                     504
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S
index 6acea1f96de3..e534e1c5bc11 100644
--- a/arch/alpha/kernel/systbls.S
+++ b/arch/alpha/kernel/systbls.S
@@ -520,6 +520,8 @@ sys_call_table:
        .quad sys_clock_adjtime
        .quad sys_syncfs                        /* 500 */
        .quad sys_setns
+        .quad sys_accept4
+        .quad sys_sendmmsg
        .size sys_call_table, . - sys_call_table
        .type sys_call_table, @object
diff --git a/arch/arm/mach-imx/mach-mx27_3ds.c b/arch/arm/mach-imx/mach-mx27_3ds.c
index 2eafbac2c763..377230497dcc 100644
--- a/arch/arm/mach-imx/mach-mx27_3ds.c
+++ b/arch/arm/mach-imx/mach-mx27_3ds.c
@@ -241,7 +241,7 @@ static struct regulator_init_data gpo_init = {
 };
 static struct regulator_consumer_supply vmmc1_consumers[] = {
-        REGULATOR_SUPPLY("lcd_2v8", NULL),
+        REGULATOR_SUPPLY("vcore", "spi0.0"),
 };
 static struct regulator_init_data vmmc1_init = {
@@ -257,7 +257,7 @@ static struct regulator_init_data vmmc1_init = {
 };
 static struct regulator_consumer_supply vgen_consumers[] = {
-        REGULATOR_SUPPLY("vdd_lcdio", NULL),
+        REGULATOR_SUPPLY("vdd", "spi0.0"),
 };
 static struct regulator_init_data vgen_init = {
@@ -348,8 +348,6 @@ static const struct imx_fb_platform_data mx27_3ds_fb_data __initconst = {
 static struct l4f00242t03_pdata mx27_3ds_lcd_pdata = {
        .reset_gpio             = LCD_RESET,
        .data_enable_gpio       = LCD_ENABLE,
-        .core_supply            = "lcd_2v8",
-        .io_supply              = "vdd_lcdio",
 };
 static struct spi_board_info mx27_3ds_spi_devs[] __initdata = {
diff --git a/arch/arm/mach-imx/mach-mx31_3ds.c b/arch/arm/mach-imx/mach-mx31_3ds.c
index 589066fb3316..6484db525bd7 100644
--- a/arch/arm/mach-imx/mach-mx31_3ds.c
+++ b/arch/arm/mach-imx/mach-mx31_3ds.c
@@ -285,8 +285,6 @@ static struct mx3fb_platform_data mx3fb_pdata __initdata = {
 static struct l4f00242t03_pdata mx31_3ds_l4f00242t03_pdata = {
        .reset_gpio             = IOMUX_TO_GPIO(MX31_PIN_LCS1),
        .data_enable_gpio       = IOMUX_TO_GPIO(MX31_PIN_SER_RS),
-        .core_supply            = "lcd_2v8",
-        .io_supply              = "vdd_lcdio",
 };
 /*
@@ -411,7 +409,7 @@ static struct regulator_init_data vmmc2_init = {
 };
 static struct regulator_consumer_supply vmmc1_consumers[] = {
-        REGULATOR_SUPPLY("lcd_2v8", NULL),
+        REGULATOR_SUPPLY("vcore", "spi0.0"),
        REGULATOR_SUPPLY("cmos_2v8", "soc-camera-pdrv.0"),
 };
@@ -428,7 +426,7 @@ static struct regulator_init_data vmmc1_init = {
 };
 static struct regulator_consumer_supply vgen_consumers[] = {
-        REGULATOR_SUPPLY("vdd_lcdio", NULL),
+        REGULATOR_SUPPLY("vdd", "spi0.0"),
 };
 static struct regulator_init_data vgen_init = {
diff --git a/arch/cris/arch-v10/kernel/kgdb.c b/arch/cris/arch-v10/kernel/kgdb.c
index b9f9c8ce2169..b579dd02e098 100644
--- a/arch/cris/arch-v10/kernel/kgdb.c
+++ b/arch/cris/arch-v10/kernel/kgdb.c
@@ -694,7 +694,7 @@ mem2hex(char *buf, unsigned char *mem, int count)
                /* Valid mem address. */
                for (i = 0; i < count; i++) {
                        ch = *mem++;
-                        buf = pack_hex_byte(buf, ch);
+                        buf = hex_byte_pack(buf, ch);
                }
        }
        
@@ -868,7 +868,7 @@ stub_is_stopped(int sigval)
        /* Send trap type (converted to signal) */
        *ptr++ = 'T';
-        ptr = pack_hex_byte(ptr, sigval);
+        ptr = hex_byte_pack(ptr, sigval);
        /* Send register contents. We probably only need to send the
         * PC, frame pointer and stack pointer here. Other registers will be
@@ -881,7 +881,7 @@ stub_is_stopped(int sigval)
                status = read_register (regno, &reg_cont);
                
                if (status == SUCCESS) {
-                        ptr = pack_hex_byte(ptr, regno);
+                        ptr = hex_byte_pack(ptr, regno);
                        *ptr++ = ':';
                        ptr = mem2hex(ptr, (unsigned char *)&reg_cont,
diff --git a/arch/cris/arch-v32/kernel/kgdb.c b/arch/cris/arch-v32/kernel/kgdb.c
index c0343c3ea7f8..8c1d35cdf00a 100644
--- a/arch/cris/arch-v32/kernel/kgdb.c
+++ b/arch/cris/arch-v32/kernel/kgdb.c
@@ -677,7 +677,7 @@ mem2hex(char *buf, unsigned char *mem, int count)
                /* Valid mem address. */
                for (i = 0; i < count; i++) {
                        ch = *mem++;
-                        buf = pack_hex_byte(buf, ch);
+                        buf = hex_byte_pack(buf, ch);
                }
        }
        /* Terminate properly. */
@@ -695,7 +695,7 @@ mem2hex_nbo(char *buf, unsigned char *mem, int count)
        mem += count - 1;
        for (i = 0; i < count; i++) {
                ch = *mem--;
-                buf = pack_hex_byte(buf, ch);
+                buf = hex_byte_pack(buf, ch);
        }
        /* Terminate properly. */
@@ -880,7 +880,7 @@ stub_is_stopped(int sigval)
        /* Send trap type (converted to signal) */
        *ptr++ = 'T';
-        ptr = pack_hex_byte(ptr, sigval);
+        ptr = hex_byte_pack(ptr, sigval);
        if (((reg.exs & 0xff00) >> 8) == 0xc) {
@@ -988,26 +988,26 @@ stub_is_stopped(int sigval)
        }
        /* Only send PC, frame and stack pointer. */
        read_register(PC, &reg_cont);
-        ptr = pack_hex_byte(ptr, PC);
+        ptr = hex_byte_pack(ptr, PC);
        *ptr++ = ':';
        ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[PC]);
        *ptr++ = ';';
        read_register(R8, &reg_cont);
-        ptr = pack_hex_byte(ptr, R8);
+        ptr = hex_byte_pack(ptr, R8);
        *ptr++ = ':';
        ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[R8]);
        *ptr++ = ';';
        read_register(SP, &reg_cont);
-        ptr = pack_hex_byte(ptr, SP);
+        ptr = hex_byte_pack(ptr, SP);
        *ptr++ = ':';
        ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[SP]);
        *ptr++ = ';';
        /* Send ERP as well; this will save us an entire register fetch in some cases. */
        read_register(ERP, &reg_cont);
-        ptr = pack_hex_byte(ptr, ERP);
+        ptr = hex_byte_pack(ptr, ERP);
        *ptr++ = ':';
        ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[ERP]);
        *ptr++ = ';';
diff --git a/arch/frv/kernel/gdb-stub.c b/arch/frv/kernel/gdb-stub.c
index a4dba6b20bd0..a6d5381c94fe 100644
--- a/arch/frv/kernel/gdb-stub.c
+++ b/arch/frv/kernel/gdb-stub.c
@@ -672,7 +672,7 @@ static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fa
        if ((uint32_t)mem&1 && count>=1) {
                if (!gdbstub_read_byte(mem,ch))
                        return NULL;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
                mem++;
                count--;
        }
@@ -680,8 +680,8 @@ static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fa
        if ((uint32_t)mem&3 && count>=2) {
                if (!gdbstub_read_word(mem,(uint16_t *)ch))
                        return NULL;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
                mem += 2;
                count -= 2;
        }
@@ -689,10 +689,10 @@ static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fa
        while (count>=4) {
                if (!gdbstub_read_dword(mem,(uint32_t *)ch))
                        return NULL;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
-                buf = pack_hex_byte(buf, ch[2]);
+                buf = hex_byte_pack(buf, ch[2]);
-                buf = pack_hex_byte(buf, ch[3]);
+                buf = hex_byte_pack(buf, ch[3]);
                mem += 4;
                count -= 4;
        }
@@ -700,8 +700,8 @@ static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fa
        if (count>=2) {
                if (!gdbstub_read_word(mem,(uint16_t *)ch))
                        return NULL;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
                mem += 2;
                count -= 2;
        }
@@ -709,7 +709,7 @@ static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fa
        if (count>=1) {
                if (!gdbstub_read_byte(mem,ch))
                        return NULL;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
        }
        *buf = 0;
@@ -1498,21 +1498,21 @@ void gdbstub(int sigval)
                ptr = mem2hex(title, ptr, sizeof(title) - 1,0);
                hx = hex_asc_hi(brr >> 24);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(brr >> 24);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(brr >> 16);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(brr >> 16);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(brr >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(brr >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(brr);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(brr);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
                *ptr = 0;
@@ -1526,10 +1526,10 @@ void gdbstub(int sigval)
        /* Send trap type (converted to signal) */
        *ptr++ = 'T';
-        ptr = pack_hex_byte(ptr, sigval);
+        ptr = hex_byte_pack(ptr, sigval);
        /* Send Error PC */
-        ptr = pack_hex_byte(ptr, GDB_REG_PC);
+        ptr = hex_byte_pack(ptr, GDB_REG_PC);
        *ptr++ = ':';
        ptr = mem2hex(&__debug_frame->pc, ptr, 4, 0);
        *ptr++ = ';';
@@ -1537,7 +1537,7 @@ void gdbstub(int sigval)
        /*
         * Send frame pointer
         */
-        ptr = pack_hex_byte(ptr, GDB_REG_FP);
+        ptr = hex_byte_pack(ptr, GDB_REG_FP);
        *ptr++ = ':';
        ptr = mem2hex(&__debug_frame->fp, ptr, 4, 0);
        *ptr++ = ';';
@@ -1545,7 +1545,7 @@ void gdbstub(int sigval)
        /*
         * Send stack pointer
         */
-        ptr = pack_hex_byte(ptr, GDB_REG_SP);
+        ptr = hex_byte_pack(ptr, GDB_REG_SP);
        *ptr++ = ':';
        ptr = mem2hex(&__debug_frame->sp, ptr, 4, 0);
        *ptr++ = ';';
diff --git a/arch/mn10300/kernel/gdb-stub.c b/arch/mn10300/kernel/gdb-stub.c
index 538266b2c9bc..522eb8a9b60d 100644
--- a/arch/mn10300/kernel/gdb-stub.c
+++ b/arch/mn10300/kernel/gdb-stub.c
@@ -798,7 +798,7 @@ unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
        if ((u32) mem & 1 && count >= 1) {
                if (gdbstub_read_byte(mem, ch) != 0)
                        return 0;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
                mem++;
                count--;
        }
@@ -806,8 +806,8 @@ unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
        if ((u32) mem & 3 && count >= 2) {
                if (gdbstub_read_word(mem, ch) != 0)
                        return 0;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
                mem += 2;
                count -= 2;
        }
@@ -815,10 +815,10 @@ unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
        while (count >= 4) {
                if (gdbstub_read_dword(mem, ch) != 0)
                        return 0;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
-                buf = pack_hex_byte(buf, ch[2]);
+                buf = hex_byte_pack(buf, ch[2]);
-                buf = pack_hex_byte(buf, ch[3]);
+                buf = hex_byte_pack(buf, ch[3]);
                mem += 4;
                count -= 4;
        }
@@ -826,8 +826,8 @@ unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
        if (count >= 2) {
                if (gdbstub_read_word(mem, ch) != 0)
                        return 0;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
-                buf = pack_hex_byte(buf, ch[1]);
+                buf = hex_byte_pack(buf, ch[1]);
                mem += 2;
                count -= 2;
        }
@@ -835,7 +835,7 @@ unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
        if (count >= 1) {
                if (gdbstub_read_byte(mem, ch) != 0)
                        return 0;
-                buf = pack_hex_byte(buf, ch[0]);
+                buf = hex_byte_pack(buf, ch[0]);
        }
        *buf = 0;
@@ -1273,13 +1273,13 @@ static int gdbstub(struct pt_regs *regs, enum exception_code excep)
                ptr = mem2hex(title, ptr, sizeof(title) - 1, 0);
                hx = hex_asc_hi(excep >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(excep >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(excep);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(excep);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
                *ptr = 0;
@@ -1291,21 +1291,21 @@ static int gdbstub(struct pt_regs *regs, enum exception_code excep)
                ptr = mem2hex(tbcberr, ptr, sizeof(tbcberr) - 1, 0);
                hx = hex_asc_hi(bcberr >> 24);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(bcberr >> 24);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(bcberr >> 16);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(bcberr >> 16);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(bcberr >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(bcberr >> 8);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_hi(bcberr);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                hx = hex_asc_lo(bcberr);
-                ptr = pack_hex_byte(ptr, hx);
+                ptr = hex_byte_pack(ptr, hx);
                ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
                *ptr = 0;
@@ -1321,12 +1321,12 @@ static int gdbstub(struct pt_regs *regs, enum exception_code excep)
         * Send trap type (converted to signal)
         */
        *ptr++ = 'T';
-        ptr = pack_hex_byte(ptr, sigval);
+        ptr = hex_byte_pack(ptr, sigval);
        /*
         * Send Error PC
         */
-        ptr = pack_hex_byte(ptr, GDB_REGID_PC);
+        ptr = hex_byte_pack(ptr, GDB_REGID_PC);
        *ptr++ = ':';
        ptr = mem2hex(&regs->pc, ptr, 4, 0);
        *ptr++ = ';';
@@ -1334,7 +1334,7 @@ static int gdbstub(struct pt_regs *regs, enum exception_code excep)
        /*
         * Send frame pointer
         */
-        ptr = pack_hex_byte(ptr, GDB_REGID_FP);
+        ptr = hex_byte_pack(ptr, GDB_REGID_FP);
        *ptr++ = ':';
        ptr = mem2hex(&regs->a3, ptr, 4, 0);
        *ptr++ = ';';
@@ -1343,7 +1343,7 @@ static int gdbstub(struct pt_regs *regs, enum exception_code excep)
         * Send stack pointer
         */
        ssp = (unsigned long) (regs + 1);
-        ptr = pack_hex_byte(ptr, GDB_REGID_SP);
+        ptr = hex_byte_pack(ptr, GDB_REGID_SP);
        *ptr++ = ':';
        ptr = mem2hex(&ssp, ptr, 4, 0);
        *ptr++ = ';';
diff --git a/arch/powerpc/include/asm/systbl.h b/arch/powerpc/include/asm/systbl.h
index fa0d27a400de..559ae1ee6706 100644
--- a/arch/powerpc/include/asm/systbl.h
+++ b/arch/powerpc/include/asm/systbl.h
@@ -354,3 +354,5 @@ COMPAT_SYS_SPU(clock_adjtime)
 SYSCALL_SPU(syncfs)
 COMPAT_SYS_SPU(sendmmsg)
 SYSCALL_SPU(setns)
+COMPAT_SYS(process_vm_readv)
+COMPAT_SYS(process_vm_writev)
diff --git a/arch/powerpc/include/asm/unistd.h b/arch/powerpc/include/asm/unistd.h
index b8b3f599362b..d3d1b5efd7eb 100644
--- a/arch/powerpc/include/asm/unistd.h
+++ b/arch/powerpc/include/asm/unistd.h
@@ -373,10 +373,12 @@
 #define __NR_syncfs             348
 #define __NR_sendmmsg           349
 #define __NR_setns              350
+#define __NR_process_vm_readv   351
+#define __NR_process_vm_writev  352
 #ifdef __KERNEL__
-#define __NR_syscalls           351
+#define __NR_syscalls           353
 #define __NR__exit __NR_exit
 #define NR_syscalls     __NR_syscalls
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index 54edb207ff3a..a6253ec1b284 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -850,4 +850,6 @@ ia32_sys_call_table:
        .quad sys_syncfs
        .quad compat_sys_sendmmsg       /* 345 */
        .quad sys_setns
+        .quad compat_sys_process_vm_readv
+        .quad compat_sys_process_vm_writev
 ia32_syscall_end:
diff --git a/arch/x86/include/asm/unistd_32.h b/arch/x86/include/asm/unistd_32.h
index 593485b38ab3..599c77d38f33 100644
--- a/arch/x86/include/asm/unistd_32.h
+++ b/arch/x86/include/asm/unistd_32.h
@@ -352,10 +352,12 @@
 #define __NR_syncfs             344
 #define __NR_sendmmsg           345
 #define __NR_setns              346
+#define __NR_process_vm_readv   347
+#define __NR_process_vm_writev  348
 #ifdef __KERNEL__
-#define NR_syscalls 347
+#define NR_syscalls 349
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
index 0a6ba337a2eb..0431f193c3f2 100644
--- a/arch/x86/include/asm/unistd_64.h
+++ b/arch/x86/include/asm/unistd_64.h
@@ -682,6 +682,10 @@ __SYSCALL(__NR_sendmmsg, sys_sendmmsg)
 __SYSCALL(__NR_setns, sys_setns)
 #define __NR_getcpu                             309
 __SYSCALL(__NR_getcpu, sys_getcpu)
+#define __NR_process_vm_readv                   310
+__SYSCALL(__NR_process_vm_readv, sys_process_vm_readv)
+#define __NR_process_vm_writev                  311
+__SYSCALL(__NR_process_vm_writev, sys_process_vm_writev)
 #ifndef __NO_STUBS
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index bc19be332bc9..9a0e31293920 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -346,3 +346,5 @@ ENTRY(sys_call_table)
        .long sys_syncfs
        .long sys_sendmmsg              /* 345 */
        .long sys_setns
+        .long sys_process_vm_readv
+        .long sys_process_vm_writev
diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c
index a61e7815a2a9..6460487e41b5 100644
--- a/drivers/hwmon/hwmon.c
+++ b/drivers/hwmon/hwmon.c
@@ -27,8 +27,7 @@
 static struct class *hwmon_class;
-static DEFINE_IDR(hwmon_idr);
+static DEFINE_IDA(hwmon_ida);
-static DEFINE_SPINLOCK(idr_lock);
 /**
 * hwmon_device_register - register w/ hwmon
@@ -42,30 +41,17 @@ static DEFINE_SPINLOCK(idr_lock);
 struct device *hwmon_device_register(struct device *dev)
 {
        struct device *hwdev;
-        int id, err;
+        int id;
-again:
-        if (unlikely(idr_pre_get(&hwmon_idr, GFP_KERNEL) == 0))
-                return ERR_PTR(-ENOMEM);
-        spin_lock(&idr_lock);
-        err = idr_get_new(&hwmon_idr, NULL, &id);
-        spin_unlock(&idr_lock);
-        if (unlikely(err == -EAGAIN))
+        id = ida_simple_get(&hwmon_ida, 0, 0, GFP_KERNEL);
-                goto again;
+        if (id < 0)
-        else if (unlikely(err))
+                return ERR_PTR(id);
-                return ERR_PTR(err);
-        id = id & MAX_ID_MASK;
        hwdev = device_create(hwmon_class, dev, MKDEV(0, 0), NULL,
                              HWMON_ID_FORMAT, id);
-        if (IS_ERR(hwdev)) {
+        if (IS_ERR(hwdev))
-                spin_lock(&idr_lock);
+                ida_simple_remove(&hwmon_ida, id);
-                idr_remove(&hwmon_idr, id);
-                spin_unlock(&idr_lock);
-        }
        return hwdev;
 }
@@ -81,9 +67,7 @@ void hwmon_device_unregister(struct device *dev)
        if (likely(sscanf(dev_name(dev), HWMON_ID_FORMAT, &id) == 1)) {
                device_unregister(dev);
-                spin_lock(&idr_lock);
+                ida_simple_remove(&hwmon_ida, id);
-                idr_remove(&hwmon_idr, id);
-                spin_unlock(&idr_lock);
        } else
                dev_dbg(dev->parent,
                        "hwmon_device_unregister() failed: bad class ID!\n");
diff --git a/drivers/hwmon/ibmaem.c b/drivers/hwmon/ibmaem.c
index c316294c48b4..783d0c17b762 100644
--- a/drivers/hwmon/ibmaem.c
+++ b/drivers/hwmon/ibmaem.c
@@ -88,8 +88,7 @@
 #define AEM_MIN_POWER_INTERVAL  200
 #define UJ_PER_MJ               1000L
-static DEFINE_IDR(aem_idr);
+static DEFINE_IDA(aem_ida);
-static DEFINE_SPINLOCK(aem_idr_lock);
 static struct platform_driver aem_driver = {
        .driver = {
@@ -356,38 +355,6 @@ static void aem_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data)
        complete(&data->read_complete);
 }
-/* ID functions */
-/* Obtain an id */
-static int aem_idr_get(int *id)
-{
-        int i, err;
-again:
-        if (unlikely(!idr_pre_get(&aem_idr, GFP_KERNEL)))
-                return -ENOMEM;
-        spin_lock(&aem_idr_lock);
-        err = idr_get_new(&aem_idr, NULL, &i);
-        spin_unlock(&aem_idr_lock);
-        if (unlikely(err == -EAGAIN))
-                goto again;
-        else if (unlikely(err))
-                return err;
-        *id = i & MAX_ID_MASK;
-        return 0;
-}
-/* Release an object ID */
-static void aem_idr_put(int id)
-{
-        spin_lock(&aem_idr_lock);
-        idr_remove(&aem_idr, id);
-        spin_unlock(&aem_idr_lock);
-}
 /* Sensor support functions */
 /* Read a sensor value */
@@ -530,7 +497,7 @@ static void aem_delete(struct aem_data *data)
        ipmi_destroy_user(data->ipmi.user);
        platform_set_drvdata(data->pdev, NULL);
        platform_device_unregister(data->pdev);
-        aem_idr_put(data->id);
+        ida_simple_remove(&aem_ida, data->id);
        kfree(data);
 }
@@ -587,7 +554,8 @@ static int aem_init_aem1_inst(struct aem_ipmi_data *probe, u8 module_handle)
                data->power_period[i] = AEM_DEFAULT_POWER_INTERVAL;
        /* Create sub-device for this fw instance */
-        if (aem_idr_get(&data->id))
+        data->id = ida_simple_get(&aem_ida, 0, 0, GFP_KERNEL);
+        if (data->id < 0)
                goto id_err;
        data->pdev = platform_device_alloc(DRVNAME, data->id);
@@ -638,7 +606,7 @@ ipmi_err:
        platform_set_drvdata(data->pdev, NULL);
        platform_device_unregister(data->pdev);
 dev_err:
-        aem_idr_put(data->id);
+        ida_simple_remove(&aem_ida, data->id);
 id_err:
        kfree(data);
@@ -720,7 +688,8 @@ static int aem_init_aem2_inst(struct aem_ipmi_data *probe,
                data->power_period[i] = AEM_DEFAULT_POWER_INTERVAL;
        /* Create sub-device for this fw instance */
-        if (aem_idr_get(&data->id))
+        data->id = ida_simple_get(&aem_ida, 0, 0, GFP_KERNEL);
+        if (data->id < 0)
                goto id_err;
        data->pdev = platform_device_alloc(DRVNAME, data->id);
@@ -771,7 +740,7 @@ ipmi_err:
        platform_set_drvdata(data->pdev, NULL);
        platform_device_unregister(data->pdev);
 dev_err:
-        aem_idr_put(data->id);
+        ida_simple_remove(&aem_ida, data->id);
 id_err:
        kfree(data);
diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c
index b645e558876f..9155f91d66bf 100644
--- a/drivers/infiniband/core/umem.c
+++ b/drivers/infiniband/core/umem.c
@@ -136,7 +136,7 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
        down_write(&current->mm->mmap_sem);
-        locked     = npages + current->mm->locked_vm;
+        locked     = npages + current->mm->pinned_vm;
        lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
        if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
@@ -206,7 +206,7 @@ out:
                __ib_umem_release(context->device, umem, 0);
                kfree(umem);
        } else
-                current->mm->locked_vm = locked;
+                current->mm->pinned_vm = locked;
        up_write(&current->mm->mmap_sem);
        if (vma_list)
@@ -222,7 +222,7 @@ static void ib_umem_account(struct work_struct *work)
        struct ib_umem *umem = container_of(work, struct ib_umem, work);
        down_write(&umem->mm->mmap_sem);
-        umem->mm->locked_vm -= umem->diff;
+        umem->mm->pinned_vm -= umem->diff;
        up_write(&umem->mm->mmap_sem);
        mmput(umem->mm);
        kfree(umem);
diff --git a/drivers/infiniband/hw/ipath/ipath_user_pages.c b/drivers/infiniband/hw/ipath/ipath_user_pages.c
index cfed5399f074..dc66c4506916 100644
--- a/drivers/infiniband/hw/ipath/ipath_user_pages.c
+++ b/drivers/infiniband/hw/ipath/ipath_user_pages.c
@@ -79,7 +79,7 @@ static int __ipath_get_user_pages(unsigned long start_page, size_t num_pages,
                        goto bail_release;
        }
-        current->mm->locked_vm += num_pages;
+        current->mm->pinned_vm += num_pages;
        ret = 0;
        goto bail;
@@ -178,7 +178,7 @@ void ipath_release_user_pages(struct page **p, size_t num_pages)
        __ipath_release_user_pages(p, num_pages, 1);
-        current->mm->locked_vm -= num_pages;
+        current->mm->pinned_vm -= num_pages;
        up_write(&current->mm->mmap_sem);
 }
@@ -195,7 +195,7 @@ static void user_pages_account(struct work_struct *_work)
                container_of(_work, struct ipath_user_pages_work, work);
        down_write(&work->mm->mmap_sem);
-        work->mm->locked_vm -= work->num_pages;
+        work->mm->pinned_vm -= work->num_pages;
        up_write(&work->mm->mmap_sem);
        mmput(work->mm);
        kfree(work);
diff --git a/drivers/infiniband/hw/qib/qib_user_pages.c b/drivers/infiniband/hw/qib/qib_user_pages.c
index 7689e49c13c9..2bc1d2b96298 100644
--- a/drivers/infiniband/hw/qib/qib_user_pages.c
+++ b/drivers/infiniband/hw/qib/qib_user_pages.c
@@ -74,7 +74,7 @@ static int __qib_get_user_pages(unsigned long start_page, size_t num_pages,
                        goto bail_release;
        }
-        current->mm->locked_vm += num_pages;
+        current->mm->pinned_vm += num_pages;
        ret = 0;
        goto bail;
@@ -151,7 +151,7 @@ void qib_release_user_pages(struct page **p, size_t num_pages)
        __qib_release_user_pages(p, num_pages, 1);
        if (current->mm) {
-                current->mm->locked_vm -= num_pages;
+                current->mm->pinned_vm -= num_pages;
                up_write(&current->mm->mmap_sem);
        }
 }
diff --git a/drivers/isdn/hisax/callc.c b/drivers/isdn/hisax/callc.c
index 37e685eafd24..c4897e1075d8 100644
--- a/drivers/isdn/hisax/callc.c
+++ b/drivers/isdn/hisax/callc.c
@@ -65,7 +65,7 @@ hisax_findcard(int driverid)
        return (struct IsdnCardState *) 0;
 }
-static __attribute__((format(printf, 3, 4))) void
+static __printf(3, 4) void
 link_debug(struct Channel *chanp, int direction, char *fmt, ...)
 {
        va_list args;
@@ -1068,7 +1068,7 @@ init_d_st(struct Channel *chanp)
        return 0;
 }
-static __attribute__((format(printf, 2, 3))) void
+static __printf(2, 3) void
 callc_debug(struct FsmInst *fi, char *fmt, ...)
 {
        va_list args;
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 0a5c42a3f125..aff45a11a92d 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -1287,9 +1287,9 @@ int jiftime(char *s, long mark);
 int HiSax_command(isdn_ctrl * ic);
 int HiSax_writebuf_skb(int id, int chan, int ack, struct sk_buff *skb);
-__attribute__((format(printf, 3, 4)))
+__printf(3, 4)
 void HiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, ...);
-__attribute__((format(printf, 3, 0)))
+__printf(3, 0)
 void VHiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, va_list args);
 void HiSax_reportcard(int cardnr, int sel);
 int QuickHex(char *txt, u_char * p, int cnt);
diff --git a/drivers/isdn/hisax/isdnl1.h b/drivers/isdn/hisax/isdnl1.h
index 425d86116f2b..66ddcab19bba 100644
--- a/drivers/isdn/hisax/isdnl1.h
+++ b/drivers/isdn/hisax/isdnl1.h
@@ -21,7 +21,7 @@
 #define B_XMTBUFREADY   1
 #define B_ACKPENDING    2
-__attribute__((format(printf, 2, 3)))
+__printf(2, 3)
 void debugl1(struct IsdnCardState *cs, char *fmt, ...);
 void DChannel_proc_xmt(struct IsdnCardState *cs);
 void DChannel_proc_rcv(struct IsdnCardState *cs);
diff --git a/drivers/isdn/hisax/isdnl3.c b/drivers/isdn/hisax/isdnl3.c
index ad291f21b201..1c24e4457b6f 100644
--- a/drivers/isdn/hisax/isdnl3.c
+++ b/drivers/isdn/hisax/isdnl3.c
@@ -66,7 +66,7 @@ static char *strL3Event[] =
        "EV_TIMEOUT",
 };
-static __attribute__((format(printf, 2, 3))) void
+static __printf(2, 3) void
 l3m_debug(struct FsmInst *fi, char *fmt, ...)
 {
        va_list args;
diff --git a/drivers/isdn/hisax/st5481_d.c b/drivers/isdn/hisax/st5481_d.c
index 44082637a09f..db247b79e561 100644
--- a/drivers/isdn/hisax/st5481_d.c
+++ b/drivers/isdn/hisax/st5481_d.c
@@ -167,7 +167,7 @@ static struct FsmNode L1FnList[] __initdata =
        {ST_L1_F8, EV_IND_RSY,           l1_ignore},
 };
-static __attribute__((format(printf, 2, 3)))
+static __printf(2, 3)
 void l1m_debug(struct FsmInst *fi, char *fmt, ...)
 {
        va_list args;
@@ -270,7 +270,7 @@ static char *strDoutEvent[] =
        "EV_DOUT_UNDERRUN",
 };
-static __attribute__((format(printf, 2, 3)))
+static __printf(2, 3)
 void dout_debug(struct FsmInst *fi, char *fmt, ...)
 {
        va_list args;
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index dc7caaddecf4..ff203a421863 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -375,6 +375,18 @@ config LEDS_ASIC3
          cannot be used. This driver supports hardware blinking with an on+off
          period from 62ms to 125s. Say Y to enable LEDs on the HP iPAQ hx4700.
+config LEDS_RENESAS_TPU
+        bool "LED support for Renesas TPU"
+        depends on LEDS_CLASS && HAVE_CLK && GENERIC_GPIO
+        help
+          This option enables build of the LED TPU platform driver,
+          suitable to drive any TPU channel on newer Renesas SoCs.
+          The driver controls the GPIO pin connected to the LED via
+          the GPIO framework and expects the LED to be connected to
+          a pin that can be driven in both GPIO mode and using TPU
+          pin function. The latter to support brightness control.
+          Brightness control is supported but hardware blinking is not.
 config LEDS_TRIGGERS
        bool "LED Trigger support"
        depends on LEDS_CLASS
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index a0a1b89d78a8..e4f6bf568880 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -42,6 +42,7 @@ obj-$(CONFIG_LEDS_MC13783)		+= leds-mc13783.o
 obj-$(CONFIG_LEDS_NS2)                  += leds-ns2.o
 obj-$(CONFIG_LEDS_NETXBIG)              += leds-netxbig.o
 obj-$(CONFIG_LEDS_ASIC3)                += leds-asic3.o
+obj-$(CONFIG_LEDS_RENESAS_TPU)          += leds-renesas-tpu.o
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index dc3d3d83191a..661b692573e7 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -267,9 +267,14 @@ void led_blink_set(struct led_classdev *led_cdev,
                   unsigned long *delay_on,
                   unsigned long *delay_off)
 {
+        del_timer_sync(&led_cdev->blink_timer);
        if (led_cdev->blink_set &&
-            !led_cdev->blink_set(led_cdev, delay_on, delay_off))
+            !led_cdev->blink_set(led_cdev, delay_on, delay_off)) {
+                led_cdev->blink_delay_on = *delay_on;
+                led_cdev->blink_delay_off = *delay_off;
                return;
+        }
        /* blink with 1 Hz as default if nothing specified */
        if (!*delay_on && !*delay_off)
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index 4bebae733349..6f1ff93d7cec 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -261,9 +261,12 @@ void led_trigger_register_simple(const char *name, struct led_trigger **tp)
        if (trigger) {
                trigger->name = name;
                err = led_trigger_register(trigger);
-                if (err < 0)
+                if (err < 0) {
+                        kfree(trigger);
+                        trigger = NULL;
                        printk(KERN_WARNING "LED trigger %s failed to register"
                                " (%d)\n", name, err);
+                }
        } else
                printk(KERN_WARNING "LED trigger %s failed to register"
                        " (no memory)\n", name);
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index 3d8bc327a68d..504cc26c7e4b 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -121,7 +121,7 @@ static int __devinit create_gpio_led(const struct gpio_led *template,
        }
        led_dat->cdev.brightness_set = gpio_led_set;
        if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP)
-                state = !!gpio_get_value(led_dat->gpio) ^ led_dat->active_low;
+                state = !!gpio_get_value_cansleep(led_dat->gpio) ^ led_dat->active_low;
        else
                state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
        led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
diff --git a/drivers/leds/leds-lm3530.c b/drivers/leds/leds-lm3530.c
index 3dd7090a9a9b..4dc510fdfa06 100644
--- a/drivers/leds/leds-lm3530.c
+++ b/drivers/leds/leds-lm3530.c
@@ -421,7 +421,6 @@ err_class_register:
 err_reg_init:
        regulator_put(drvdata->regulator);
 err_regulator_get:
-        i2c_set_clientdata(client, NULL);
        kfree(drvdata);
 err_out:
        return err;
@@ -449,7 +448,7 @@ MODULE_DEVICE_TABLE(i2c, lm3530_id);
 static struct i2c_driver lm3530_i2c_driver = {
        .probe = lm3530_probe,
-        .remove = lm3530_remove,
+        .remove = __devexit_p(lm3530_remove),
        .id_table = lm3530_id,
        .driver = {
                .name = LM3530_NAME,
diff --git a/drivers/leds/leds-lp5521.c b/drivers/leds/leds-lp5521.c
index 9fc122c81f06..cb641f1b3342 100644
--- a/drivers/leds/leds-lp5521.c
+++ b/drivers/leds/leds-lp5521.c
@@ -97,6 +97,9 @@
 /* Status */
 #define LP5521_EXT_CLK_USED             0x08
+/* default R channel current register value */
+#define LP5521_REG_R_CURR_DEFAULT       0xAF
 struct lp5521_engine {
        int             id;
        u8              mode;
@@ -175,14 +178,14 @@ static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
                mode = LP5521_CMD_DIRECT;
        ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
+        if (ret < 0)
+                return ret;
        /* set mode only for this engine */
        engine_state &= ~(engine->engine_mask);
        mode &= engine->engine_mask;
        engine_state |= mode;
-        ret |= lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
+        return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
-        return ret;
 }
 static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
@@ -643,6 +646,7 @@ static int __devinit lp5521_probe(struct i2c_client *client,
        struct lp5521_chip              *chip;
        struct lp5521_platform_data     *pdata;
        int ret, i, led;
+        u8 buf;
        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
        if (!chip)
@@ -681,6 +685,20 @@ static int __devinit lp5521_probe(struct i2c_client *client,
                                     * Exact value is not available. 10 - 20ms
                                     * appears to be enough for reset.
                                     */
+        /*
+         * Make sure that the chip is reset by reading back the r channel
+         * current reg. This is dummy read is required on some platforms -
+         * otherwise further access to the R G B channels in the
+         * LP5521_REG_ENABLE register will not have any effect - strange!
+         */
+        lp5521_read(client, LP5521_REG_R_CURRENT, &buf);
+        if (buf != LP5521_REG_R_CURR_DEFAULT) {
+                dev_err(&client->dev, "error in reseting chip\n");
+                goto fail2;
+        }
+        usleep_range(10000, 20000);
        ret = lp5521_detect(client);
        if (ret) {
diff --git a/drivers/leds/leds-renesas-tpu.c b/drivers/leds/leds-renesas-tpu.c
new file mode 100644
index 000000000000..3ee540eb127e
--- /dev/null
+++ b/drivers/leds/leds-renesas-tpu.c
@@ -0,0 +1,357 @@
+/*
+ * LED control using Renesas TPU
+ *
+ *  Copyright (C) 2011 Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/printk.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/leds.h>
+#include <linux/platform_data/leds-renesas-tpu.h>
+#include <linux/gpio.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
+#include <linux/workqueue.h>
+enum r_tpu_pin { R_TPU_PIN_UNUSED, R_TPU_PIN_GPIO, R_TPU_PIN_GPIO_FN };
+enum r_tpu_timer { R_TPU_TIMER_UNUSED, R_TPU_TIMER_ON };
+struct r_tpu_priv {
+        struct led_classdev ldev;
+        void __iomem *mapbase;
+        struct clk *clk;
+        struct platform_device *pdev;
+        enum r_tpu_pin pin_state;
+        enum r_tpu_timer timer_state;
+        unsigned long min_rate;
+        unsigned int refresh_rate;
+        struct work_struct work;
+        enum led_brightness new_brightness;
+};
+static DEFINE_SPINLOCK(r_tpu_lock);
+#define TSTR -1 /* Timer start register (shared register) */
+#define TCR  0 /* Timer control register (+0x00) */
+#define TMDR 1 /* Timer mode register (+0x04) */
+#define TIOR 2 /* Timer I/O control register (+0x08) */
+#define TIER 3 /* Timer interrupt enable register (+0x0c) */
+#define TSR  4 /* Timer status register (+0x10) */
+#define TCNT 5 /* Timer counter (+0x14) */
+#define TGRA 6 /* Timer general register A (+0x18) */
+#define TGRB 7 /* Timer general register B (+0x1c) */
+#define TGRC 8 /* Timer general register C (+0x20) */
+#define TGRD 9 /* Timer general register D (+0x24) */
+static inline unsigned short r_tpu_read(struct r_tpu_priv *p, int reg_nr)
+{
+        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs = reg_nr << 2;
+        if (reg_nr == TSTR)
+                return ioread16(base - cfg->channel_offset);
+        return ioread16(base + offs);
+}
+static inline void r_tpu_write(struct r_tpu_priv *p, int reg_nr,
+                               unsigned short value)
+{
+        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs = reg_nr << 2;
+        if (reg_nr == TSTR) {
+                iowrite16(value, base - cfg->channel_offset);
+                return;
+        }
+        iowrite16(value, base + offs);
+}
+static void r_tpu_start_stop_ch(struct r_tpu_priv *p, int start)
+{
+        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
+        unsigned long flags, value;
+        /* start stop register shared by multiple timer channels */
+        spin_lock_irqsave(&r_tpu_lock, flags);
+        value = r_tpu_read(p, TSTR);
+        if (start)
+                value |= 1 << cfg->timer_bit;
+        else
+                value &= ~(1 << cfg->timer_bit);
+        r_tpu_write(p, TSTR, value);
+        spin_unlock_irqrestore(&r_tpu_lock, flags);
+}
+static int r_tpu_enable(struct r_tpu_priv *p, enum led_brightness brightness)
+{
+        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
+        int prescaler[] = { 1, 4, 16, 64 };
+        int k, ret;
+        unsigned long rate, tmp;
+        if (p->timer_state == R_TPU_TIMER_ON)
+                return 0;
+        /* wake up device and enable clock */
+        pm_runtime_get_sync(&p->pdev->dev);
+        ret = clk_enable(p->clk);
+        if (ret) {
+                dev_err(&p->pdev->dev, "cannot enable clock\n");
+                return ret;
+        }
+        /* make sure channel is disabled */
+        r_tpu_start_stop_ch(p, 0);
+        /* get clock rate after enabling it */
+        rate = clk_get_rate(p->clk);
+        /* pick the lowest acceptable rate */
+        for (k = 0; k < ARRAY_SIZE(prescaler); k++)
+                if ((rate / prescaler[k]) < p->min_rate)
+                        break;
+        if (!k) {
+                dev_err(&p->pdev->dev, "clock rate mismatch\n");
+                goto err0;
+        }
+        dev_dbg(&p->pdev->dev, "rate = %lu, prescaler %u\n",
+                rate, prescaler[k - 1]);
+        /* clear TCNT on TGRB match, count on rising edge, set prescaler */
+        r_tpu_write(p, TCR, 0x0040 | (k - 1));
+        /* output 0 until TGRA, output 1 until TGRB */
+        r_tpu_write(p, TIOR, 0x0002);
+        rate /= prescaler[k - 1] * p->refresh_rate;
+        r_tpu_write(p, TGRB, rate);
+        dev_dbg(&p->pdev->dev, "TRGB = 0x%04lx\n", rate);
+        tmp = (cfg->max_brightness - brightness) * rate;
+        r_tpu_write(p, TGRA, tmp / cfg->max_brightness);
+        dev_dbg(&p->pdev->dev, "TRGA = 0x%04lx\n", tmp / cfg->max_brightness);
+        /* PWM mode */
+        r_tpu_write(p, TMDR, 0x0002);
+        /* enable channel */
+        r_tpu_start_stop_ch(p, 1);
+        p->timer_state = R_TPU_TIMER_ON;
+        return 0;
+ err0:
+        clk_disable(p->clk);
+        pm_runtime_put_sync(&p->pdev->dev);
+        return -ENOTSUPP;
+}
+static void r_tpu_disable(struct r_tpu_priv *p)
+{
+        if (p->timer_state == R_TPU_TIMER_UNUSED)
+                return;
+        /* disable channel */
+        r_tpu_start_stop_ch(p, 0);
+        /* stop clock and mark device as idle */
+        clk_disable(p->clk);
+        pm_runtime_put_sync(&p->pdev->dev);
+        p->timer_state = R_TPU_TIMER_UNUSED;
+}
+static void r_tpu_set_pin(struct r_tpu_priv *p, enum r_tpu_pin new_state,
+                          enum led_brightness brightness)
+{
+        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
+        if (p->pin_state == new_state) {
+                if (p->pin_state == R_TPU_PIN_GPIO)
+                        gpio_set_value(cfg->pin_gpio, brightness);
+                return;
+        }
+        if (p->pin_state == R_TPU_PIN_GPIO)
+                gpio_free(cfg->pin_gpio);
+        if (p->pin_state == R_TPU_PIN_GPIO_FN)
+                gpio_free(cfg->pin_gpio_fn);
+        if (new_state == R_TPU_PIN_GPIO) {
+                gpio_request(cfg->pin_gpio, cfg->name);
+                gpio_direction_output(cfg->pin_gpio, !!brightness);
+        }
+        if (new_state == R_TPU_PIN_GPIO_FN)
+                gpio_request(cfg->pin_gpio_fn, cfg->name);
+        p->pin_state = new_state;
+}
+static void r_tpu_work(struct work_struct *work)
+{
+        struct r_tpu_priv *p = container_of(work, struct r_tpu_priv, work);
+        enum led_brightness brightness = p->new_brightness;
+        r_tpu_disable(p);
+        /* off and maximum are handled as GPIO pins, in between PWM */
+        if ((brightness == 0) || (brightness == p->ldev.max_brightness))
+                r_tpu_set_pin(p, R_TPU_PIN_GPIO, brightness);
+        else {
+                r_tpu_set_pin(p, R_TPU_PIN_GPIO_FN, 0);
+                r_tpu_enable(p, brightness);
+        }
+}
+static void r_tpu_set_brightness(struct led_classdev *ldev,
+                                 enum led_brightness brightness)
+{
+        struct r_tpu_priv *p = container_of(ldev, struct r_tpu_priv, ldev);
+        p->new_brightness = brightness;
+        schedule_work(&p->work);
+}
+static int __devinit r_tpu_probe(struct platform_device *pdev)
+{
+        struct led_renesas_tpu_config *cfg = pdev->dev.platform_data;
+        struct r_tpu_priv *p;
+        struct resource *res;
+        int ret = -ENXIO;
+        if (!cfg) {
+                dev_err(&pdev->dev, "missing platform data\n");
+                goto err0;
+        }
+        p = kzalloc(sizeof(*p), GFP_KERNEL);
+        if (p == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                ret = -ENOMEM;
+                goto err0;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get I/O memory\n");
+                goto err1;
+        }
+        /* map memory, let mapbase point to our channel */
+        p->mapbase = ioremap_nocache(res->start, resource_size(res));
+        if (p->mapbase == NULL) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                goto err1;
+        }
+        /* get hold of clock */
+        p->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(p->clk)) {
+                dev_err(&pdev->dev, "cannot get clock\n");
+                ret = PTR_ERR(p->clk);
+                goto err2;
+        }
+        p->pdev = pdev;
+        p->pin_state = R_TPU_PIN_UNUSED;
+        p->timer_state = R_TPU_TIMER_UNUSED;
+        p->refresh_rate = cfg->refresh_rate ? cfg->refresh_rate : 100;
+        r_tpu_set_pin(p, R_TPU_PIN_GPIO, LED_OFF);
+        platform_set_drvdata(pdev, p);
+        INIT_WORK(&p->work, r_tpu_work);
+        p->ldev.name = cfg->name;
+        p->ldev.brightness = LED_OFF;
+        p->ldev.max_brightness = cfg->max_brightness;
+        p->ldev.brightness_set = r_tpu_set_brightness;
+        p->ldev.flags |= LED_CORE_SUSPENDRESUME;
+        ret = led_classdev_register(&pdev->dev, &p->ldev);
+        if (ret < 0)
+                goto err3;
+        /* max_brightness may be updated by the LED core code */
+        p->min_rate = p->ldev.max_brightness * p->refresh_rate;
+        pm_runtime_enable(&pdev->dev);
+        return 0;
+ err3:
+        r_tpu_set_pin(p, R_TPU_PIN_UNUSED, LED_OFF);
+        clk_put(p->clk);
+ err2:
+        iounmap(p->mapbase);
+ err1:
+        kfree(p);
+ err0:
+        return ret;
+}
+static int __devexit r_tpu_remove(struct platform_device *pdev)
+{
+        struct r_tpu_priv *p = platform_get_drvdata(pdev);
+        r_tpu_set_brightness(&p->ldev, LED_OFF);
+        led_classdev_unregister(&p->ldev);
+        cancel_work_sync(&p->work);
+        r_tpu_disable(p);
+        r_tpu_set_pin(p, R_TPU_PIN_UNUSED, LED_OFF);
+        pm_runtime_disable(&pdev->dev);
+        clk_put(p->clk);
+        iounmap(p->mapbase);
+        kfree(p);
+        return 0;
+}
+static struct platform_driver r_tpu_device_driver = {
+        .probe          = r_tpu_probe,
+        .remove         = __devexit_p(r_tpu_remove),
+        .driver         = {
+                .name   = "leds-renesas-tpu",
+        }
+};
+static int __init r_tpu_init(void)
+{
+        return platform_driver_register(&r_tpu_device_driver);
+}
+static void __exit r_tpu_exit(void)
+{
+        platform_driver_unregister(&r_tpu_device_driver);
+}
+module_init(r_tpu_init);
+module_exit(r_tpu_exit);
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("Renesas TPU LED Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/misc/ad525x_dpot-i2c.c b/drivers/misc/ad525x_dpot-i2c.c
index 4ff73c215746..a39e0555df63 100644
--- a/drivers/misc/ad525x_dpot-i2c.c
+++ b/drivers/misc/ad525x_dpot-i2c.c
@@ -98,6 +98,7 @@ static const struct i2c_device_id ad_dpot_id[] = {
        {"ad5282", AD5282_ID},
        {"adn2860", ADN2860_ID},
        {"ad5273", AD5273_ID},
+        {"ad5161", AD5161_ID},
        {"ad5171", AD5171_ID},
        {"ad5170", AD5170_ID},
        {"ad5172", AD5172_ID},
diff --git a/drivers/misc/fsa9480.c b/drivers/misc/fsa9480.c
index 27dc0d21aafa..f6586d53e1a3 100644
--- a/drivers/misc/fsa9480.c
+++ b/drivers/misc/fsa9480.c
@@ -400,7 +400,8 @@ static int fsa9480_irq_init(struct fsa9480_usbsw *usbsw)
                        return ret;
                }
-                device_init_wakeup(&client->dev, pdata->wakeup);
+                if (pdata)
+                        device_init_wakeup(&client->dev, pdata->wakeup);
        }
        return 0;
diff --git a/drivers/misc/lis3lv02d/lis3lv02d.c b/drivers/misc/lis3lv02d/lis3lv02d.c
index 8b51cd62d067..29d12a70eb1b 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d.c
+++ b/drivers/misc/lis3lv02d/lis3lv02d.c
@@ -163,7 +163,7 @@ static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z)
        int i;
        if (lis3->blkread) {
-                if (lis3_dev.whoami == WAI_12B) {
+                if (lis3->whoami == WAI_12B) {
                        u16 data[3];
                        lis3->blkread(lis3, OUTX_L, 6, (u8 *)data);
                        for (i = 0; i < 3; i++)
@@ -195,18 +195,30 @@ static int lis3_8_rates[2] = {100, 400};
 static int lis3_3dc_rates[16] = {0, 1, 10, 25, 50, 100, 200, 400, 1600, 5000};
 /* ODR is Output Data Rate */
-static int lis3lv02d_get_odr(void)
+static int lis3lv02d_get_odr(struct lis3lv02d *lis3)
 {
        u8 ctrl;
        int shift;
-        lis3_dev.read(&lis3_dev, CTRL_REG1, &ctrl);
+        lis3->read(lis3, CTRL_REG1, &ctrl);
-        ctrl &= lis3_dev.odr_mask;
+        ctrl &= lis3->odr_mask;
-        shift = ffs(lis3_dev.odr_mask) - 1;
+        shift = ffs(lis3->odr_mask) - 1;
-        return lis3_dev.odrs[(ctrl >> shift)];
+        return lis3->odrs[(ctrl >> shift)];
 }
-static int lis3lv02d_set_odr(int rate)
+static int lis3lv02d_get_pwron_wait(struct lis3lv02d *lis3)
+{
+        int div = lis3lv02d_get_odr(lis3);
+        if (WARN_ONCE(div == 0, "device returned spurious data"))
+                return -ENXIO;
+        /* LIS3 power on delay is quite long */
+        msleep(lis3->pwron_delay / div);
+        return 0;
+}
+static int lis3lv02d_set_odr(struct lis3lv02d *lis3, int rate)
 {
        u8 ctrl;
        int i, len, shift;
@@ -214,14 +226,14 @@ static int lis3lv02d_set_odr(int rate)
        if (!rate)
                return -EINVAL;
-        lis3_dev.read(&lis3_dev, CTRL_REG1, &ctrl);
+        lis3->read(lis3, CTRL_REG1, &ctrl);
-        ctrl &= ~lis3_dev.odr_mask;
+        ctrl &= ~lis3->odr_mask;
-        len = 1 << hweight_long(lis3_dev.odr_mask); /* # of possible values */
+        len = 1 << hweight_long(lis3->odr_mask); /* # of possible values */
-        shift = ffs(lis3_dev.odr_mask) - 1;
+        shift = ffs(lis3->odr_mask) - 1;
        for (i = 0; i < len; i++)
-                if (lis3_dev.odrs[i] == rate) {
+                if (lis3->odrs[i] == rate) {
-                        lis3_dev.write(&lis3_dev, CTRL_REG1,
+                        lis3->write(lis3, CTRL_REG1,
                                        ctrl | (i << shift));
                        return 0;
                }
@@ -240,12 +252,12 @@ static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
        mutex_lock(&lis3->mutex);
        irq_cfg = lis3->irq_cfg;
-        if (lis3_dev.whoami == WAI_8B) {
+        if (lis3->whoami == WAI_8B) {
                lis3->data_ready_count[IRQ_LINE0] = 0;
                lis3->data_ready_count[IRQ_LINE1] = 0;
                /* Change interrupt cfg to data ready for selftest */
-                atomic_inc(&lis3_dev.wake_thread);
+                atomic_inc(&lis3->wake_thread);
                lis3->irq_cfg = LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY;
                lis3->read(lis3, CTRL_REG3, &ctrl_reg_data);
                lis3->write(lis3, CTRL_REG3, (ctrl_reg_data &
@@ -253,12 +265,12 @@ static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
                                (LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY));
        }
-        if (lis3_dev.whoami == WAI_3DC) {
+        if (lis3->whoami == WAI_3DC) {
                ctlreg = CTRL_REG4;
                selftest = CTRL4_ST0;
        } else {
                ctlreg = CTRL_REG1;
-                if (lis3_dev.whoami == WAI_12B)
+                if (lis3->whoami == WAI_12B)
                        selftest = CTRL1_ST;
                else
                        selftest = CTRL1_STP;
@@ -266,7 +278,9 @@ static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
        lis3->read(lis3, ctlreg, &reg);
        lis3->write(lis3, ctlreg, (reg | selftest));
-        msleep(lis3->pwron_delay / lis3lv02d_get_odr());
+        ret = lis3lv02d_get_pwron_wait(lis3);
+        if (ret)
+                goto fail;
        /* Read directly to avoid axis remap */
        x = lis3->read_data(lis3, OUTX);
@@ -275,7 +289,9 @@ static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
        /* back to normal settings */
        lis3->write(lis3, ctlreg, reg);
-        msleep(lis3->pwron_delay / lis3lv02d_get_odr());
+        ret = lis3lv02d_get_pwron_wait(lis3);
+        if (ret)
+                goto fail;
        results[0] = x - lis3->read_data(lis3, OUTX);
        results[1] = y - lis3->read_data(lis3, OUTY);
@@ -283,9 +299,9 @@ static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
        ret = 0;
-        if (lis3_dev.whoami == WAI_8B) {
+        if (lis3->whoami == WAI_8B) {
                /* Restore original interrupt configuration */
-                atomic_dec(&lis3_dev.wake_thread);
+                atomic_dec(&lis3->wake_thread);
                lis3->write(lis3, CTRL_REG3, ctrl_reg_data);
                lis3->irq_cfg = irq_cfg;
@@ -363,8 +379,9 @@ void lis3lv02d_poweroff(struct lis3lv02d *lis3)
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
-void lis3lv02d_poweron(struct lis3lv02d *lis3)
+int lis3lv02d_poweron(struct lis3lv02d *lis3)
 {
+        int err;
        u8 reg;
        lis3->init(lis3);
@@ -384,35 +401,41 @@ void lis3lv02d_poweron(struct lis3lv02d *lis3)
                lis3->write(lis3, CTRL_REG2, reg);
        }
-        /* LIS3 power on delay is quite long */
+        err = lis3lv02d_get_pwron_wait(lis3);
-        msleep(lis3->pwron_delay / lis3lv02d_get_odr());
+        if (err)
+                return err;
        if (lis3->reg_ctrl)
                lis3_context_restore(lis3);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
 static void lis3lv02d_joystick_poll(struct input_polled_dev *pidev)
 {
+        struct lis3lv02d *lis3 = pidev->private;
        int x, y, z;
-        mutex_lock(&lis3_dev.mutex);
+        mutex_lock(&lis3->mutex);
-        lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
+        lis3lv02d_get_xyz(lis3, &x, &y, &z);
        input_report_abs(pidev->input, ABS_X, x);
        input_report_abs(pidev->input, ABS_Y, y);
        input_report_abs(pidev->input, ABS_Z, z);
        input_sync(pidev->input);
-        mutex_unlock(&lis3_dev.mutex);
+        mutex_unlock(&lis3->mutex);
 }
 static void lis3lv02d_joystick_open(struct input_polled_dev *pidev)
 {
-        if (lis3_dev.pm_dev)
+        struct lis3lv02d *lis3 = pidev->private;
-                pm_runtime_get_sync(lis3_dev.pm_dev);
-        if (lis3_dev.pdata && lis3_dev.whoami == WAI_8B && lis3_dev.idev)
+        if (lis3->pm_dev)
-                atomic_set(&lis3_dev.wake_thread, 1);
+                pm_runtime_get_sync(lis3->pm_dev);
+        if (lis3->pdata && lis3->whoami == WAI_8B && lis3->idev)
+                atomic_set(&lis3->wake_thread, 1);
        /*
         * Update coordinates for the case where poll interval is 0 and
         * the chip in running purely under interrupt control
@@ -422,14 +445,18 @@ static void lis3lv02d_joystick_open(struct input_polled_dev *pidev)
 static void lis3lv02d_joystick_close(struct input_polled_dev *pidev)
 {
-        atomic_set(&lis3_dev.wake_thread, 0);
+        struct lis3lv02d *lis3 = pidev->private;
-        if (lis3_dev.pm_dev)
-                pm_runtime_put(lis3_dev.pm_dev);
+        atomic_set(&lis3->wake_thread, 0);
+        if (lis3->pm_dev)
+                pm_runtime_put(lis3->pm_dev);
 }
-static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
+static irqreturn_t lis302dl_interrupt(int irq, void *data)
 {
-        if (!test_bit(0, &lis3_dev.misc_opened))
+        struct lis3lv02d *lis3 = data;
+        if (!test_bit(0, &lis3->misc_opened))
                goto out;
        /*
@@ -437,12 +464,12 @@ static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
         * the lid is closed. This leads to interrupts as soon as a little move
         * is done.
         */
-        atomic_inc(&lis3_dev.count);
+        atomic_inc(&lis3->count);
-        wake_up_interruptible(&lis3_dev.misc_wait);
+        wake_up_interruptible(&lis3->misc_wait);
-        kill_fasync(&lis3_dev.async_queue, SIGIO, POLL_IN);
+        kill_fasync(&lis3->async_queue, SIGIO, POLL_IN);
 out:
-        if (atomic_read(&lis3_dev.wake_thread))
+        if (atomic_read(&lis3->wake_thread))
                return IRQ_WAKE_THREAD;
        return IRQ_HANDLED;
 }
@@ -514,28 +541,37 @@ static irqreturn_t lis302dl_interrupt_thread2_8b(int irq, void *data)
 static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
 {
-        if (test_and_set_bit(0, &lis3_dev.misc_opened))
+        struct lis3lv02d *lis3 = container_of(file->private_data,
+                                              struct lis3lv02d, miscdev);
+        if (test_and_set_bit(0, &lis3->misc_opened))
                return -EBUSY; /* already open */
-        if (lis3_dev.pm_dev)
+        if (lis3->pm_dev)
-                pm_runtime_get_sync(lis3_dev.pm_dev);
+                pm_runtime_get_sync(lis3->pm_dev);
-        atomic_set(&lis3_dev.count, 0);
+        atomic_set(&lis3->count, 0);
        return 0;
 }
 static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
 {
-        fasync_helper(-1, file, 0, &lis3_dev.async_queue);
+        struct lis3lv02d *lis3 = container_of(file->private_data,
-        clear_bit(0, &lis3_dev.misc_opened); /* release the device */
+                                              struct lis3lv02d, miscdev);
-        if (lis3_dev.pm_dev)
-                pm_runtime_put(lis3_dev.pm_dev);
+        fasync_helper(-1, file, 0, &lis3->async_queue);
+        clear_bit(0, &lis3->misc_opened); /* release the device */
+        if (lis3->pm_dev)
+                pm_runtime_put(lis3->pm_dev);
        return 0;
 }
 static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
                                size_t count, loff_t *pos)
 {
+        struct lis3lv02d *lis3 = container_of(file->private_data,
+                                              struct lis3lv02d, miscdev);
        DECLARE_WAITQUEUE(wait, current);
        u32 data;
        unsigned char byte_data;
@@ -544,10 +580,10 @@ static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
        if (count < 1)
                return -EINVAL;
-        add_wait_queue(&lis3_dev.misc_wait, &wait);
+        add_wait_queue(&lis3->misc_wait, &wait);
        while (true) {
                set_current_state(TASK_INTERRUPTIBLE);
-                data = atomic_xchg(&lis3_dev.count, 0);
+                data = atomic_xchg(&lis3->count, 0);
                if (data)
                        break;
@@ -577,22 +613,28 @@ static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
 out:
        __set_current_state(TASK_RUNNING);
-        remove_wait_queue(&lis3_dev.misc_wait, &wait);
+        remove_wait_queue(&lis3->misc_wait, &wait);
        return retval;
 }
 static unsigned int lis3lv02d_misc_poll(struct file *file, poll_table *wait)
 {
-        poll_wait(file, &lis3_dev.misc_wait, wait);
+        struct lis3lv02d *lis3 = container_of(file->private_data,
-        if (atomic_read(&lis3_dev.count))
+                                              struct lis3lv02d, miscdev);
+        poll_wait(file, &lis3->misc_wait, wait);
+        if (atomic_read(&lis3->count))
                return POLLIN | POLLRDNORM;
        return 0;
 }
 static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
 {
-        return fasync_helper(fd, file, on, &lis3_dev.async_queue);
+        struct lis3lv02d *lis3 = container_of(file->private_data,
+                                              struct lis3lv02d, miscdev);
+        return fasync_helper(fd, file, on, &lis3->async_queue);
 }
 static const struct file_operations lis3lv02d_misc_fops = {
@@ -605,85 +647,80 @@ static const struct file_operations lis3lv02d_misc_fops = {
        .fasync  = lis3lv02d_misc_fasync,
 };
-static struct miscdevice lis3lv02d_misc_device = {
+int lis3lv02d_joystick_enable(struct lis3lv02d *lis3)
-        .minor   = MISC_DYNAMIC_MINOR,
-        .name    = "freefall",
-        .fops    = &lis3lv02d_misc_fops,
-};
-int lis3lv02d_joystick_enable(void)
 {
        struct input_dev *input_dev;
        int err;
        int max_val, fuzz, flat;
        int btns[] = {BTN_X, BTN_Y, BTN_Z};
-        if (lis3_dev.idev)
+        if (lis3->idev)
                return -EINVAL;
-        lis3_dev.idev = input_allocate_polled_device();
+        lis3->idev = input_allocate_polled_device();
-        if (!lis3_dev.idev)
+        if (!lis3->idev)
                return -ENOMEM;
-        lis3_dev.idev->poll = lis3lv02d_joystick_poll;
+        lis3->idev->poll = lis3lv02d_joystick_poll;
-        lis3_dev.idev->open = lis3lv02d_joystick_open;
+        lis3->idev->open = lis3lv02d_joystick_open;
-        lis3_dev.idev->close = lis3lv02d_joystick_close;
+        lis3->idev->close = lis3lv02d_joystick_close;
-        lis3_dev.idev->poll_interval = MDPS_POLL_INTERVAL;
+        lis3->idev->poll_interval = MDPS_POLL_INTERVAL;
-        lis3_dev.idev->poll_interval_min = MDPS_POLL_MIN;
+        lis3->idev->poll_interval_min = MDPS_POLL_MIN;
-        lis3_dev.idev->poll_interval_max = MDPS_POLL_MAX;
+        lis3->idev->poll_interval_max = MDPS_POLL_MAX;
-        input_dev = lis3_dev.idev->input;
+        lis3->idev->private = lis3;
+        input_dev = lis3->idev->input;
        input_dev->name       = "ST LIS3LV02DL Accelerometer";
        input_dev->phys       = DRIVER_NAME "/input0";
        input_dev->id.bustype = BUS_HOST;
        input_dev->id.vendor  = 0;
-        input_dev->dev.parent = &lis3_dev.pdev->dev;
+        input_dev->dev.parent = &lis3->pdev->dev;
        set_bit(EV_ABS, input_dev->evbit);
-        max_val = (lis3_dev.mdps_max_val * lis3_dev.scale) / LIS3_ACCURACY;
+        max_val = (lis3->mdps_max_val * lis3->scale) / LIS3_ACCURACY;
-        if (lis3_dev.whoami == WAI_12B) {
+        if (lis3->whoami == WAI_12B) {
                fuzz = LIS3_DEFAULT_FUZZ_12B;
                flat = LIS3_DEFAULT_FLAT_12B;
        } else {
                fuzz = LIS3_DEFAULT_FUZZ_8B;
                flat = LIS3_DEFAULT_FLAT_8B;
        }
-        fuzz = (fuzz * lis3_dev.scale) / LIS3_ACCURACY;
+        fuzz = (fuzz * lis3->scale) / LIS3_ACCURACY;
-        flat = (flat * lis3_dev.scale) / LIS3_ACCURACY;
+        flat = (flat * lis3->scale) / LIS3_ACCURACY;
        input_set_abs_params(input_dev, ABS_X, -max_val, max_val, fuzz, flat);
        input_set_abs_params(input_dev, ABS_Y, -max_val, max_val, fuzz, flat);
        input_set_abs_params(input_dev, ABS_Z, -max_val, max_val, fuzz, flat);
-        lis3_dev.mapped_btns[0] = lis3lv02d_get_axis(abs(lis3_dev.ac.x), btns);
+        lis3->mapped_btns[0] = lis3lv02d_get_axis(abs(lis3->ac.x), btns);
-        lis3_dev.mapped_btns[1] = lis3lv02d_get_axis(abs(lis3_dev.ac.y), btns);
+        lis3->mapped_btns[1] = lis3lv02d_get_axis(abs(lis3->ac.y), btns);
-        lis3_dev.mapped_btns[2] = lis3lv02d_get_axis(abs(lis3_dev.ac.z), btns);
+        lis3->mapped_btns[2] = lis3lv02d_get_axis(abs(lis3->ac.z), btns);
-        err = input_register_polled_device(lis3_dev.idev);
+        err = input_register_polled_device(lis3->idev);
        if (err) {
-                input_free_polled_device(lis3_dev.idev);
+                input_free_polled_device(lis3->idev);
-                lis3_dev.idev = NULL;
+                lis3->idev = NULL;
        }
        return err;
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
-void lis3lv02d_joystick_disable(void)
+void lis3lv02d_joystick_disable(struct lis3lv02d *lis3)
 {
-        if (lis3_dev.irq)
+        if (lis3->irq)
-                free_irq(lis3_dev.irq, &lis3_dev);
+                free_irq(lis3->irq, lis3);
-        if (lis3_dev.pdata && lis3_dev.pdata->irq2)
+        if (lis3->pdata && lis3->pdata->irq2)
-                free_irq(lis3_dev.pdata->irq2, &lis3_dev);
+                free_irq(lis3->pdata->irq2, lis3);
-        if (!lis3_dev.idev)
+        if (!lis3->idev)
                return;
-        if (lis3_dev.irq)
+        if (lis3->irq)
-                misc_deregister(&lis3lv02d_misc_device);
+                misc_deregister(&lis3->miscdev);
-        input_unregister_polled_device(lis3_dev.idev);
+        input_unregister_polled_device(lis3->idev);
-        input_free_polled_device(lis3_dev.idev);
+        input_free_polled_device(lis3->idev);
-        lis3_dev.idev = NULL;
+        lis3->idev = NULL;
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
@@ -708,6 +745,7 @@ static void lis3lv02d_sysfs_poweron(struct lis3lv02d *lis3)
 static ssize_t lis3lv02d_selftest_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
 {
+        struct lis3lv02d *lis3 = dev_get_drvdata(dev);
        s16 values[3];
        static const char ok[] = "OK";
@@ -715,8 +753,8 @@ static ssize_t lis3lv02d_selftest_show(struct device *dev,
        static const char irq[] = "FAIL_IRQ";
        const char *res;
-        lis3lv02d_sysfs_poweron(&lis3_dev);
+        lis3lv02d_sysfs_poweron(lis3);
-        switch (lis3lv02d_selftest(&lis3_dev, values)) {
+        switch (lis3lv02d_selftest(lis3, values)) {
        case SELFTEST_FAIL:
                res = fail;
                break;
@@ -735,33 +773,37 @@ static ssize_t lis3lv02d_selftest_show(struct device *dev,
 static ssize_t lis3lv02d_position_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
 {
+        struct lis3lv02d *lis3 = dev_get_drvdata(dev);
        int x, y, z;
-        lis3lv02d_sysfs_poweron(&lis3_dev);
+        lis3lv02d_sysfs_poweron(lis3);
-        mutex_lock(&lis3_dev.mutex);
+        mutex_lock(&lis3->mutex);
-        lis3lv02d_get_xyz(&lis3_dev, &x, &y, &z);
+        lis3lv02d_get_xyz(lis3, &x, &y, &z);
-        mutex_unlock(&lis3_dev.mutex);
+        mutex_unlock(&lis3->mutex);
        return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
 }
 static ssize_t lis3lv02d_rate_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
 {
-        lis3lv02d_sysfs_poweron(&lis3_dev);
+        struct lis3lv02d *lis3 = dev_get_drvdata(dev);
-        return sprintf(buf, "%d\n", lis3lv02d_get_odr());
+        lis3lv02d_sysfs_poweron(lis3);
+        return sprintf(buf, "%d\n", lis3lv02d_get_odr(lis3));
 }
 static ssize_t lis3lv02d_rate_set(struct device *dev,
                                struct device_attribute *attr, const char *buf,
                                size_t count)
 {
+        struct lis3lv02d *lis3 = dev_get_drvdata(dev);
        unsigned long rate;
        if (strict_strtoul(buf, 0, &rate))
                return -EINVAL;
-        lis3lv02d_sysfs_poweron(&lis3_dev);
+        lis3lv02d_sysfs_poweron(lis3);
-        if (lis3lv02d_set_odr(rate))
+        if (lis3lv02d_set_odr(lis3, rate))
                return -EINVAL;
        return count;
@@ -790,6 +832,7 @@ static int lis3lv02d_add_fs(struct lis3lv02d *lis3)
        if (IS_ERR(lis3->pdev))
                return PTR_ERR(lis3->pdev);
+        platform_set_drvdata(lis3->pdev, lis3);
        return sysfs_create_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group);
 }
@@ -803,7 +846,7 @@ int lis3lv02d_remove_fs(struct lis3lv02d *lis3)
                /* SYSFS may have left chip running. Turn off if necessary */
                if (!pm_runtime_suspended(lis3->pm_dev))
-                        lis3lv02d_poweroff(&lis3_dev);
+                        lis3lv02d_poweroff(lis3);
                pm_runtime_disable(lis3->pm_dev);
                pm_runtime_set_suspended(lis3->pm_dev);
@@ -813,24 +856,24 @@ int lis3lv02d_remove_fs(struct lis3lv02d *lis3)
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
-static void lis3lv02d_8b_configure(struct lis3lv02d *dev,
+static void lis3lv02d_8b_configure(struct lis3lv02d *lis3,
                                struct lis3lv02d_platform_data *p)
 {
        int err;
        int ctrl2 = p->hipass_ctrl;
        if (p->click_flags) {
-                dev->write(dev, CLICK_CFG, p->click_flags);
+                lis3->write(lis3, CLICK_CFG, p->click_flags);
-                dev->write(dev, CLICK_TIMELIMIT, p->click_time_limit);
+                lis3->write(lis3, CLICK_TIMELIMIT, p->click_time_limit);
-                dev->write(dev, CLICK_LATENCY, p->click_latency);
+                lis3->write(lis3, CLICK_LATENCY, p->click_latency);
-                dev->write(dev, CLICK_WINDOW, p->click_window);
+                lis3->write(lis3, CLICK_WINDOW, p->click_window);
-                dev->write(dev, CLICK_THSZ, p->click_thresh_z & 0xf);
+                lis3->write(lis3, CLICK_THSZ, p->click_thresh_z & 0xf);
-                dev->write(dev, CLICK_THSY_X,
+                lis3->write(lis3, CLICK_THSY_X,
                        (p->click_thresh_x & 0xf) |
                        (p->click_thresh_y << 4));
-                if (dev->idev) {
+                if (lis3->idev) {
-                        struct input_dev *input_dev = lis3_dev.idev->input;
+                        struct input_dev *input_dev = lis3->idev->input;
                        input_set_capability(input_dev, EV_KEY, BTN_X);
                        input_set_capability(input_dev, EV_KEY, BTN_Y);
                        input_set_capability(input_dev, EV_KEY, BTN_Z);
@@ -838,22 +881,22 @@ static void lis3lv02d_8b_configure(struct lis3lv02d *dev,
        }
        if (p->wakeup_flags) {
-                dev->write(dev, FF_WU_CFG_1, p->wakeup_flags);
+                lis3->write(lis3, FF_WU_CFG_1, p->wakeup_flags);
-                dev->write(dev, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
+                lis3->write(lis3, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
                /* pdata value + 1 to keep this backward compatible*/
-                dev->write(dev, FF_WU_DURATION_1, p->duration1 + 1);
+                lis3->write(lis3, FF_WU_DURATION_1, p->duration1 + 1);
                ctrl2 ^= HP_FF_WU1; /* Xor to keep compatible with old pdata*/
        }
        if (p->wakeup_flags2) {
-                dev->write(dev, FF_WU_CFG_2, p->wakeup_flags2);
+                lis3->write(lis3, FF_WU_CFG_2, p->wakeup_flags2);
-                dev->write(dev, FF_WU_THS_2, p->wakeup_thresh2 & 0x7f);
+                lis3->write(lis3, FF_WU_THS_2, p->wakeup_thresh2 & 0x7f);
                /* pdata value + 1 to keep this backward compatible*/
-                dev->write(dev, FF_WU_DURATION_2, p->duration2 + 1);
+                lis3->write(lis3, FF_WU_DURATION_2, p->duration2 + 1);
                ctrl2 ^= HP_FF_WU2; /* Xor to keep compatible with old pdata*/
        }
        /* Configure hipass filters */
-        dev->write(dev, CTRL_REG2, ctrl2);
+        lis3->write(lis3, CTRL_REG2, ctrl2);
        if (p->irq2) {
                err = request_threaded_irq(p->irq2,
@@ -861,7 +904,7 @@ static void lis3lv02d_8b_configure(struct lis3lv02d *dev,
                                        lis302dl_interrupt_thread2_8b,
                                        IRQF_TRIGGER_RISING | IRQF_ONESHOT |
                                        (p->irq_flags2 & IRQF_TRIGGER_MASK),
-                                        DRIVER_NAME, &lis3_dev);
+                                        DRIVER_NAME, lis3);
                if (err < 0)
                        pr_err("No second IRQ. Limited functionality\n");
        }
@@ -871,93 +914,97 @@ static void lis3lv02d_8b_configure(struct lis3lv02d *dev,
 * Initialise the accelerometer and the various subsystems.
 * Should be rather independent of the bus system.
 */
-int lis3lv02d_init_device(struct lis3lv02d *dev)
+int lis3lv02d_init_device(struct lis3lv02d *lis3)
 {
        int err;
        irq_handler_t thread_fn;
        int irq_flags = 0;
-        dev->whoami = lis3lv02d_read_8(dev, WHO_AM_I);
+        lis3->whoami = lis3lv02d_read_8(lis3, WHO_AM_I);
-        switch (dev->whoami) {
+        switch (lis3->whoami) {
        case WAI_12B:
                pr_info("12 bits sensor found\n");
-                dev->read_data = lis3lv02d_read_12;
+                lis3->read_data = lis3lv02d_read_12;
-                dev->mdps_max_val = 2048;
+                lis3->mdps_max_val = 2048;
-                dev->pwron_delay = LIS3_PWRON_DELAY_WAI_12B;
+                lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_12B;
-                dev->odrs = lis3_12_rates;
+                lis3->odrs = lis3_12_rates;
-                dev->odr_mask = CTRL1_DF0 | CTRL1_DF1;
+                lis3->odr_mask = CTRL1_DF0 | CTRL1_DF1;
-                dev->scale = LIS3_SENSITIVITY_12B;
+                lis3->scale = LIS3_SENSITIVITY_12B;
-                dev->regs = lis3_wai12_regs;
+                lis3->regs = lis3_wai12_regs;
-                dev->regs_size = ARRAY_SIZE(lis3_wai12_regs);
+                lis3->regs_size = ARRAY_SIZE(lis3_wai12_regs);
                break;
        case WAI_8B:
                pr_info("8 bits sensor found\n");
-                dev->read_data = lis3lv02d_read_8;
+                lis3->read_data = lis3lv02d_read_8;
-                dev->mdps_max_val = 128;
+                lis3->mdps_max_val = 128;
-                dev->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
+                lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
-                dev->odrs = lis3_8_rates;
+                lis3->odrs = lis3_8_rates;
-                dev->odr_mask = CTRL1_DR;
+                lis3->odr_mask = CTRL1_DR;
-                dev->scale = LIS3_SENSITIVITY_8B;
+                lis3->scale = LIS3_SENSITIVITY_8B;
-                dev->regs = lis3_wai8_regs;
+                lis3->regs = lis3_wai8_regs;
-                dev->regs_size = ARRAY_SIZE(lis3_wai8_regs);
+                lis3->regs_size = ARRAY_SIZE(lis3_wai8_regs);
                break;
        case WAI_3DC:
                pr_info("8 bits 3DC sensor found\n");
-                dev->read_data = lis3lv02d_read_8;
+                lis3->read_data = lis3lv02d_read_8;
-                dev->mdps_max_val = 128;
+                lis3->mdps_max_val = 128;
-                dev->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
+                lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
-                dev->odrs = lis3_3dc_rates;
+                lis3->odrs = lis3_3dc_rates;
-                dev->odr_mask = CTRL1_ODR0|CTRL1_ODR1|CTRL1_ODR2|CTRL1_ODR3;
+                lis3->odr_mask = CTRL1_ODR0|CTRL1_ODR1|CTRL1_ODR2|CTRL1_ODR3;
-                dev->scale = LIS3_SENSITIVITY_8B;
+                lis3->scale = LIS3_SENSITIVITY_8B;
                break;
        default:
-                pr_err("unknown sensor type 0x%X\n", dev->whoami);
+                pr_err("unknown sensor type 0x%X\n", lis3->whoami);
                return -EINVAL;
        }
-        dev->reg_cache = kzalloc(max(sizeof(lis3_wai8_regs),
+        lis3->reg_cache = kzalloc(max(sizeof(lis3_wai8_regs),
                                     sizeof(lis3_wai12_regs)), GFP_KERNEL);
-        if (dev->reg_cache == NULL) {
+        if (lis3->reg_cache == NULL) {
                printk(KERN_ERR DRIVER_NAME "out of memory\n");
                return -ENOMEM;
        }
-        mutex_init(&dev->mutex);
+        mutex_init(&lis3->mutex);
-        atomic_set(&dev->wake_thread, 0);
+        atomic_set(&lis3->wake_thread, 0);
-        lis3lv02d_add_fs(dev);
+        lis3lv02d_add_fs(lis3);
-        lis3lv02d_poweron(dev);
+        err = lis3lv02d_poweron(lis3);
+        if (err) {
+                lis3lv02d_remove_fs(lis3);
+                return err;
+        }
-        if (dev->pm_dev) {
+        if (lis3->pm_dev) {
-                pm_runtime_set_active(dev->pm_dev);
+                pm_runtime_set_active(lis3->pm_dev);
-                pm_runtime_enable(dev->pm_dev);
+                pm_runtime_enable(lis3->pm_dev);
        }
-        if (lis3lv02d_joystick_enable())
+        if (lis3lv02d_joystick_enable(lis3))
                pr_err("joystick initialization failed\n");
        /* passing in platform specific data is purely optional and only
         * used by the SPI transport layer at the moment */
-        if (dev->pdata) {
+        if (lis3->pdata) {
-                struct lis3lv02d_platform_data *p = dev->pdata;
+                struct lis3lv02d_platform_data *p = lis3->pdata;
-                if (dev->whoami == WAI_8B)
+                if (lis3->whoami == WAI_8B)
-                        lis3lv02d_8b_configure(dev, p);
+                        lis3lv02d_8b_configure(lis3, p);
                irq_flags = p->irq_flags1 & IRQF_TRIGGER_MASK;
-                dev->irq_cfg = p->irq_cfg;
+                lis3->irq_cfg = p->irq_cfg;
                if (p->irq_cfg)
-                        dev->write(dev, CTRL_REG3, p->irq_cfg);
+                        lis3->write(lis3, CTRL_REG3, p->irq_cfg);
                if (p->default_rate)
-                        lis3lv02d_set_odr(p->default_rate);
+                        lis3lv02d_set_odr(lis3, p->default_rate);
        }
        /* bail if we did not get an IRQ from the bus layer */
-        if (!dev->irq) {
+        if (!lis3->irq) {
                pr_debug("No IRQ. Disabling /dev/freefall\n");
                goto out;
        }
@@ -973,23 +1020,27 @@ int lis3lv02d_init_device(struct lis3lv02d *dev)
         * io-apic is not configurable (and generates a warning) but I keep it
         * in case of support for other hardware.
         */
-        if (dev->pdata && dev->whoami == WAI_8B)
+        if (lis3->pdata && lis3->whoami == WAI_8B)
                thread_fn = lis302dl_interrupt_thread1_8b;
        else
                thread_fn = NULL;
-        err = request_threaded_irq(dev->irq, lis302dl_interrupt,
+        err = request_threaded_irq(lis3->irq, lis302dl_interrupt,
                                thread_fn,
                                IRQF_TRIGGER_RISING | IRQF_ONESHOT |
                                irq_flags,
-                                DRIVER_NAME, &lis3_dev);
+                                DRIVER_NAME, lis3);
        if (err < 0) {
                pr_err("Cannot get IRQ\n");
                goto out;
        }
-        if (misc_register(&lis3lv02d_misc_device))
+        lis3->miscdev.minor     = MISC_DYNAMIC_MINOR;
+        lis3->miscdev.name      = "freefall";
+        lis3->miscdev.fops      = &lis3lv02d_misc_fops;
+        if (misc_register(&lis3->miscdev))
                pr_err("misc_register failed\n");
 out:
        return 0;
diff --git a/drivers/misc/lis3lv02d/lis3lv02d.h b/drivers/misc/lis3lv02d/lis3lv02d.h
index a1939589eb2c..2b1482ad3f16 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d.h
+++ b/drivers/misc/lis3lv02d/lis3lv02d.h
@@ -21,6 +21,7 @@
 #include <linux/platform_device.h>
 #include <linux/input-polldev.h>
 #include <linux/regulator/consumer.h>
+#include <linux/miscdevice.h>
 /*
 * This driver tries to support the "digital" accelerometer chips from
@@ -273,6 +274,8 @@ struct lis3lv02d {
        struct fasync_struct    *async_queue; /* queue for the misc device */
        wait_queue_head_t       misc_wait; /* Wait queue for the misc device */
        unsigned long           misc_opened; /* bit0: whether the device is open */
+        struct miscdevice       miscdev;
        int                     data_ready_count[2];
        atomic_t                wake_thread;
        unsigned char           irq_cfg;
@@ -282,10 +285,10 @@ struct lis3lv02d {
 };
 int lis3lv02d_init_device(struct lis3lv02d *lis3);
-int lis3lv02d_joystick_enable(void);
+int lis3lv02d_joystick_enable(struct lis3lv02d *lis3);
-void lis3lv02d_joystick_disable(void);
+void lis3lv02d_joystick_disable(struct lis3lv02d *lis3);
 void lis3lv02d_poweroff(struct lis3lv02d *lis3);
-void lis3lv02d_poweron(struct lis3lv02d *lis3);
+int lis3lv02d_poweron(struct lis3lv02d *lis3);
 int lis3lv02d_remove_fs(struct lis3lv02d *lis3);
 extern struct lis3lv02d lis3_dev;
diff --git a/drivers/misc/lis3lv02d/lis3lv02d_i2c.c b/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
index b20dfb4522d2..c02fea029dcf 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
+++ b/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
@@ -79,8 +79,7 @@ static int lis3_i2c_init(struct lis3lv02d *lis3)
        u8 reg;
        int ret;
-        if (lis3->reg_ctrl)
+        lis3_reg_ctrl(lis3, LIS3_REG_ON);
-                lis3_reg_ctrl(lis3, LIS3_REG_ON);
        lis3->read(lis3, WHO_AM_I, &reg);
        if (reg != lis3->whoami)
@@ -106,10 +105,6 @@ static int __devinit lis3lv02d_i2c_probe(struct i2c_client *client,
        struct lis3lv02d_platform_data *pdata = client->dev.platform_data;
        if (pdata) {
-                /* Regulator control is optional */
-                if (pdata->driver_features & LIS3_USE_REGULATOR_CTRL)
-                        lis3_dev.reg_ctrl = lis3_reg_ctrl;
                if ((pdata->driver_features & LIS3_USE_BLOCK_READ) &&
                        (i2c_check_functionality(client->adapter,
                                                I2C_FUNC_SMBUS_I2C_BLOCK)))
@@ -131,15 +126,13 @@ static int __devinit lis3lv02d_i2c_probe(struct i2c_client *client,
                        goto fail;
        }
-        if (lis3_dev.reg_ctrl) {
+        lis3_dev.regulators[0].supply = reg_vdd;
-                lis3_dev.regulators[0].supply = reg_vdd;
+        lis3_dev.regulators[1].supply = reg_vdd_io;
-                lis3_dev.regulators[1].supply = reg_vdd_io;
+        ret = regulator_bulk_get(&client->dev,
-                ret = regulator_bulk_get(&client->dev,
+                                 ARRAY_SIZE(lis3_dev.regulators),
-                                        ARRAY_SIZE(lis3_dev.regulators),
+                                 lis3_dev.regulators);
-                                        lis3_dev.regulators);
+        if (ret < 0)
-                if (ret < 0)
+                goto fail;
-                        goto fail;
-        }
        lis3_dev.pdata    = pdata;
        lis3_dev.bus_priv = client;
@@ -153,16 +146,19 @@ static int __devinit lis3lv02d_i2c_probe(struct i2c_client *client,
        i2c_set_clientdata(client, &lis3_dev);
        /* Provide power over the init call */
-        if (lis3_dev.reg_ctrl)
+        lis3_reg_ctrl(&lis3_dev, LIS3_REG_ON);
-                lis3_reg_ctrl(&lis3_dev, LIS3_REG_ON);
        ret = lis3lv02d_init_device(&lis3_dev);
-        if (lis3_dev.reg_ctrl)
+        lis3_reg_ctrl(&lis3_dev, LIS3_REG_OFF);
-                lis3_reg_ctrl(&lis3_dev, LIS3_REG_OFF);
-        if (ret == 0)
+        if (ret)
-                return 0;
+                goto fail2;
+        return 0;
+fail2:
+        regulator_bulk_free(ARRAY_SIZE(lis3_dev.regulators),
+                                lis3_dev.regulators);
 fail:
        if (pdata && pdata->release_resources)
                pdata->release_resources();
@@ -177,12 +173,11 @@ static int __devexit lis3lv02d_i2c_remove(struct i2c_client *client)
        if (pdata && pdata->release_resources)
                pdata->release_resources();
-        lis3lv02d_joystick_disable();
+        lis3lv02d_joystick_disable(lis3);
        lis3lv02d_remove_fs(&lis3_dev);
-        if (lis3_dev.reg_ctrl)
+        regulator_bulk_free(ARRAY_SIZE(lis3->regulators),
-                regulator_bulk_free(ARRAY_SIZE(lis3->regulators),
+                            lis3_dev.regulators);
-                                lis3_dev.regulators);
        return 0;
 }
diff --git a/drivers/misc/lis3lv02d/lis3lv02d_spi.c b/drivers/misc/lis3lv02d/lis3lv02d_spi.c
index c1f8a8fbf694..b2c1be12d16f 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d_spi.c
+++ b/drivers/misc/lis3lv02d/lis3lv02d_spi.c
@@ -83,7 +83,7 @@ static int __devinit lis302dl_spi_probe(struct spi_device *spi)
 static int __devexit lis302dl_spi_remove(struct spi_device *spi)
 {
        struct lis3lv02d *lis3 = spi_get_drvdata(spi);
-        lis3lv02d_joystick_disable();
+        lis3lv02d_joystick_disable(lis3);
        lis3lv02d_poweroff(lis3);
        return lis3lv02d_remove_fs(&lis3_dev);
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index fca66165110e..8fda331c65df 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -581,8 +581,9 @@ extern const struct ethtool_ops mlx4_en_ethtool_ops;
 * printk / logging functions
 */
+__printf(3, 4)
 int en_print(const char *level, const struct mlx4_en_priv *priv,
-             const char *format, ...) __attribute__ ((format (printf, 3, 4)));
+             const char *format, ...);
 #define en_dbg(mlevel, priv, format, arg...)                    \
 do {                                                            \
diff --git a/drivers/net/wireless/at76c50x-usb.c b/drivers/net/wireless/at76c50x-usb.c
index 39322d4121b7..4045e5ab0555 100644
--- a/drivers/net/wireless/at76c50x-usb.c
+++ b/drivers/net/wireless/at76c50x-usb.c
@@ -517,7 +517,7 @@ static char *hex2str(void *buf, size_t len)
                goto exit;
        while (len--) {
-                obuf = pack_hex_byte(obuf, *ibuf++);
+                obuf = hex_byte_pack(obuf, *ibuf++);
                *obuf++ = '-';
        }
        obuf--;
diff --git a/drivers/net/wireless/ath/ath.h b/drivers/net/wireless/ath/ath.h
index 908fdbc3e0ee..0f9ee46cfc97 100644
--- a/drivers/net/wireless/ath/ath.h
+++ b/drivers/net/wireless/ath/ath.h
@@ -173,8 +173,7 @@ bool ath_hw_keyreset(struct ath_common *common, u16 entry);
 void ath_hw_cycle_counters_update(struct ath_common *common);
 int32_t ath_hw_get_listen_time(struct ath_common *common);
-extern __attribute__((format (printf, 2, 3)))
+extern __printf(2, 3) void ath_printk(const char *level, const char *fmt, ...);
-void ath_printk(const char *level, const char *fmt, ...);
 #define _ath_printk(level, common, fmt, ...)                    \
 do {                                                            \
@@ -258,7 +257,7 @@ do {									\
 #else
-static inline  __attribute__((format (printf, 3, 4)))
+static inline  __attribute__ ((format (printf, 3, 4)))
 void ath_dbg(struct ath_common *common, enum ATH_DEBUG dbg_mask,
             const char *fmt, ...)
 {
diff --git a/drivers/net/wireless/ath/ath5k/debug.h b/drivers/net/wireless/ath/ath5k/debug.h
index 7f37df3125fd..0a3f916a1ef3 100644
--- a/drivers/net/wireless/ath/ath5k/debug.h
+++ b/drivers/net/wireless/ath/ath5k/debug.h
@@ -141,10 +141,10 @@ ath5k_debug_printtxbuf(struct ath5k_hw *ah, struct ath5k_buf *bf);
 #include <linux/compiler.h>
-static inline void __attribute__ ((format (printf, 3, 4)))
+static inline __printf(3, 4) void
 ATH5K_DBG(struct ath5k_hw *ah, unsigned int m, const char *fmt, ...) {}
-static inline void __attribute__ ((format (printf, 3, 4)))
+static inline __printf(3, 4) void
 ATH5K_DBG_UNLIMIT(struct ath5k_hw *ah, unsigned int m, const char *fmt, ...)
 {}
diff --git a/drivers/net/wireless/ath/ath6kl/debug.h b/drivers/net/wireless/ath/ath6kl/debug.h
index 9288a3ce1e39..7b7675f70a10 100644
--- a/drivers/net/wireless/ath/ath6kl/debug.h
+++ b/drivers/net/wireless/ath/ath6kl/debug.h
@@ -44,8 +44,8 @@ enum ATH6K_DEBUG_MASK {
 };
 extern unsigned int debug_mask;
-extern int ath6kl_printk(const char *level, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int ath6kl_printk(const char *level, const char *fmt, ...);
 #define ath6kl_info(fmt, ...)                           \
        ath6kl_printk(KERN_INFO, fmt, ##__VA_ARGS__)
diff --git a/drivers/net/wireless/b43/b43.h b/drivers/net/wireless/b43/b43.h
index 447a2307c9d9..37110dfd2c96 100644
--- a/drivers/net/wireless/b43/b43.h
+++ b/drivers/net/wireless/b43/b43.h
@@ -1011,14 +1011,10 @@ static inline bool b43_using_pio_transfers(struct b43_wldev *dev)
 }
 /* Message printing */
-void b43info(struct b43_wl *wl, const char *fmt, ...)
+__printf(2, 3) void b43info(struct b43_wl *wl, const char *fmt, ...);
-    __attribute__ ((format(printf, 2, 3)));
+__printf(2, 3) void b43err(struct b43_wl *wl, const char *fmt, ...);
-void b43err(struct b43_wl *wl, const char *fmt, ...)
+__printf(2, 3) void b43warn(struct b43_wl *wl, const char *fmt, ...);
-    __attribute__ ((format(printf, 2, 3)));
+__printf(2, 3) void b43dbg(struct b43_wl *wl, const char *fmt, ...);
-void b43warn(struct b43_wl *wl, const char *fmt, ...)
-    __attribute__ ((format(printf, 2, 3)));
-void b43dbg(struct b43_wl *wl, const char *fmt, ...)
-    __attribute__ ((format(printf, 2, 3)));
 /* A WARN_ON variant that vanishes when b43 debugging is disabled.
diff --git a/drivers/net/wireless/b43legacy/b43legacy.h b/drivers/net/wireless/b43legacy/b43legacy.h
index 12b518251581..1d4fc9db7f5e 100644
--- a/drivers/net/wireless/b43legacy/b43legacy.h
+++ b/drivers/net/wireless/b43legacy/b43legacy.h
@@ -810,15 +810,15 @@ struct b43legacy_lopair *b43legacy_get_lopair(struct b43legacy_phy *phy,
 /* Message printing */
-void b43legacyinfo(struct b43legacy_wl *wl, const char *fmt, ...)
+__printf(2, 3)
-                __attribute__((format(printf, 2, 3)));
+void b43legacyinfo(struct b43legacy_wl *wl, const char *fmt, ...);
-void b43legacyerr(struct b43legacy_wl *wl, const char *fmt, ...)
+__printf(2, 3)
-                __attribute__((format(printf, 2, 3)));
+void b43legacyerr(struct b43legacy_wl *wl, const char *fmt, ...);
-void b43legacywarn(struct b43legacy_wl *wl, const char *fmt, ...)
+__printf(2, 3)
-                __attribute__((format(printf, 2, 3)));
+void b43legacywarn(struct b43legacy_wl *wl, const char *fmt, ...);
 #if B43legacy_DEBUG
-void b43legacydbg(struct b43legacy_wl *wl, const char *fmt, ...)
+__printf(2, 3)
-                __attribute__((format(printf, 2, 3)));
+void b43legacydbg(struct b43legacy_wl *wl, const char *fmt, ...);
 #else /* DEBUG */
 # define b43legacydbg(wl, fmt...) do { /* nothing */ } while (0)
 #endif /* DEBUG */
diff --git a/drivers/platform/x86/hp_accel.c b/drivers/platform/x86/hp_accel.c
index 64b454855f65..22b2dfa73148 100644
--- a/drivers/platform/x86/hp_accel.c
+++ b/drivers/platform/x86/hp_accel.c
@@ -210,6 +210,8 @@ static struct dmi_system_id lis3lv02d_dmi_ids[] = {
        AXIS_DMI_MATCH("NC6715x", "HP Compaq 6715", y_inverted),
        AXIS_DMI_MATCH("NC693xx", "HP EliteBook 693", xy_rotated_right),
        AXIS_DMI_MATCH("NC693xx", "HP EliteBook 853", xy_swap),
+        AXIS_DMI_MATCH("NC854xx", "HP EliteBook 854", y_inverted),
+        AXIS_DMI_MATCH("NC273xx", "HP EliteBook 273", y_inverted),
        /* Intel-based HP Pavilion dv5 */
        AXIS_DMI_MATCH2("HPDV5_I",
                        PRODUCT_NAME, "HP Pavilion dv5",
@@ -228,6 +230,7 @@ static struct dmi_system_id lis3lv02d_dmi_ids[] = {
        AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted),
        AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap),
        AXIS_DMI_MATCH("HPB532x", "HP ProBook 532", y_inverted),
+        AXIS_DMI_MATCH("HPB655x", "HP ProBook 655", xy_swap_inverted),
        AXIS_DMI_MATCH("Mini510x", "HP Mini 510", xy_rotated_left_usd),
        AXIS_DMI_MATCH("HPB63xx", "HP ProBook 63", xy_swap),
        AXIS_DMI_MATCH("HPB64xx", "HP ProBook 64", xy_swap),
@@ -325,7 +328,7 @@ static int lis3lv02d_add(struct acpi_device *device)
        INIT_WORK(&hpled_led.work, delayed_set_status_worker);
        ret = led_classdev_register(NULL, &hpled_led.led_classdev);
        if (ret) {
-                lis3lv02d_joystick_disable();
+                lis3lv02d_joystick_disable(&lis3_dev);
                lis3lv02d_poweroff(&lis3_dev);
                flush_work(&hpled_led.work);
                return ret;
@@ -339,7 +342,7 @@ static int lis3lv02d_remove(struct acpi_device *device, int type)
        if (!device)
                return -EINVAL;
-        lis3lv02d_joystick_disable();
+        lis3lv02d_joystick_disable(&lis3_dev);
        lis3lv02d_poweroff(&lis3_dev);
        led_classdev_unregister(&hpled_led.led_classdev);
@@ -359,8 +362,7 @@ static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state)
 static int lis3lv02d_resume(struct acpi_device *device)
 {
-        lis3lv02d_poweron(&lis3_dev);
+        return lis3lv02d_poweron(&lis3_dev);
-        return 0;
 }
 #else
 #define lis3lv02d_suspend NULL
diff --git a/drivers/staging/iio/trigger.h b/drivers/staging/iio/trigger.h
index 598fcb3599f9..5cc42a655c88 100644
--- a/drivers/staging/iio/trigger.h
+++ b/drivers/staging/iio/trigger.h
@@ -115,8 +115,7 @@ void iio_trigger_poll_chained(struct iio_trigger *trig, s64 time);
 irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private);
-struct iio_trigger *iio_allocate_trigger(const char *fmt, ...)
+__printf(1, 2) struct iio_trigger *iio_allocate_trigger(const char *fmt, ...);
-        __attribute__((format(printf, 1, 2)));
 void iio_free_trigger(struct iio_trigger *trig);
 #endif /* _IIO_TRIGGER_H_ */
diff --git a/drivers/video/backlight/adp8870_bl.c b/drivers/video/backlight/adp8870_bl.c
index 98e0304deeaf..6c68a6899e87 100644
--- a/drivers/video/backlight/adp8870_bl.c
+++ b/drivers/video/backlight/adp8870_bl.c
@@ -931,7 +931,6 @@ out:
 out1:
        backlight_device_unregister(bl);
 out2:
-        i2c_set_clientdata(client, NULL);
        kfree(data);
        return ret;
@@ -951,7 +950,6 @@ static int __devexit adp8870_remove(struct i2c_client *client)
                        &adp8870_bl_attr_group);
        backlight_device_unregister(data->bl);
-        i2c_set_clientdata(client, NULL);
        kfree(data);
        return 0;
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
index 8c6befd65a33..adb191466d64 100644
--- a/drivers/video/backlight/generic_bl.c
+++ b/drivers/video/backlight/generic_bl.c
@@ -56,7 +56,7 @@ static int genericbl_get_intensity(struct backlight_device *bd)
 * Called when the battery is low to limit the backlight intensity.
 * If limit==0 clear any limit, otherwise limit the intensity
 */
-void corgibl_limit_intensity(int limit)
+void genericbl_limit_intensity(int limit)
 {
        struct backlight_device *bd = generic_backlight_device;
@@ -68,7 +68,7 @@ void corgibl_limit_intensity(int limit)
        backlight_update_status(generic_backlight_device);
        mutex_unlock(&bd->ops_lock);
 }
-EXPORT_SYMBOL(corgibl_limit_intensity);
+EXPORT_SYMBOL(genericbl_limit_intensity);
 static const struct backlight_ops genericbl_ops = {
        .options = BL_CORE_SUSPENDRESUME,
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index 98ad3e5f7c85..3543f1b7d5f1 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -52,15 +52,11 @@ static void l4f00242t03_lcd_init(struct spi_device *spi)
        dev_dbg(&spi->dev, "initializing LCD\n");
-        if (priv->io_reg) {
+        regulator_set_voltage(priv->io_reg, 1800000, 1800000);
-                regulator_set_voltage(priv->io_reg, 1800000, 1800000);
+        regulator_enable(priv->io_reg);
-                regulator_enable(priv->io_reg);
-        }
-        if (priv->core_reg) {
+        regulator_set_voltage(priv->core_reg, 2800000, 2800000);
-                regulator_set_voltage(priv->core_reg, 2800000, 2800000);
+        regulator_enable(priv->core_reg);
-                regulator_enable(priv->core_reg);
-        }
        l4f00242t03_reset(pdata->reset_gpio);
@@ -78,11 +74,8 @@ static void l4f00242t03_lcd_powerdown(struct spi_device *spi)
        gpio_set_value(pdata->data_enable_gpio, 0);
-        if (priv->io_reg)
+        regulator_disable(priv->io_reg);
-                regulator_disable(priv->io_reg);
+        regulator_disable(priv->core_reg);
-        if (priv->core_reg)
-                regulator_disable(priv->core_reg);
 }
 static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
@@ -178,47 +171,34 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
        priv->spi = spi;
-        ret = gpio_request(pdata->reset_gpio, "lcd l4f00242t03 reset");
+        ret = gpio_request_one(pdata->reset_gpio, GPIOF_OUT_INIT_HIGH,
+                                                "lcd l4f00242t03 reset");
        if (ret) {
                dev_err(&spi->dev,
                        "Unable to get the lcd l4f00242t03 reset gpio.\n");
                goto err;
        }
-        ret = gpio_direction_output(pdata->reset_gpio, 1);
+        ret = gpio_request_one(pdata->data_enable_gpio, GPIOF_OUT_INIT_LOW,
-        if (ret)
+                                                "lcd l4f00242t03 data enable");
-                goto err2;
-        ret = gpio_request(pdata->data_enable_gpio,
-                                "lcd l4f00242t03 data enable");
        if (ret) {
                dev_err(&spi->dev,
                        "Unable to get the lcd l4f00242t03 data en gpio.\n");
                goto err2;
        }
-        ret = gpio_direction_output(pdata->data_enable_gpio, 0);
+        priv->io_reg = regulator_get(&spi->dev, "vdd");
-        if (ret)
+        if (IS_ERR(priv->io_reg)) {
+                dev_err(&spi->dev, "%s: Unable to get the IO regulator\n",
+                       __func__);
                goto err3;
-        if (pdata->io_supply) {
-                priv->io_reg = regulator_get(NULL, pdata->io_supply);
-                if (IS_ERR(priv->io_reg)) {
-                        pr_err("%s: Unable to get the IO regulator\n",
-                                                                __func__);
-                        goto err3;
-                }
        }
-        if (pdata->core_supply) {
+        priv->core_reg = regulator_get(&spi->dev, "vcore");
-                priv->core_reg = regulator_get(NULL, pdata->core_supply);
+        if (IS_ERR(priv->core_reg)) {
+                dev_err(&spi->dev, "%s: Unable to get the core regulator\n",
-                if (IS_ERR(priv->core_reg)) {
+                       __func__);
-                        pr_err("%s: Unable to get the core regulator\n",
+                goto err4;
-                                                                __func__);
-                        goto err4;
-                }
        }
        priv->ld = lcd_device_register("l4f00242t03",
@@ -238,11 +218,9 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
        return 0;
 err5:
-        if (priv->core_reg)
+        regulator_put(priv->core_reg);
-                regulator_put(priv->core_reg);
 err4:
-        if (priv->io_reg)
+        regulator_put(priv->io_reg);
-                regulator_put(priv->io_reg);
 err3:
        gpio_free(pdata->data_enable_gpio);
 err2:
@@ -266,10 +244,8 @@ static int __devexit l4f00242t03_remove(struct spi_device *spi)
        gpio_free(pdata->data_enable_gpio);
        gpio_free(pdata->reset_gpio);
-        if (priv->io_reg)
+        regulator_put(priv->io_reg);
-                regulator_put(priv->io_reg);
+        regulator_put(priv->core_reg);
-        if (priv->core_reg)
-                regulator_put(priv->core_reg);
        kfree(priv);
diff --git a/fs/Kconfig b/fs/Kconfig
index 9fe0b349f4cd..5f4c45d4aa10 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -109,7 +109,7 @@ source "fs/proc/Kconfig"
 source "fs/sysfs/Kconfig"
 config TMPFS
-        bool "Virtual memory file system support (former shm fs)"
+        bool "Tmpfs virtual memory file system support (former shm fs)"
        depends on SHMEM
        help
          Tmpfs is a file system which keeps all files in virtual memory.
diff --git a/fs/aio.c b/fs/aio.c
index e29ec485af25..632b235f4fbe 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1387,13 +1387,13 @@ static ssize_t aio_setup_vectored_rw(int type, struct kiocb *kiocb, bool compat)
                ret = compat_rw_copy_check_uvector(type,
                                (struct compat_iovec __user *)kiocb->ki_buf,
                                kiocb->ki_nbytes, 1, &kiocb->ki_inline_vec,
-                                &kiocb->ki_iovec);
+                                &kiocb->ki_iovec, 1);
        else
 #endif
                ret = rw_copy_check_uvector(type,
                                (struct iovec __user *)kiocb->ki_buf,
                                kiocb->ki_nbytes, 1, &kiocb->ki_inline_vec,
-                                &kiocb->ki_iovec);
+                                &kiocb->ki_iovec, 1);
        if (ret < 0)
                goto out;
diff --git a/fs/buffer.c b/fs/buffer.c
index 936d6035f6e2..70a19745cb61 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -213,13 +213,16 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)
         * elsewhere, don't buffer_error if we had some unmapped buffers
         */
        if (all_mapped) {
+                char b[BDEVNAME_SIZE];
                printk("__find_get_block_slow() failed. "
                        "block=%llu, b_blocknr=%llu\n",
                        (unsigned long long)block,
                        (unsigned long long)bh->b_blocknr);
                printk("b_state=0x%08lx, b_size=%zu\n",
                        bh->b_state, bh->b_size);
-                printk("device blocksize: %d\n", 1 << bd_inode->i_blkbits);
+                printk("device %s blocksize: %d\n", bdevname(bdev, b),
+                        1 << bd_inode->i_blkbits);
        }
 out_unlock:
        spin_unlock(&bd_mapping->private_lock);
diff --git a/fs/compat.c b/fs/compat.c
index 302e761bd0aa..c98787536bb8 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -546,7 +546,7 @@ out:
 ssize_t compat_rw_copy_check_uvector(int type,
                const struct compat_iovec __user *uvector, unsigned long nr_segs,
                unsigned long fast_segs, struct iovec *fast_pointer,
-                struct iovec **ret_pointer)
+                struct iovec **ret_pointer, int check_access)
 {
        compat_ssize_t tot_len;
        struct iovec *iov = *ret_pointer = fast_pointer;
@@ -593,7 +593,8 @@ ssize_t compat_rw_copy_check_uvector(int type,
                }
                if (len < 0)    /* size_t not fitting in compat_ssize_t .. */
                        goto out;
-                if (!access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
+                if (check_access &&
+                    !access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
                        ret = -EFAULT;
                        goto out;
                }
@@ -1107,7 +1108,7 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
                goto out;
        tot_len = compat_rw_copy_check_uvector(type, uvector, nr_segs,
-                                               UIO_FASTIOV, iovstack, &iov);
+                                               UIO_FASTIOV, iovstack, &iov, 1);
        if (tot_len == 0) {
                ret = 0;
                goto out;
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index b36c5572b3f3..54481a3b2c79 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -514,7 +514,7 @@ ecryptfs_set_dentry_lower_mnt(struct dentry *dentry, struct vfsmount *lower_mnt)
 #define ecryptfs_printk(type, fmt, arg...) \
        __ecryptfs_printk(type "%s: " fmt, __func__, ## arg);
-__attribute__ ((format(printf, 1, 2)))
+__printf(1, 2)
 void __ecryptfs_printk(const char *fmt, ...);
 extern const struct file_operations ecryptfs_main_fops;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 9026fc91fe3b..828e750af23a 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -70,6 +70,15 @@
 * simultaneous inserts (A into B and B into A) from racing and
 * constructing a cycle without either insert observing that it is
 * going to.
+ * It is necessary to acquire multiple "ep->mtx"es at once in the
+ * case when one epoll fd is added to another. In this case, we
+ * always acquire the locks in the order of nesting (i.e. after
+ * epoll_ctl(e1, EPOLL_CTL_ADD, e2), e1->mtx will always be acquired
+ * before e2->mtx). Since we disallow cycles of epoll file
+ * descriptors, this ensures that the mutexes are well-ordered. In
+ * order to communicate this nesting to lockdep, when walking a tree
+ * of epoll file descriptors, we use the current recursion depth as
+ * the lockdep subkey.
 * It is possible to drop the "ep->mtx" and to use the global
 * mutex "epmutex" (together with "ep->lock") to have it working,
 * but having "ep->mtx" will make the interface more scalable.
@@ -464,13 +473,15 @@ static void ep_unregister_pollwait(struct eventpoll *ep, struct epitem *epi)
 * @ep: Pointer to the epoll private data structure.
 * @sproc: Pointer to the scan callback.
 * @priv: Private opaque data passed to the @sproc callback.
+ * @depth: The current depth of recursive f_op->poll calls.
 *
 * Returns: The same integer error code returned by the @sproc callback.
 */
 static int ep_scan_ready_list(struct eventpoll *ep,
                              int (*sproc)(struct eventpoll *,
                                           struct list_head *, void *),
-                              void *priv)
+                              void *priv,
+                              int depth)
 {
        int error, pwake = 0;
        unsigned long flags;
@@ -481,7 +492,7 @@ static int ep_scan_ready_list(struct eventpoll *ep,
         * We need to lock this because we could be hit by
         * eventpoll_release_file() and epoll_ctl().
         */
-        mutex_lock(&ep->mtx);
+        mutex_lock_nested(&ep->mtx, depth);
        /*
         * Steal the ready list, and re-init the original one to the
@@ -670,7 +681,7 @@ static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
 static int ep_poll_readyevents_proc(void *priv, void *cookie, int call_nests)
 {
-        return ep_scan_ready_list(priv, ep_read_events_proc, NULL);
+        return ep_scan_ready_list(priv, ep_read_events_proc, NULL, call_nests + 1);
 }
 static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
@@ -737,7 +748,7 @@ void eventpoll_release_file(struct file *file)
                ep = epi->ep;
                list_del_init(&epi->fllink);
-                mutex_lock(&ep->mtx);
+                mutex_lock_nested(&ep->mtx, 0);
                ep_remove(ep, epi);
                mutex_unlock(&ep->mtx);
        }
@@ -1134,7 +1145,7 @@ static int ep_send_events(struct eventpoll *ep,
        esed.maxevents = maxevents;
        esed.events = events;
-        return ep_scan_ready_list(ep, ep_send_events_proc, &esed);
+        return ep_scan_ready_list(ep, ep_send_events_proc, &esed, 0);
 }
 static inline struct timespec ep_set_mstimeout(long ms)
@@ -1267,7 +1278,7 @@ static int ep_loop_check_proc(void *priv, void *cookie, int call_nests)
        struct rb_node *rbp;
        struct epitem *epi;
-        mutex_lock(&ep->mtx);
+        mutex_lock_nested(&ep->mtx, call_nests + 1);
        for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
                epi = rb_entry(rbp, struct epitem, rbn);
                if (unlikely(is_file_epoll(epi->ffd.file))) {
@@ -1409,7 +1420,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
        }
-        mutex_lock(&ep->mtx);
+        mutex_lock_nested(&ep->mtx, 0);
        /*
         * Try to lookup the file inside our RB tree, Since we grabbed "mtx"
diff --git a/fs/exec.c b/fs/exec.c
index 25dcbe5fc356..36254645b7cc 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -841,10 +841,6 @@ static int exec_mmap(struct mm_struct *mm)
        tsk->mm = mm;
        tsk->active_mm = mm;
        activate_mm(active_mm, mm);
-        if (old_mm && tsk->signal->oom_score_adj == OOM_SCORE_ADJ_MIN) {
-                atomic_dec(&old_mm->oom_disable_count);
-                atomic_inc(&tsk->mm->oom_disable_count);
-        }
        task_unlock(tsk);
        arch_pick_mmap_layout(mm);
        if (old_mm) {
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index af9fc89b1b2d..9a4e5e206d08 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -135,10 +135,10 @@ extern long ext2_compat_ioctl(struct file *, unsigned int, unsigned long);
 struct dentry *ext2_get_parent(struct dentry *child);
 /* super.c */
-extern void ext2_error (struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext2_error(struct super_block *, const char *, const char *, ...);
-extern void ext2_msg(struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext2_msg(struct super_block *, const char *, const char *, ...);
 extern void ext2_update_dynamic_rev (struct super_block *sb);
 extern void ext2_write_super (struct super_block *);
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index b7d7bd0f066e..cec3145e532c 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1878,40 +1878,40 @@ extern int ext4_group_extend(struct super_block *sb,
 extern void *ext4_kvmalloc(size_t size, gfp_t flags);
 extern void *ext4_kvzalloc(size_t size, gfp_t flags);
 extern void ext4_kvfree(void *ptr);
-extern void __ext4_error(struct super_block *, const char *, unsigned int,
+extern __printf(4, 5)
-                         const char *, ...)
+void __ext4_error(struct super_block *, const char *, unsigned int,
-        __attribute__ ((format (printf, 4, 5)));
+                  const char *, ...);
 #define ext4_error(sb, message...)      __ext4_error(sb, __func__,      \
                                                     __LINE__, ## message)
-extern void ext4_error_inode(struct inode *, const char *, unsigned int,
+extern __printf(5, 6)
-                             ext4_fsblk_t, const char *, ...)
+void ext4_error_inode(struct inode *, const char *, unsigned int, ext4_fsblk_t,
-        __attribute__ ((format (printf, 5, 6)));
+                      const char *, ...);
-extern void ext4_error_file(struct file *, const char *, unsigned int,
+extern __printf(5, 6)
-                            ext4_fsblk_t, const char *, ...)
+void ext4_error_file(struct file *, const char *, unsigned int, ext4_fsblk_t,
-        __attribute__ ((format (printf, 5, 6)));
+                     const char *, ...);
 extern void __ext4_std_error(struct super_block *, const char *,
                             unsigned int, int);
-extern void __ext4_abort(struct super_block *, const char *, unsigned int,
+extern __printf(4, 5)
-                       const char *, ...)
+void __ext4_abort(struct super_block *, const char *, unsigned int,
-        __attribute__ ((format (printf, 4, 5)));
+                  const char *, ...);
 #define ext4_abort(sb, message...)      __ext4_abort(sb, __func__, \
                                                       __LINE__, ## message)
-extern void __ext4_warning(struct super_block *, const char *, unsigned int,
+extern __printf(4, 5)
-                          const char *, ...)
+void __ext4_warning(struct super_block *, const char *, unsigned int,
-        __attribute__ ((format (printf, 4, 5)));
+                    const char *, ...);
 #define ext4_warning(sb, message...)    __ext4_warning(sb, __func__, \
                                                       __LINE__, ## message)
-extern void ext4_msg(struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext4_msg(struct super_block *, const char *, const char *, ...);
 extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
                           const char *, unsigned int, const char *);
 #define dump_mmp_msg(sb, mmp, msg)      __dump_mmp_msg(sb, mmp, __func__, \
                                                       __LINE__, msg)
-extern void __ext4_grp_locked_error(const char *, unsigned int, \
+extern __printf(7, 8)
-                                    struct super_block *, ext4_group_t, \
+void __ext4_grp_locked_error(const char *, unsigned int,
-                                    unsigned long, ext4_fsblk_t, \
+                             struct super_block *, ext4_group_t,
-                                    const char *, ...)
+                             unsigned long, ext4_fsblk_t,
-        __attribute__ ((format (printf, 7, 8)));
+                             const char *, ...);
 #define ext4_grp_locked_error(sb, grp, message...) \
        __ext4_grp_locked_error(__func__, __LINE__, (sb), (grp), ## message)
 extern void ext4_update_dynamic_rev(struct super_block *sb);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 986e2388f031..0defe0bfe019 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1811,8 +1811,12 @@ static int ext4_writepage(struct page *page,
                 * We don't want to do block allocation, so redirty
                 * the page and return.  We may reach here when we do
                 * a journal commit via journal_submit_inode_data_buffers.
-                 * We can also reach here via shrink_page_list
+                 * We can also reach here via shrink_page_list but it
+                 * should never be for direct reclaim so warn if that
+                 * happens
                 */
+                WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
+                                                                PF_MEMALLOC);
                goto redirty_page;
        }
        if (commit_write)
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 5efbd5d7701a..aca191bd5f8f 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -156,8 +156,8 @@ static int uni16_to_x8(struct super_block *sb, unsigned char *ascii,
                } else {
                        if (uni_xlate == 1) {
                                *op++ = ':';
-                                op = pack_hex_byte(op, ec >> 8);
+                                op = hex_byte_pack(op, ec >> 8);
-                                op = pack_hex_byte(op, ec);
+                                op = hex_byte_pack(op, ec);
                                len -= 5;
                        } else {
                                *op++ = '?';
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index a5d3853822e0..1510a4d51990 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -326,15 +326,14 @@ extern int fat_fill_super(struct super_block *sb, void *data, int silent,
 extern int fat_flush_inodes(struct super_block *sb, struct inode *i1,
                            struct inode *i2);
 /* fat/misc.c */
-extern void
+extern __printf(3, 4) __cold
-__fat_fs_error(struct super_block *sb, int report, const char *fmt, ...)
+void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...);
-        __attribute__ ((format (printf, 3, 4))) __cold;
 #define fat_fs_error(sb, fmt, args...)          \
        __fat_fs_error(sb, 1, fmt , ## args)
 #define fat_fs_error_ratelimit(sb, fmt, args...) \
        __fat_fs_error(sb, __ratelimit(&MSDOS_SB(sb)->ratelimit), fmt , ## args)
-void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...)
+__printf(3, 4) __cold
-        __attribute__ ((format (printf, 3, 4))) __cold;
+void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...);
 extern int fat_clusters_flush(struct super_block *sb);
 extern int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster);
 extern void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec *ts,
diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
index 66707118af25..2553b858a72e 100644
--- a/fs/gfs2/glock.h
+++ b/fs/gfs2/glock.h
@@ -201,7 +201,7 @@ int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs);
 void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs);
 void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs);
-__attribute__ ((format(printf, 2, 3)))
+__printf(2, 3)
 void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...);
 /**
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index 331b5e234ef3..de946170ebb1 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -311,8 +311,8 @@ static inline struct hpfs_sb_info *hpfs_sb(struct super_block *sb)
 /* super.c */
-void hpfs_error(struct super_block *, const char *, ...)
+__printf(2, 3)
-        __attribute__((format (printf, 2, 3)));
+void hpfs_error(struct super_block *, const char *, ...);
 int hpfs_stop_cycles(struct super_block *, int, int *, int *, char *);
 unsigned hpfs_count_one_bitmap(struct super_block *, secno);
diff --git a/fs/logfs/logfs.h b/fs/logfs/logfs.h
index f22d108bfa5d..398ecff6e548 100644
--- a/fs/logfs/logfs.h
+++ b/fs/logfs/logfs.h
@@ -618,7 +618,6 @@ static inline int logfs_buf_recover(struct logfs_area *area, u64 ofs,
 struct page *emergency_read_begin(struct address_space *mapping, pgoff_t index);
 void emergency_read_end(struct page *page);
 void logfs_crash_dump(struct super_block *sb);
-void *memchr_inv(const void *s, int c, size_t n);
 int logfs_statfs(struct dentry *dentry, struct kstatfs *stats);
 int logfs_check_ds(struct logfs_disk_super *ds);
 int logfs_write_sb(struct super_block *sb);
diff --git a/fs/logfs/super.c b/fs/logfs/super.c
index ce03a182c771..f2697e4df109 100644
--- a/fs/logfs/super.c
+++ b/fs/logfs/super.c
@@ -91,28 +91,6 @@ void logfs_crash_dump(struct super_block *sb)
 }
 /*
- * TODO: move to lib/string.c
- */
-/**
- * memchr_inv - Find a character in an area of memory.
- * @s: The memory area
- * @c: The byte to search for
- * @n: The size of the area.
- *
- * returns the address of the first character other than @c, or %NULL
- * if the whole buffer contains just @c.
- */
-void *memchr_inv(const void *s, int c, size_t n)
-{
-        const unsigned char *p = s;
-        while (n-- != 0)
-                if ((unsigned char)c != *p++)
-                        return (void *)(p - 1);
-        return NULL;
-}
-/*
 * FIXME: There should be a reserve for root, similar to ext2.
 */
 int logfs_statfs(struct dentry *dentry, struct kstatfs *stats)
diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index 255d5e1c03b7..3777d138f895 100644
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -276,10 +276,10 @@ int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 /* super.c */
 extern struct inode *nilfs_alloc_inode(struct super_block *);
 extern void nilfs_destroy_inode(struct inode *);
-extern void nilfs_error(struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void nilfs_error(struct super_block *, const char *, const char *, ...);
-extern void nilfs_warning(struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void nilfs_warning(struct super_block *, const char *, const char *, ...);
 extern struct nilfs_super_block *
 nilfs_read_super_block(struct super_block *, u64, int, struct buffer_head **);
 extern int nilfs_store_magic_and_option(struct super_block *,
diff --git a/fs/ntfs/debug.h b/fs/ntfs/debug.h
index 2142b1c68b61..53c27eaf2307 100644
--- a/fs/ntfs/debug.h
+++ b/fs/ntfs/debug.h
@@ -30,8 +30,9 @@
 extern int debug_msgs;
-extern void __ntfs_debug(const char *file, int line, const char *function,
+extern __printf(4, 5)
-        const char *format, ...) __attribute__ ((format (printf, 4, 5)));
+void __ntfs_debug(const char *file, int line, const char *function,
+                  const char *format, ...);
 /**
 * ntfs_debug - write a debug level message to syslog
 * @f:          a printf format string containing the message
@@ -52,12 +53,14 @@ extern void ntfs_debug_dump_runlist(const runlist_element *rl);
 #endif  /* !DEBUG */
-extern void __ntfs_warning(const char *function, const struct super_block *sb,
+extern  __printf(3, 4)
-                const char *fmt, ...) __attribute__ ((format (printf, 3, 4)));
+void __ntfs_warning(const char *function, const struct super_block *sb,
+                    const char *fmt, ...);
 #define ntfs_warning(sb, f, a...)       __ntfs_warning(__func__, sb, f, ##a)
-extern void __ntfs_error(const char *function, const struct super_block *sb,
+extern  __printf(3, 4)
-                const char *fmt, ...) __attribute__ ((format (printf, 3, 4)));
+void __ntfs_error(const char *function, const struct super_block *sb,
+                  const char *fmt, ...);
 #define ntfs_error(sb, f, a...)         __ntfs_error(__func__, sb, f, ##a)
 #endif /* _LINUX_NTFS_DEBUG_H */
diff --git a/fs/ocfs2/super.h b/fs/ocfs2/super.h
index 40c7de084c10..74ff74cf78fe 100644
--- a/fs/ocfs2/super.h
+++ b/fs/ocfs2/super.h
@@ -31,17 +31,15 @@ extern struct workqueue_struct *ocfs2_wq;
 int ocfs2_publish_get_mount_state(struct ocfs2_super *osb,
                                  int node_num);
-void __ocfs2_error(struct super_block *sb,
+__printf(3, 4)
-                   const char *function,
+void __ocfs2_error(struct super_block *sb, const char *function,
-                   const char *fmt, ...)
+                   const char *fmt, ...);
-        __attribute__ ((format (printf, 3, 4)));
 #define ocfs2_error(sb, fmt, args...) __ocfs2_error(sb, __PRETTY_FUNCTION__, fmt, ##args)
-void __ocfs2_abort(struct super_block *sb,
+__printf(3, 4)
-                   const char *function,
+void __ocfs2_abort(struct super_block *sb, const char *function,
-                   const char *fmt, ...)
+                   const char *fmt, ...);
-        __attribute__ ((format (printf, 3, 4)));
 #define ocfs2_abort(sb, fmt, args...) __ocfs2_abort(sb, __PRETTY_FUNCTION__, fmt, ##args)
diff --git a/fs/partitions/ldm.c b/fs/partitions/ldm.c
index af9fdf046769..bd8ae788f689 100644
--- a/fs/partitions/ldm.c
+++ b/fs/partitions/ldm.c
@@ -49,18 +49,20 @@
 #define ldm_error(f, a...) _ldm_printk (KERN_ERR,   __func__, f, ##a)
 #define ldm_info(f, a...)  _ldm_printk (KERN_INFO,  __func__, f, ##a)
-__attribute__ ((format (printf, 3, 4)))
+static __printf(3, 4)
-static void _ldm_printk (const char *level, const char *function,
+void _ldm_printk(const char *level, const char *function, const char *fmt, ...)
-                         const char *fmt, ...)
 {
-        static char buf[128];
+        struct va_format vaf;
        va_list args;
        va_start (args, fmt);
-        vsnprintf (buf, sizeof (buf), fmt, args);
-        va_end (args);
-        printk ("%s%s(): %s\n", level, function, buf);
+        vaf.fmt = fmt;
+        vaf.va = &args;
+        printk("%s%s(): %pV\n", level, function, &vaf);
+        va_end(args);
 }
 /**
diff --git a/fs/pipe.c b/fs/pipe.c
index 0e0be1dc0f8e..4065f07366b3 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -1254,6 +1254,7 @@ out:
 static const struct super_operations pipefs_ops = {
        .destroy_inode = free_inode_nonrcu,
+        .statfs = simple_statfs,
 };
 /*
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 5eb02069e1b8..8f0087e20e16 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1107,13 +1107,6 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
                goto err_sighand;
        }
-        if (oom_adjust != task->signal->oom_adj) {
-                if (oom_adjust == OOM_DISABLE)
-                        atomic_inc(&task->mm->oom_disable_count);
-                if (task->signal->oom_adj == OOM_DISABLE)
-                        atomic_dec(&task->mm->oom_disable_count);
-        }
        /*
         * Warn that /proc/pid/oom_adj is deprecated, see
         * Documentation/feature-removal-schedule.txt.
@@ -1215,12 +1208,6 @@ static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
                goto err_sighand;
        }
-        if (oom_score_adj != task->signal->oom_score_adj) {
-                if (oom_score_adj == OOM_SCORE_ADJ_MIN)
-                        atomic_inc(&task->mm->oom_disable_count);
-                if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
-                        atomic_dec(&task->mm->oom_disable_count);
-        }
        task->signal->oom_score_adj = oom_score_adj;
        if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
                task->signal->oom_score_adj_min = oom_score_adj;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 5afaa58a8630..e418c5abdb0e 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -44,6 +44,7 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                "VmPeak:\t%8lu kB\n"
                "VmSize:\t%8lu kB\n"
                "VmLck:\t%8lu kB\n"
+                "VmPin:\t%8lu kB\n"
                "VmHWM:\t%8lu kB\n"
                "VmRSS:\t%8lu kB\n"
                "VmData:\t%8lu kB\n"
@@ -55,6 +56,7 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                hiwater_vm << (PAGE_SHIFT-10),
                (total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
                mm->locked_vm << (PAGE_SHIFT-10),
+                mm->pinned_vm << (PAGE_SHIFT-10),
                hiwater_rss << (PAGE_SHIFT-10),
                total_rss << (PAGE_SHIFT-10),
                data << (PAGE_SHIFT-10),
@@ -1039,6 +1041,9 @@ static int show_numa_map(struct seq_file *m, void *v)
                seq_printf(m, " stack");
        }
+        if (is_vm_hugetlb_page(vma))
+                seq_printf(m, " huge");
        walk_page_range(vma->vm_start, vma->vm_end, &walk);
        if (!md->pages)
diff --git a/fs/read_write.c b/fs/read_write.c
index dfd125798791..5ad4248b0cd8 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -633,7 +633,8 @@ ssize_t do_loop_readv_writev(struct file *filp, struct iovec *iov,
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
                              unsigned long nr_segs, unsigned long fast_segs,
                              struct iovec *fast_pointer,
-                              struct iovec **ret_pointer)
+                              struct iovec **ret_pointer,
+                              int check_access)
 {
        unsigned long seg;
        ssize_t ret;
@@ -689,7 +690,8 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
                        ret = -EINVAL;
                        goto out;
                }
-                if (unlikely(!access_ok(vrfy_dir(type), buf, len))) {
+                if (check_access
+                    && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
                        ret = -EFAULT;
                        goto out;
                }
@@ -721,7 +723,7 @@ static ssize_t do_readv_writev(int type, struct file *file,
        }
        ret = rw_copy_check_uvector(type, uvector, nr_segs,
-                        ARRAY_SIZE(iovstack), iovstack, &iov);
+                                    ARRAY_SIZE(iovstack), iovstack, &iov, 1);
        if (ret <= 0)
                goto out;
diff --git a/fs/super.c b/fs/super.c
index 3f56a269a4f4..32a81f3467e0 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -61,7 +61,7 @@ static int prune_super(struct shrinker *shrink, struct shrink_control *sc)
                return -1;
        if (!grab_super_passive(sb))
-                return -1;
+                return !sc->nr_to_scan ? 0 : -1;
        if (sb->s_op && sb->s_op->nr_cached_objects)
                fs_objects = sb->s_op->nr_cached_objects(sb);
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index dbd52d4b5eed..dc8a8dcc5ae1 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -112,8 +112,8 @@ struct extent_position {
 /* super.c */
-__attribute__((format(printf, 3, 4)))
+extern __printf(3, 4) void udf_warning(struct super_block *, const char *,
-extern void udf_warning(struct super_block *, const char *, const char *, ...);
+                                        const char *, ...);
 static inline void udf_updated_lvid(struct super_block *sb)
 {
        struct buffer_head *bh = UDF_SB(sb)->s_lvid_bh;
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index 5be2755dd715..c26f2bcec264 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -117,9 +117,12 @@ extern int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buf
 extern const struct file_operations ufs_dir_operations;
 /* super.c */
-extern void ufs_warning (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern __printf(3, 4)
-extern void ufs_error (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+void ufs_warning(struct super_block *, const char *, const char *, ...);
-extern void ufs_panic (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern __printf(3, 4)
+void ufs_error(struct super_block *, const char *, const char *, ...);
+extern __printf(3, 4)
+void ufs_panic(struct super_block *, const char *, const char *, ...);
 /* symlink.c */
 extern const struct inode_operations ufs_fast_symlink_inode_operations;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 11b2aad982d4..33b13310ee0c 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -902,11 +902,11 @@ xfs_vm_writepage(
         * random callers for direct reclaim or memcg reclaim.  We explicitly
         * allow reclaim from kswapd as the stack usage there is relatively low.
         *
-         * This should really be done by the core VM, but until that happens
+         * This should never happen except in the case of a VM regression so
-         * filesystems like XFS, btrfs and ext4 have to take care of this
+         * warn about it.
-         * by themselves.
         */
-        if ((current->flags & (PF_MEMALLOC|PF_KSWAPD)) == PF_MEMALLOC)
+        if (WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
+                        PF_MEMALLOC))
                goto redirty;
        /*
diff --git a/fs/xfs/xfs_message.h b/fs/xfs/xfs_message.h
index 7fb7ea007672..56dc0c17f16a 100644
--- a/fs/xfs/xfs_message.h
+++ b/fs/xfs/xfs_message.h
@@ -3,31 +3,29 @@
 struct xfs_mount;
-extern void xfs_emerg(const struct xfs_mount *mp, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void xfs_emerg(const struct xfs_mount *mp, const char *fmt, ...);
-extern void xfs_alert(const struct xfs_mount *mp, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void xfs_alert(const struct xfs_mount *mp, const char *fmt, ...);
-extern void xfs_alert_tag(const struct xfs_mount *mp, int tag,
+extern __printf(3, 4)
-                         const char *fmt, ...)
+void xfs_alert_tag(const struct xfs_mount *mp, int tag, const char *fmt, ...);
-        __attribute__ ((format (printf, 3, 4)));
+extern __printf(2, 3)
-extern void xfs_crit(const struct xfs_mount *mp, const char *fmt, ...)
+void xfs_crit(const struct xfs_mount *mp, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern void xfs_err(const struct xfs_mount *mp, const char *fmt, ...)
+void xfs_err(const struct xfs_mount *mp, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern void xfs_warn(const struct xfs_mount *mp, const char *fmt, ...)
+void xfs_warn(const struct xfs_mount *mp, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern void xfs_notice(const struct xfs_mount *mp, const char *fmt, ...)
+void xfs_notice(const struct xfs_mount *mp, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern void xfs_info(const struct xfs_mount *mp, const char *fmt, ...)
+void xfs_info(const struct xfs_mount *mp, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
 #ifdef DEBUG
-extern void xfs_debug(const struct xfs_mount *mp, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void xfs_debug(const struct xfs_mount *mp, const char *fmt, ...);
 #else
-static inline void
+static inline __printf(2, 3)
-__attribute__ ((format (printf, 2, 3)))
+void xfs_debug(const struct xfs_mount *mp, const char *fmt, ...)
-xfs_debug(const struct xfs_mount *mp, const char *fmt, ...)
 {
 }
 #endif
diff --git a/include/asm-generic/bug.h b/include/asm-generic/bug.h
index dfb0ec666c94..84458b0c38d1 100644
--- a/include/asm-generic/bug.h
+++ b/include/asm-generic/bug.h
@@ -61,11 +61,12 @@ struct bug_entry {
 */
 #ifndef __WARN_TAINT
 #ifndef __ASSEMBLY__
-extern void warn_slowpath_fmt(const char *file, const int line,
+extern __printf(3, 4)
-                const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+void warn_slowpath_fmt(const char *file, const int line,
-extern void warn_slowpath_fmt_taint(const char *file, const int line,
+                       const char *fmt, ...);
-                                    unsigned taint, const char *fmt, ...)
+extern __printf(4, 5)
-        __attribute__((format(printf, 4, 5)));
+void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint,
+                             const char *fmt, ...);
 extern void warn_slowpath_null(const char *file, const int line);
 #define WANT_WARN_ON_SLOWPATH
 #endif
diff --git a/include/asm-generic/dma-mapping-common.h b/include/asm-generic/dma-mapping-common.h
index 0c80bb38773f..9fa3f96e38cf 100644
--- a/include/asm-generic/dma-mapping-common.h
+++ b/include/asm-generic/dma-mapping-common.h
@@ -123,7 +123,12 @@ static inline void dma_sync_single_range_for_cpu(struct device *dev,
                                                 size_t size,
                                                 enum dma_data_direction dir)
 {
-        dma_sync_single_for_cpu(dev, addr + offset, size, dir);
+        const struct dma_map_ops *ops = get_dma_ops(dev);
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_for_cpu)
+                ops->sync_single_for_cpu(dev, addr + offset, size, dir);
+        debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
 }
 static inline void dma_sync_single_range_for_device(struct device *dev,
@@ -132,7 +137,12 @@ static inline void dma_sync_single_range_for_device(struct device *dev,
                                                    size_t size,
                                                    enum dma_data_direction dir)
 {
-        dma_sync_single_for_device(dev, addr + offset, size, dir);
+        const struct dma_map_ops *ops = get_dma_ops(dev);
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_for_device)
+                ops->sync_single_for_device(dev, addr + offset, size, dir);
+        debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
 }
 static inline void
diff --git a/include/asm-generic/page.h b/include/asm-generic/page.h
index 75fec18cdc59..351889d1de19 100644
--- a/include/asm-generic/page.h
+++ b/include/asm-generic/page.h
@@ -79,8 +79,8 @@ extern unsigned long memory_end;
 #define virt_to_pfn(kaddr)      (__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_to_virt(pfn)        __va((pfn) << PAGE_SHIFT)
-#define virt_to_page(addr)      (mem_map + (((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT))
+#define virt_to_page(addr)      pfn_to_page(virt_to_pfn(addr))
-#define page_to_virt(page)      ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
+#define page_to_virt(page)      pfn_to_virt(page_to_pfn(page))
 #ifndef page_to_phys
 #define page_to_phys(page)      ((dma_addr_t)page_to_pfn(page) << PAGE_SHIFT)
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 43538b643560..cf3b446139ea 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -122,12 +122,12 @@ struct drm_device;
 * using the DRM_DEBUG_KMS and DRM_DEBUG.
 */
-extern __attribute__((format (printf, 4, 5)))
+extern __printf(4, 5)
 void drm_ut_debug_printk(unsigned int request_level,
-                                const char *prefix,
+                         const char *prefix,
-                                const char *function_name,
+                         const char *function_name,
-                                const char *format, ...);
+                         const char *format, ...);
-extern __attribute__((format (printf, 2, 3)))
+extern __printf(2, 3)
 int drm_err(const char *func, const char *format, ...);
 /***********************************************************************/
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 0c8006129fb2..2f81c6f3b630 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -584,14 +584,13 @@ extern int audit_signals;
 #ifdef CONFIG_AUDIT
 /* These are defined in audit.c */
                                /* Public API */
-extern void                 audit_log(struct audit_context *ctx, gfp_t gfp_mask,
+extern __printf(4, 5)
-                                      int type, const char *fmt, ...)
+void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
-                                      __attribute__((format(printf,4,5)));
+               const char *fmt, ...);
 extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, int type);
-extern void                 audit_log_format(struct audit_buffer *ab,
+extern __printf(2, 3)
-                                             const char *fmt, ...)
+void audit_log_format(struct audit_buffer *ab, const char *fmt, ...);
-                            __attribute__((format(printf,2,3)));
 extern void                 audit_log_end(struct audit_buffer *ab);
 extern int                  audit_string_contains_control(const char *string,
                                                          size_t len);
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 8e9e4bc6d73b..4d1a0748eaf8 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -170,7 +170,7 @@ extern void blk_trace_shutdown(struct request_queue *);
 extern int do_blk_trace_setup(struct request_queue *q, char *name,
                              dev_t dev, struct block_device *bdev,
                              struct blk_user_trace_setup *buts);
-extern __attribute__((format(printf, 2, 3)))
+extern __printf(2, 3)
 void __trace_note_message(struct blk_trace *, const char *fmt, ...);
 /**
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index cc9f7a428649..bb2bbdbe5464 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -24,8 +24,6 @@ extern unsigned long try_to_compact_pages(struct zonelist *zonelist,
                        int order, gfp_t gfp_mask, nodemask_t *mask,
                        bool sync);
 extern unsigned long compaction_suitable(struct zone *zone, int order);
-extern unsigned long compact_zone_order(struct zone *zone, int order,
-                                        gfp_t gfp_mask, bool sync);
 /* Do not skip compaction more than 64 times */
 #define COMPACT_MAX_DEFER_SHIFT 6
@@ -69,12 +67,6 @@ static inline unsigned long compaction_suitable(struct zone *zone, int order)
        return COMPACT_SKIPPED;
 }
-static inline unsigned long compact_zone_order(struct zone *zone, int order,
-                                               gfp_t gfp_mask, bool sync)
-{
-        return COMPACT_CONTINUE;
-}
 static inline void defer_compaction(struct zone *zone)
 {
 }
diff --git a/include/linux/compat.h b/include/linux/compat.h
index c6e7523bf765..154bf5683015 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -547,7 +547,8 @@ extern ssize_t compat_rw_copy_check_uvector(int type,
                const struct compat_iovec __user *uvector,
                unsigned long nr_segs,
                unsigned long fast_segs, struct iovec *fast_pointer,
-                struct iovec **ret_pointer);
+                struct iovec **ret_pointer,
+                int check_access);
 extern void __user *compat_alloc_user_space(unsigned long len);
diff --git a/include/linux/device.h b/include/linux/device.h
index 85e78fc7d7fd..e88abeecfadf 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -622,8 +622,8 @@ static inline const char *dev_name(const struct device *dev)
        return kobject_name(&dev->kobj);
 }
-extern int dev_set_name(struct device *dev, const char *name, ...)
+extern __printf(2, 3)
-                        __attribute__((format(printf, 2, 3)));
+int dev_set_name(struct device *dev, const char *name, ...);
 #ifdef CONFIG_NUMA
 static inline int dev_to_node(struct device *dev)
@@ -753,10 +753,10 @@ extern struct device *device_create_vargs(struct class *cls,
                                          void *drvdata,
                                          const char *fmt,
                                          va_list vargs);
-extern struct device *device_create(struct class *cls, struct device *parent,
+extern __printf(5, 6)
-                                    dev_t devt, void *drvdata,
+struct device *device_create(struct class *cls, struct device *parent,
-                                    const char *fmt, ...)
+                             dev_t devt, void *drvdata,
-                                    __attribute__((format(printf, 5, 6)));
+                             const char *fmt, ...);
 extern void device_destroy(struct class *cls, dev_t devt);
 /*
@@ -800,64 +800,56 @@ extern const char *dev_driver_string(const struct device *dev);
 extern int __dev_printk(const char *level, const struct device *dev,
                        struct va_format *vaf);
-extern int dev_printk(const char *level, const struct device *dev,
+extern __printf(3, 4)
-                      const char *fmt, ...)
+int dev_printk(const char *level, const struct device *dev,
-        __attribute__ ((format (printf, 3, 4)));
+               const char *fmt, ...)
-extern int dev_emerg(const struct device *dev, const char *fmt, ...)
+        ;
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int dev_alert(const struct device *dev, const char *fmt, ...)
+int dev_emerg(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int dev_crit(const struct device *dev, const char *fmt, ...)
+int dev_alert(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int dev_err(const struct device *dev, const char *fmt, ...)
+int dev_crit(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int dev_warn(const struct device *dev, const char *fmt, ...)
+int dev_err(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int dev_notice(const struct device *dev, const char *fmt, ...)
+int dev_warn(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
-extern int _dev_info(const struct device *dev, const char *fmt, ...)
+int dev_notice(const struct device *dev, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
+extern __printf(2, 3)
+int _dev_info(const struct device *dev, const char *fmt, ...);
 #else
 static inline int __dev_printk(const char *level, const struct device *dev,
                               struct va_format *vaf)
-         { return 0; }
+{ return 0; }
-static inline int dev_printk(const char *level, const struct device *dev,
+static inline __printf(3, 4)
-                      const char *fmt, ...)
+int dev_printk(const char *level, const struct device *dev,
-        __attribute__ ((format (printf, 3, 4)));
+               const char *fmt, ...)
-static inline int dev_printk(const char *level, const struct device *dev,
+{ return 0; }
-                      const char *fmt, ...)
-         { return 0; }
+static inline __printf(2, 3)
+int dev_emerg(const struct device *dev, const char *fmt, ...)
-static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
+{ return 0; }
-        __attribute__ ((format (printf, 2, 3)));
+static inline __printf(2, 3)
-static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
+int dev_crit(const struct device *dev, const char *fmt, ...)
-        { return 0; }
+{ return 0; }
-static inline int dev_crit(const struct device *dev, const char *fmt, ...)
+static inline __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int dev_alert(const struct device *dev, const char *fmt, ...)
-static inline int dev_crit(const struct device *dev, const char *fmt, ...)
+{ return 0; }
-        { return 0; }
+static inline __printf(2, 3)
-static inline int dev_alert(const struct device *dev, const char *fmt, ...)
+int dev_err(const struct device *dev, const char *fmt, ...)
-        __attribute__ ((format (printf, 2, 3)));
+{ return 0; }
-static inline int dev_alert(const struct device *dev, const char *fmt, ...)
+static inline __printf(2, 3)
-        { return 0; }
+int dev_warn(const struct device *dev, const char *fmt, ...)
-static inline int dev_err(const struct device *dev, const char *fmt, ...)
+{ return 0; }
-        __attribute__ ((format (printf, 2, 3)));
+static inline __printf(2, 3)
-static inline int dev_err(const struct device *dev, const char *fmt, ...)
+int dev_notice(const struct device *dev, const char *fmt, ...)
-        { return 0; }
+{ return 0; }
-static inline int dev_warn(const struct device *dev, const char *fmt, ...)
+static inline __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int _dev_info(const struct device *dev, const char *fmt, ...)
-static inline int dev_warn(const struct device *dev, const char *fmt, ...)
+{ return 0; }
-        { return 0; }
-static inline int dev_notice(const struct device *dev, const char *fmt, ...)
-        __attribute__ ((format (printf, 2, 3)));
-static inline int dev_notice(const struct device *dev, const char *fmt, ...)
-        { return 0; }
-static inline int _dev_info(const struct device *dev, const char *fmt, ...)
-        __attribute__ ((format (printf, 2, 3)));
-static inline int _dev_info(const struct device *dev, const char *fmt, ...)
-        { return 0; }
 #endif
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index a8b1a847c103..731a60975101 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -26,6 +26,8 @@
 #include <linux/msi.h>
 #include <linux/irqreturn.h>
+struct acpi_dmar_header;
 /* DMAR Flags */
 #define DMAR_INTR_REMAP         0x1
 #define DMAR_X2APIC_OPT_OUT     0x2
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 13aae8087b56..0564e3c39882 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -37,22 +37,21 @@ int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 #if defined(CONFIG_DYNAMIC_DEBUG)
 extern int ddebug_remove_module(const char *mod_name);
-extern int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
 struct device;
-extern int __dynamic_dev_dbg(struct _ddebug *descriptor,
+extern __printf(3, 4)
-                             const struct device *dev,
+int __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
-                             const char *fmt, ...)
+                      const char *fmt, ...);
-        __attribute__ ((format (printf, 3, 4)));
 struct net_device;
-extern int __dynamic_netdev_dbg(struct _ddebug *descriptor,
+extern __printf(3, 4)
-                             const struct net_device *dev,
+int __dynamic_netdev_dbg(struct _ddebug *descriptor,
-                             const char *fmt, ...)
+                         const struct net_device *dev,
-        __attribute__ ((format (printf, 3, 4)));
+                         const char *fmt, ...);
 #define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt)                \
        static struct _ddebug __used __aligned(8)               \
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 67a803aee619..81965cce6bfa 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -937,15 +937,15 @@ extern int ext3_group_extend(struct super_block *sb,
                                ext3_fsblk_t n_blocks_count);
 /* super.c */
-extern void ext3_error (struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext3_error(struct super_block *, const char *, const char *, ...);
 extern void __ext3_std_error (struct super_block *, const char *, int);
-extern void ext3_abort (struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext3_abort(struct super_block *, const char *, const char *, ...);
-extern void ext3_warning (struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext3_warning(struct super_block *, const char *, const char *, ...);
-extern void ext3_msg(struct super_block *, const char *, const char *, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+void ext3_msg(struct super_block *, const char *, const char *, ...);
 extern void ext3_update_dynamic_rev (struct super_block *sb);
 #define ext3_std_error(sb, errno)                               \
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 14493a2d5a03..7a049fd2aa4c 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1633,9 +1633,10 @@ struct inode_operations {
 struct seq_file;
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
-                                unsigned long nr_segs, unsigned long fast_segs,
+                              unsigned long nr_segs, unsigned long fast_segs,
-                                struct iovec *fast_pointer,
+                              struct iovec *fast_pointer,
-                                struct iovec **ret_pointer);
+                              struct iovec **ret_pointer,
+                              int check_access);
 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
@@ -2634,8 +2635,8 @@ static const struct file_operations __fops = {				\
        .llseek  = generic_file_llseek,                                 \
 };
-static inline void __attribute__((format(printf, 1, 2)))
+static inline __printf(1, 2)
-__simple_attr_check_format(const char *fmt, ...)
+void __simple_attr_check_format(const char *fmt, ...)
 {
        /* don't do anything, just let the compiler check the arguments; */
 }
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index af095b54502e..ce31408b1e47 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -492,10 +492,10 @@ static inline void fscache_end_io(struct fscache_retrieval *op,
 /*
 * out-of-line cache backend functions
 */
-extern void fscache_init_cache(struct fscache_cache *cache,
+extern __printf(3, 4)
-                               const struct fscache_cache_ops *ops,
+void fscache_init_cache(struct fscache_cache *cache,
-                               const char *idfmt,
+                        const struct fscache_cache_ops *ops,
-                               ...) __attribute__ ((format (printf, 3, 4)));
+                        const char *idfmt, ...);
 extern int fscache_add_cache(struct fscache_cache *cache,
                             struct fscache_object *fsdef,
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
index b65a6f472775..069ee4139105 100644
--- a/include/linux/gameport.h
+++ b/include/linux/gameport.h
@@ -78,8 +78,8 @@ static inline void gameport_register_port(struct gameport *gameport)
 void gameport_unregister_port(struct gameport *gameport);
-void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
+__printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void gameport_set_phys(struct gameport *gameport, const char *fmt, ...);
 #else
@@ -93,8 +93,8 @@ static inline void gameport_unregister_port(struct gameport *gameport)
        return;
 }
-static inline void gameport_set_phys(struct gameport *gameport,
+static inline __printf(2, 3)
-                                     const char *fmt, ...)
+void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
 {
        return;
 }
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 48c32ebf65a7..a9ace9c32507 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -22,6 +22,11 @@ extern int zap_huge_pmd(struct mmu_gather *tlb,
 extern int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                        unsigned long addr, unsigned long end,
                        unsigned char *vec);
+extern int move_huge_pmd(struct vm_area_struct *vma,
+                         struct vm_area_struct *new_vma,
+                         unsigned long old_addr,
+                         unsigned long new_addr, unsigned long old_end,
+                         pmd_t *old_pmd, pmd_t *new_pmd);
 extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                        unsigned long addr, pgprot_t newprot);
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index 0df513b7a9f8..387571959dd9 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -101,9 +101,8 @@ static inline int lookup_symbol_attrs(unsigned long addr, unsigned long *size, u
 #endif /*CONFIG_KALLSYMS*/
 /* This macro allows us to keep printk typechecking */
-static void __check_printsym_format(const char *fmt, ...)
+static __printf(1, 2)
-__attribute__((format(printf,1,2)));
+void __check_printsym_format(const char *fmt, ...)
-static inline void __check_printsym_format(const char *fmt, ...)
 {
 }
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
index 529d9a0c75a5..064725854db8 100644
--- a/include/linux/kdb.h
+++ b/include/linux/kdb.h
@@ -114,12 +114,9 @@ typedef enum {
 } kdb_reason_t;
 extern int kdb_trap_printk;
-extern int vkdb_printf(const char *fmt, va_list args)
+extern __printf(1, 0) int vkdb_printf(const char *fmt, va_list args);
-            __attribute__ ((format (printf, 1, 0)));
+extern __printf(1, 2) int kdb_printf(const char *, ...);
-extern int kdb_printf(const char *, ...)
+typedef __printf(1, 2) int (*kdb_printf_t)(const char *, ...);
-            __attribute__ ((format (printf, 1, 2)));
-typedef int (*kdb_printf_t)(const char *, ...)
-             __attribute__ ((format (printf, 1, 2)));
 extern void kdb_init(int level);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 8eefcf7e95eb..4c0d3b2fd5fc 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -287,6 +287,8 @@ static inline int __must_check kstrtos32_from_user(const char __user *s, size_t
        return kstrtoint_from_user(s, count, base, res);
 }
+/* Obsolete, do not use.  Use kstrto<foo> instead */
 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
 extern long simple_strtol(const char *,char **,unsigned int);
 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
@@ -296,20 +298,20 @@ extern long long simple_strtoll(const char *,char **,unsigned int);
 #define strict_strtoull kstrtoull
 #define strict_strtoll  kstrtoll
-extern int sprintf(char * buf, const char * fmt, ...)
+/* lib/printf utilities */
-        __attribute__ ((format (printf, 2, 3)));
-extern int vsprintf(char *buf, const char *, va_list)
+extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
-        __attribute__ ((format (printf, 2, 0)));
+extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list);
-extern int snprintf(char * buf, size_t size, const char * fmt, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+int snprintf(char *buf, size_t size, const char *fmt, ...);
-extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
+extern __printf(3, 0)
-        __attribute__ ((format (printf, 3, 0)));
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
-extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
+extern __printf(3, 4)
-        __attribute__ ((format (printf, 3, 4)));
+int scnprintf(char *buf, size_t size, const char *fmt, ...);
-extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+extern __printf(3, 0)
-        __attribute__ ((format (printf, 3, 0)));
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
-extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+char *kasprintf(gfp_t gfp, const char *fmt, ...);
 extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
 extern int sscanf(const char *, const char *, ...)
@@ -374,13 +376,18 @@ extern const char hex_asc[];
 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
 #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
-static inline char *pack_hex_byte(char *buf, u8 byte)
+static inline char *hex_byte_pack(char *buf, u8 byte)
 {
        *buf++ = hex_asc_hi(byte);
        *buf++ = hex_asc_lo(byte);
        return buf;
 }
+static inline char * __deprecated pack_hex_byte(char *buf, u8 byte)
+{
+        return hex_byte_pack(buf, byte);
+}
 extern int hex_to_bin(char ch);
 extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
@@ -427,8 +434,8 @@ extern void tracing_start(void);
 extern void tracing_stop(void);
 extern void ftrace_off_permanent(void);
-static inline void __attribute__ ((format (printf, 1, 2)))
+static inline __printf(1, 2)
-____trace_printk_check_format(const char *fmt, ...)
+void ____trace_printk_check_format(const char *fmt, ...)
 {
 }
 #define __trace_printk_check_format(fmt, args...)                       \
@@ -467,13 +474,11 @@ do {									\
                __trace_printk(_THIS_IP_, fmt, ##args);         \
 } while (0)
-extern int
+extern __printf(2, 3)
-__trace_bprintk(unsigned long ip, const char *fmt, ...)
+int __trace_bprintk(unsigned long ip, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
-extern int
+extern __printf(2, 3)
-__trace_printk(unsigned long ip, const char *fmt, ...)
+int __trace_printk(unsigned long ip, const char *fmt, ...);
-        __attribute__ ((format (printf, 2, 3)));
 extern void trace_dump_stack(void);
@@ -502,8 +507,8 @@ __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
 #else
-static inline int
+static inline __printf(1, 2)
-trace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+int trace_printk(const char *fmt, ...);
 static inline void tracing_start(void) { }
 static inline void tracing_stop(void) { }
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index fe45136b32cc..2fa0901219d4 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -140,8 +140,8 @@ void crash_save_vmcoreinfo(void);
 void crash_map_reserved_pages(void);
 void crash_unmap_reserved_pages(void);
 void arch_crash_save_vmcoreinfo(void);
-void vmcoreinfo_append_str(const char *fmt, ...)
+__printf(1, 2)
-        __attribute__ ((format (printf, 1, 2)));
+void vmcoreinfo_append_str(const char *fmt, ...);
 unsigned long paddr_vmcoreinfo_note(void);
 #define VMCOREINFO_OSRELEASE(value) \
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 0da38cf7db7b..b16f65390734 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -32,8 +32,8 @@
 extern char modprobe_path[]; /* for sysctl */
 /* modprobe exit status on success, -ve on error.  Return value
 * usually useless though. */
-extern int __request_module(bool wait, const char *name, ...) \
+extern __printf(2, 3)
-        __attribute__((format(printf, 2, 3)));
+int __request_module(bool wait, const char *name, ...);
 #define request_module(mod...) __request_module(true, mod)
 #define request_module_nowait(mod...) __request_module(false, mod)
 #define try_then_request_module(x, mod...) \
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 668729cc0fe9..ad81e1c51487 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -72,8 +72,8 @@ struct kobject {
        unsigned int uevent_suppress:1;
 };
-extern int kobject_set_name(struct kobject *kobj, const char *name, ...)
+extern __printf(2, 3)
-                            __attribute__((format(printf, 2, 3)));
+int kobject_set_name(struct kobject *kobj, const char *name, ...);
 extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
                                  va_list vargs);
@@ -83,15 +83,13 @@ static inline const char *kobject_name(const struct kobject *kobj)
 }
 extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
-extern int __must_check kobject_add(struct kobject *kobj,
+extern __printf(3, 4) __must_check
-                                    struct kobject *parent,
+int kobject_add(struct kobject *kobj, struct kobject *parent,
-                                    const char *fmt, ...)
+                const char *fmt, ...);
-        __attribute__((format(printf, 3, 4)));
+extern __printf(4, 5) __must_check
-extern int __must_check kobject_init_and_add(struct kobject *kobj,
+int kobject_init_and_add(struct kobject *kobj,
-                                             struct kobj_type *ktype,
+                         struct kobj_type *ktype, struct kobject *parent,
-                                             struct kobject *parent,
+                         const char *fmt, ...);
-                                             const char *fmt, ...)
-        __attribute__((format(printf, 4, 5)));
 extern void kobject_del(struct kobject *kobj);
@@ -212,8 +210,8 @@ int kobject_uevent(struct kobject *kobj, enum kobject_action action);
 int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                        char *envp[]);
-int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
+__printf(2, 3)
-        __attribute__((format (printf, 2, 3)));
+int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);
 int kobject_action_type(const char *buf, size_t count,
                        enum kobject_action *type);
@@ -226,7 +224,7 @@ static inline int kobject_uevent_env(struct kobject *kobj,
                                      char *envp[])
 { return 0; }
-static inline __attribute__((format(printf, 2, 3)))
+static inline __printf(2, 3)
 int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
 { return 0; }
diff --git a/include/linux/kthread.h b/include/linux/kthread.h
index 1e923e5e88e8..5cac19b3a266 100644
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -4,11 +4,11 @@
 #include <linux/err.h>
 #include <linux/sched.h>
+__printf(4, 5)
 struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
                                           void *data,
                                           int node,
-                                           const char namefmt[], ...)
+                                           const char namefmt[], ...);
-        __attribute__((format(printf, 4, 5)));
 #define kthread_create(threadfn, data, namefmt, arg...) \
        kthread_create_on_node(threadfn, data, -1, namefmt, ##arg)
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 23fa829bf7a3..cafc09a64fe4 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1256,13 +1256,13 @@ static inline int sata_srst_pmp(struct ata_link *link)
 /*
 * printk helpers
 */
-__attribute__((format (printf, 3, 4)))
+__printf(3, 4)
 int ata_port_printk(const struct ata_port *ap, const char *level,
                    const char *fmt, ...);
-__attribute__((format (printf, 3, 4)))
+__printf(3, 4)
 int ata_link_printk(const struct ata_link *link, const char *level,
                    const char *fmt, ...);
-__attribute__((format (printf, 3, 4)))
+__printf(3, 4)
 int ata_dev_printk(const struct ata_device *dev, const char *level,
                   const char *fmt, ...);
@@ -1304,10 +1304,10 @@ void ata_print_version(const struct device *dev, const char *version);
 /*
 * ata_eh_info helpers
 */
-extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
-extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
 extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
 static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
@@ -1321,8 +1321,8 @@ static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
 /*
 * port description helpers
 */
-extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+void ata_port_desc(struct ata_port *ap, const char *fmt, ...);
 #ifdef CONFIG_PCI
 extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
                               const char *name);
diff --git a/include/linux/lis3lv02d.h b/include/linux/lis3lv02d.h
index d4292c8431e0..f1664c636af0 100644
--- a/include/linux/lis3lv02d.h
+++ b/include/linux/lis3lv02d.h
@@ -113,7 +113,6 @@ struct lis3lv02d_platform_data {
        s8 axis_x;
        s8 axis_y;
        s8 axis_z;
-#define LIS3_USE_REGULATOR_CTRL 0x01
 #define LIS3_USE_BLOCK_READ     0x02
        u16 driver_features;
        int default_rate;
diff --git a/include/linux/llist.h b/include/linux/llist.h
index 7287734e08d1..801b44b07aac 100644
--- a/include/linux/llist.h
+++ b/include/linux/llist.h
@@ -148,7 +148,7 @@ static inline struct llist_node *llist_next(struct llist_node *node)
 * @new:        new entry to be added
 * @head:       the head for your lock-less list
 *
- * Return whether list is empty before adding.
+ * Returns true if the list was empty prior to adding this entry.
 */
 static inline bool llist_add(struct llist_node *new, struct llist_head *head)
 {
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 7525e38c434d..e6b843e16e81 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -80,6 +80,7 @@ extern phys_addr_t __memblock_alloc_base(phys_addr_t size,
                                           phys_addr_t align,
                                           phys_addr_t max_addr);
 extern phys_addr_t memblock_phys_mem_size(void);
+extern phys_addr_t memblock_start_of_DRAM(void);
 extern phys_addr_t memblock_end_of_DRAM(void);
 extern void memblock_enforce_memory_limit(phys_addr_t memory_limit);
 extern int memblock_is_memory(phys_addr_t addr);
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 343bd7661f2a..ac797fa03ef8 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -35,7 +35,8 @@ enum mem_cgroup_page_stat_item {
 extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
                                        struct list_head *dst,
                                        unsigned long *scanned, int order,
-                                        int mode, struct zone *z,
+                                        isolate_mode_t mode,
+                                        struct zone *z,
                                        struct mem_cgroup *mem_cont,
                                        int active, int file);
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 7438071b44aa..3b3e3b8bb706 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1334,7 +1334,8 @@ extern void si_meminfo(struct sysinfo * val);
 extern void si_meminfo_node(struct sysinfo *val, int nid);
 extern int after_bootmem;
-extern void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);
+extern __printf(3, 4)
+void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);
 extern void setup_per_cpu_pageset(void);
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index c93d00a6e95d..3e01a19a91e8 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -304,8 +304,15 @@ struct mm_struct {
        unsigned long hiwater_rss;      /* High-watermark of RSS usage */
        unsigned long hiwater_vm;       /* High-water virtual memory usage */
-        unsigned long total_vm, locked_vm, shared_vm, exec_vm;
+        unsigned long total_vm;         /* Total pages mapped */
-        unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
+        unsigned long locked_vm;        /* Pages that have PG_mlocked set */
+        unsigned long pinned_vm;        /* Refcount permanently increased */
+        unsigned long shared_vm;        /* Shared pages (files) */
+        unsigned long exec_vm;          /* VM_EXEC & ~VM_WRITE */
+        unsigned long stack_vm;         /* VM_GROWSUP/DOWN */
+        unsigned long reserved_vm;      /* VM_RESERVED|VM_IO pages */
+        unsigned long def_flags;
+        unsigned long nr_ptes;          /* Page table pages */
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long start_brk, brk, start_stack;
        unsigned long arg_start, arg_end, env_start, env_end;
@@ -336,9 +343,6 @@ struct mm_struct {
        unsigned int token_priority;
        unsigned int last_interval;
-        /* How many tasks sharing this mm are OOM_DISABLE */
-        atomic_t oom_disable_count;
        unsigned long flags; /* Must use atomic bitops to access the bits */
        struct core_state *core_state; /* coredumping support */
diff --git a/include/linux/mmiotrace.h b/include/linux/mmiotrace.h
index 97491f78b08c..c5d52780d6a0 100644
--- a/include/linux/mmiotrace.h
+++ b/include/linux/mmiotrace.h
@@ -49,8 +49,7 @@ extern void mmiotrace_ioremap(resource_size_t offset, unsigned long size,
 extern void mmiotrace_iounmap(volatile void __iomem *addr);
 /* For anyone to insert markers. Remember trailing newline. */
-extern int mmiotrace_printk(const char *fmt, ...)
+extern __printf(1, 2) int mmiotrace_printk(const char *fmt, ...);
-                                __attribute__ ((format (printf, 1, 2)));
 #else /* !CONFIG_MMIOTRACE: */
 static inline int is_kmmio_active(void)
 {
@@ -71,10 +70,7 @@ static inline void mmiotrace_iounmap(volatile void __iomem *addr)
 {
 }
-static inline int mmiotrace_printk(const char *fmt, ...)
+static inline __printf(1, 2) int mmiotrace_printk(const char *fmt, ...)
-                                __attribute__ ((format (printf, 1, 0)));
-static inline int mmiotrace_printk(const char *fmt, ...)
 {
        return 0;
 }
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index be1ac8d7789b..188cb2ffe8db 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -100,6 +100,7 @@ enum zone_stat_item {
        NR_UNSTABLE_NFS,        /* NFS unstable pages */
        NR_BOUNCE,
        NR_VMSCAN_WRITE,
+        NR_VMSCAN_IMMEDIATE,    /* Prioritise for reclaim when writeback ends */
        NR_WRITEBACK_TEMP,      /* Writeback using temporary buffers */
        NR_ISOLATED_ANON,       /* Temporary isolated pages from anon lru */
        NR_ISOLATED_FILE,       /* Temporary isolated pages from file lru */
@@ -164,6 +165,18 @@ static inline int is_unevictable_lru(enum lru_list l)
 #define LRU_ALL_EVICTABLE (LRU_ALL_FILE | LRU_ALL_ANON)
 #define LRU_ALL      ((1 << NR_LRU_LISTS) - 1)
+/* Isolate inactive pages */
+#define ISOLATE_INACTIVE        ((__force isolate_mode_t)0x1)
+/* Isolate active pages */
+#define ISOLATE_ACTIVE          ((__force isolate_mode_t)0x2)
+/* Isolate clean file */
+#define ISOLATE_CLEAN           ((__force isolate_mode_t)0x4)
+/* Isolate unmapped file */
+#define ISOLATE_UNMAPPED        ((__force isolate_mode_t)0x8)
+/* LRU Isolation modes. */
+typedef unsigned __bitwise__ isolate_mode_t;
 enum zone_watermarks {
        WMARK_MIN,
        WMARK_LOW,
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index df1c836e6948..cbeb5867cff7 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -2622,23 +2622,23 @@ static inline const char *netdev_name(const struct net_device *dev)
 extern int __netdev_printk(const char *level, const struct net_device *dev,
                        struct va_format *vaf);
-extern int netdev_printk(const char *level, const struct net_device *dev,
+extern __printf(3, 4)
-                         const char *format, ...)
+int netdev_printk(const char *level, const struct net_device *dev,
-        __attribute__ ((format (printf, 3, 4)));
+                  const char *format, ...);
-extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_emerg(const struct net_device *dev, const char *format, ...);
-extern int netdev_alert(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_alert(const struct net_device *dev, const char *format, ...);
-extern int netdev_crit(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_crit(const struct net_device *dev, const char *format, ...);
-extern int netdev_err(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_err(const struct net_device *dev, const char *format, ...);
-extern int netdev_warn(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_warn(const struct net_device *dev, const char *format, ...);
-extern int netdev_notice(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_notice(const struct net_device *dev, const char *format, ...);
-extern int netdev_info(const struct net_device *dev, const char *format, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int netdev_info(const struct net_device *dev, const char *format, ...);
 #define MODULE_ALIAS_NETDEV(device) \
        MODULE_ALIAS("netdev-" device)
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 13b7b02e599a..6f9d04a85336 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -40,6 +40,7 @@ enum oom_constraint {
        CONSTRAINT_MEMCG,
 };
+extern void compare_swap_oom_score_adj(int old_val, int new_val);
 extern int test_set_oom_score_adj(int new_val);
 extern unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem,
diff --git a/include/linux/platform_data/leds-renesas-tpu.h b/include/linux/platform_data/leds-renesas-tpu.h
new file mode 100644
index 000000000000..055387086fc1
--- /dev/null
+++ b/include/linux/platform_data/leds-renesas-tpu.h
@@ -0,0 +1,14 @@
+#ifndef __LEDS_RENESAS_TPU_H__
+#define __LEDS_RENESAS_TPU_H__
+struct led_renesas_tpu_config {
+        char *name;
+        unsigned pin_gpio_fn;
+        unsigned pin_gpio;
+        unsigned int channel_offset;
+        unsigned int timer_bit;
+        unsigned int max_brightness;
+        unsigned int refresh_rate;
+};
+#endif /* __LEDS_RENESAS_TPU_H__ */
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 0101d55d9651..f0e22f75143f 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -82,22 +82,22 @@ struct va_format {
 * Dummy printk for disabled debugging statements to use whilst maintaining
 * gcc's format and side-effect checking.
 */
-static inline __attribute__ ((format (printf, 1, 2)))
+static inline __printf(1, 2)
 int no_printk(const char *fmt, ...)
 {
        return 0;
 }
-extern asmlinkage __attribute__ ((format (printf, 1, 2)))
+extern asmlinkage __printf(1, 2)
 void early_printk(const char *fmt, ...);
 extern int printk_needs_cpu(int cpu);
 extern void printk_tick(void);
 #ifdef CONFIG_PRINTK
-asmlinkage __attribute__ ((format (printf, 1, 0)))
+asmlinkage __printf(1, 0)
 int vprintk(const char *fmt, va_list args);
-asmlinkage __attribute__ ((format (printf, 1, 2))) __cold
+asmlinkage __printf(1, 2) __cold
 int printk(const char *fmt, ...);
 /*
@@ -117,12 +117,12 @@ extern int kptr_restrict;
 void log_buf_kexec_setup(void);
 void __init setup_log_buf(int early);
 #else
-static inline __attribute__ ((format (printf, 1, 0)))
+static inline __printf(1, 0)
 int vprintk(const char *s, va_list args)
 {
        return 0;
 }
-static inline __attribute__ ((format (printf, 1, 2))) __cold
+static inline __printf(1, 2) __cold
 int printk(const char *s, ...)
 {
        return 0;
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 26f9e3612e0f..d93f95e6177c 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -31,7 +31,7 @@ static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
 #define quota_error(sb, fmt, args...) \
        __quota_error((sb), __func__, fmt , ## args)
-extern __attribute__((format (printf, 3, 4)))
+extern __printf(3, 4)
 void __quota_error(struct super_block *sb, const char *func,
                   const char *fmt, ...);
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index be720cd2038d..0b69a4684216 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -84,8 +84,7 @@ int seq_putc(struct seq_file *m, char c);
 int seq_puts(struct seq_file *m, const char *s);
 int seq_write(struct seq_file *seq, const void *data, size_t len);
-int seq_printf(struct seq_file *, const char *, ...)
+__printf(2, 3) int seq_printf(struct seq_file *, const char *, ...);
-        __attribute__ ((format (printf,2,3)));
 int seq_path(struct seq_file *, struct path *, char *);
 int seq_dentry(struct seq_file *, struct dentry *, char *);
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
index 790651b4e5ba..a83833a1f7a2 100644
--- a/include/linux/shrinker.h
+++ b/include/linux/shrinker.h
@@ -20,6 +20,7 @@ struct shrink_control {
 * 'nr_to_scan' entries and attempt to free them up.  It should return
 * the number of objects which remain in the cache.  If it returns -1, it means
 * it cannot do any scanning at this time (eg. there is a risk of deadlock).
+ * The callback must not return -1 if nr_to_scan is zero.
 *
 * The 'gfpmask' refers to the allocation we are currently trying to
 * fulfil.
diff --git a/include/linux/spi/l4f00242t03.h b/include/linux/spi/l4f00242t03.h
index aee1dbda4edc..bc8677c8eba9 100644
--- a/include/linux/spi/l4f00242t03.h
+++ b/include/linux/spi/l4f00242t03.h
@@ -24,8 +24,6 @@
 struct l4f00242t03_pdata {
        unsigned int    reset_gpio;
        unsigned int    data_enable_gpio;
-        const char      *io_supply;     /* will be set to 1.8 V */
-        const char      *core_supply;   /* will be set to 2.8 V */
 };
 #endif /* _INCLUDE_LINUX_SPI_L4F00242T03_H_ */
diff --git a/include/linux/string.h b/include/linux/string.h
index a176db2f2c85..e033564f10ba 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -114,6 +114,7 @@ extern int memcmp(const void *,const void *,__kernel_size_t);
 #ifndef __HAVE_ARCH_MEMCHR
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif
+void *memchr_inv(const void *s, int c, size_t n);
 extern char *kstrdup(const char *s, gfp_t gfp);
 extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index c71f84bb62ec..1e22e126d2ac 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -243,15 +243,10 @@ static inline void lru_cache_add_file(struct page *page)
        __lru_cache_add(page, LRU_INACTIVE_FILE);
 }
-/* LRU Isolation modes. */
-#define ISOLATE_INACTIVE 0      /* Isolate inactive pages. */
-#define ISOLATE_ACTIVE 1        /* Isolate active pages. */
-#define ISOLATE_BOTH 2          /* Isolate both active and inactive pages. */
 /* linux/mm/vmscan.c */
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                        gfp_t gfp_mask, nodemask_t *mask);
-extern int __isolate_lru_page(struct page *page, int mode, int file);
+extern int __isolate_lru_page(struct page *page, isolate_mode_t mode, int file);
 extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
                                                  gfp_t gfp_mask, bool noswap);
 extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 1ff0ec2a5e8d..86a24b1166d1 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -844,4 +844,17 @@ asmlinkage long sys_open_by_handle_at(int mountdirfd,
                                      struct file_handle __user *handle,
                                      int flags);
 asmlinkage long sys_setns(int fd, int nstype);
+asmlinkage long sys_process_vm_readv(pid_t pid,
+                                     const struct iovec __user *lvec,
+                                     unsigned long liovcnt,
+                                     const struct iovec __user *rvec,
+                                     unsigned long riovcnt,
+                                     unsigned long flags);
+asmlinkage long sys_process_vm_writev(pid_t pid,
+                                      const struct iovec __user *lvec,
+                                      unsigned long liovcnt,
+                                      const struct iovec __user *rvec,
+                                      unsigned long riovcnt,
+                                      unsigned long flags);
 #endif
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h
index 5cf397ceb726..7dadc3df0c77 100644
--- a/include/linux/trace_seq.h
+++ b/include/linux/trace_seq.h
@@ -29,10 +29,10 @@ trace_seq_init(struct trace_seq *s)
 * Currently only defined when tracing is enabled.
 */
 #ifdef CONFIG_TRACING
-extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+extern __printf(2, 3)
-        __attribute__ ((format (printf, 2, 3)));
+int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
-extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+extern __printf(2, 0)
-        __attribute__ ((format (printf, 2, 0)));
+int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args);
 extern int
 trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary);
 extern int trace_print_seq(struct seq_file *m, struct trace_seq *s);
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index 9332e52ea8c2..687fb11e2010 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -13,6 +13,7 @@ struct vm_area_struct;		/* vma defining user mapping in mm_types.h */
 #define VM_MAP          0x00000004      /* vmap()ed pages */
 #define VM_USERMAP      0x00000008      /* suitable for remap_vmalloc_range */
 #define VM_VPAGES       0x00000010      /* buffer for pages was vmalloc'ed */
+#define VM_UNLIST       0x00000020      /* vm_struct is not listed in vmlist */
 /* bits [20..32] reserved for arch specific ioremap internals */
 /*
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index e727555d4ee9..e86af08293a8 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -77,7 +77,7 @@ struct bt_power {
 #define BT_POWER_FORCE_ACTIVE_OFF 0
 #define BT_POWER_FORCE_ACTIVE_ON  1
-__attribute__((format (printf, 2, 3)))
+__printf(2, 3)
 int bt_printk(const char *level, const char *fmt, ...);
 #define BT_INFO(fmt, arg...)   bt_printk(KERN_INFO, pr_fmt(fmt), ##arg)
diff --git a/include/net/netfilter/nf_log.h b/include/net/netfilter/nf_log.h
index 920997f1aff0..e991bd0a27af 100644
--- a/include/net/netfilter/nf_log.h
+++ b/include/net/netfilter/nf_log.h
@@ -53,12 +53,13 @@ int nf_log_bind_pf(u_int8_t pf, const struct nf_logger *logger);
 void nf_log_unbind_pf(u_int8_t pf);
 /* Calls the registered backend logging function */
+__printf(7, 8)
 void nf_log_packet(u_int8_t pf,
                   unsigned int hooknum,
                   const struct sk_buff *skb,
                   const struct net_device *in,
                   const struct net_device *out,
                   const struct nf_loginfo *li,
-                   const char *fmt, ...) __attribute__ ((format(printf,7,8)));
+                   const char *fmt, ...);
 #endif /* _NF_LOG_H */
diff --git a/include/net/sock.h b/include/net/sock.h
index 5ac682f73d63..c6658bef7f32 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -76,8 +76,8 @@
                                        printk(KERN_DEBUG msg); } while (0)
 #else
 /* Validate arguments and do nothing */
-static inline void __attribute__ ((format (printf, 2, 3)))
+static inline __printf(2, 3)
-SOCK_DEBUG(struct sock *sk, const char *msg, ...)
+void SOCK_DEBUG(struct sock *sk, const char *msg, ...)
 {
 }
 #endif
diff --git a/include/sound/core.h b/include/sound/core.h
index 1fa2407c966f..91d513879a78 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -326,9 +326,9 @@ void release_and_free_resource(struct resource *res);
 /* --- */
 #if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
+__printf(4, 5)
 void __snd_printk(unsigned int level, const char *file, int line,
-                  const char *format, ...)
+                  const char *format, ...);
-     __attribute__ ((format (printf, 4, 5)));
 #else
 #define __snd_printk(level, file, line, format, args...) \
        printk(format, ##args)
diff --git a/include/sound/info.h b/include/sound/info.h
index 4e94cf1ff762..5492cc40dc57 100644
--- a/include/sound/info.h
+++ b/include/sound/info.h
@@ -110,8 +110,8 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer);
 static inline void snd_card_info_read_oss(struct snd_info_buffer *buffer) {}
 #endif
-int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...) \
+__printf(2, 3)
-                                __attribute__ ((format (printf, 2, 3)));
+int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...);
 int snd_info_init(void);
 int snd_info_done(void);
diff --git a/include/sound/seq_kernel.h b/include/sound/seq_kernel.h
index 3d9afb6a8c9c..f352a98ce4f4 100644
--- a/include/sound/seq_kernel.h
+++ b/include/sound/seq_kernel.h
@@ -75,9 +75,9 @@ struct snd_seq_port_callback {
 };
 /* interface for kernel client */
+__printf(3, 4)
 int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
-                                 const char *name_fmt, ...)
+                                 const char *name_fmt, ...);
-        __attribute__ ((format (printf, 3, 4)));
 int snd_seq_delete_kernel_client(int client);
 int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);
 int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event *ev, int atomic, int hop);
diff --git a/include/trace/events/vmscan.h b/include/trace/events/vmscan.h
index 36851f7f13da..edc4b3d25a2d 100644
--- a/include/trace/events/vmscan.h
+++ b/include/trace/events/vmscan.h
@@ -266,7 +266,7 @@ DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,
                unsigned long nr_lumpy_taken,
                unsigned long nr_lumpy_dirty,
                unsigned long nr_lumpy_failed,
-                int isolate_mode),
+                isolate_mode_t isolate_mode),
        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode),
@@ -278,7 +278,7 @@ DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,
                __field(unsigned long, nr_lumpy_taken)
                __field(unsigned long, nr_lumpy_dirty)
                __field(unsigned long, nr_lumpy_failed)
-                __field(int, isolate_mode)
+                __field(isolate_mode_t, isolate_mode)
        ),
        TP_fast_assign(
@@ -312,7 +312,7 @@ DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
                unsigned long nr_lumpy_taken,
                unsigned long nr_lumpy_dirty,
                unsigned long nr_lumpy_failed,
-                int isolate_mode),
+                isolate_mode_t isolate_mode),
        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode)
@@ -327,7 +327,7 @@ DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
                unsigned long nr_lumpy_taken,
                unsigned long nr_lumpy_dirty,
                unsigned long nr_lumpy_failed,
-                int isolate_mode),
+                isolate_mode_t isolate_mode),
        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode)
diff --git a/include/xen/hvc-console.h b/include/xen/hvc-console.h
index 901724dc528d..b62dfef15f61 100644
--- a/include/xen/hvc-console.h
+++ b/include/xen/hvc-console.h
@@ -6,12 +6,12 @@ extern struct console xenboot_console;
 #ifdef CONFIG_HVC_XEN
 void xen_console_resume(void);
 void xen_raw_console_write(const char *str);
-__attribute__((format(printf, 1, 2)))
+__printf(1, 2)
 void xen_raw_printk(const char *fmt, ...);
 #else
 static inline void xen_console_resume(void) { }
 static inline void xen_raw_console_write(const char *str) { }
-static inline __attribute__((format(printf, 1, 2)))
+static inline __printf(1, 2)
 void xen_raw_printk(const char *fmt, ...) { }
 #endif
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index aceeca799fd7..b9f9fb5af0d8 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -156,9 +156,9 @@ int xenbus_scanf(struct xenbus_transaction t,
        __attribute__((format(scanf, 4, 5)));
 /* Single printf and write: returns -errno or 0. */
+__printf(4, 5)
 int xenbus_printf(struct xenbus_transaction t,
-                  const char *dir, const char *node, const char *fmt, ...)
+                  const char *dir, const char *node, const char *fmt, ...);
-        __attribute__((format(printf, 4, 5)));
 /* Generic read function: NULL-terminated triples of name,
 * sprintf-style type string, and pointer. Returns 0 or errno.*/
@@ -200,11 +200,11 @@ int xenbus_watch_path(struct xenbus_device *dev, const char *path,
                      struct xenbus_watch *watch,
                      void (*callback)(struct xenbus_watch *,
                                       const char **, unsigned int));
+__printf(4, 5)
 int xenbus_watch_pathfmt(struct xenbus_device *dev, struct xenbus_watch *watch,
                         void (*callback)(struct xenbus_watch *,
                                          const char **, unsigned int),
-                         const char *pathfmt, ...)
+                         const char *pathfmt, ...);
-        __attribute__ ((format (printf, 4, 5)));
 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state new_state);
 int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn);
@@ -223,9 +223,9 @@ int xenbus_free_evtchn(struct xenbus_device *dev, int port);
 enum xenbus_state xenbus_read_driver_state(const char *path);
-__attribute__((format(printf, 3, 4)))
+__printf(3, 4)
 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...);
-__attribute__((format(printf, 3, 4)))
+__printf(3, 4)
 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...);
 const char *xenbus_strstate(enum xenbus_state state);
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index ed049ea568f4..2e0ecfcc881d 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -449,8 +449,8 @@ static int wq_sleep(struct mqueue_inode_info *info, int sr,
                set_current_state(TASK_INTERRUPTIBLE);
                spin_unlock(&info->lock);
-                time = schedule_hrtimeout_range_clock(timeout,
+                time = schedule_hrtimeout_range_clock(timeout, 0,
-                    HRTIMER_MODE_ABS, 0, CLOCK_REALTIME);
+                        HRTIMER_MODE_ABS, CLOCK_REALTIME);
                while (ewp->state == STATE_PENDING)
                        cpu_relax();
diff --git a/kernel/debug/gdbstub.c b/kernel/debug/gdbstub.c
index 34872482315e..c22d8c28ad84 100644
--- a/kernel/debug/gdbstub.c
+++ b/kernel/debug/gdbstub.c
@@ -217,7 +217,7 @@ void gdbstub_msg_write(const char *s, int len)
                /* Pack in hex chars */
                for (i = 0; i < wcount; i++)
-                        bufptr = pack_hex_byte(bufptr, s[i]);
+                        bufptr = hex_byte_pack(bufptr, s[i]);
                *bufptr = '\0';
                /* Move up */
@@ -249,7 +249,7 @@ char *kgdb_mem2hex(char *mem, char *buf, int count)
        if (err)
                return NULL;
        while (count > 0) {
-                buf = pack_hex_byte(buf, *tmp);
+                buf = hex_byte_pack(buf, *tmp);
                tmp++;
                count--;
        }
@@ -411,14 +411,14 @@ static char *pack_threadid(char *pkt, unsigned char *id)
        limit = id + (BUF_THREAD_ID_SIZE / 2);
        while (id < limit) {
                if (!lzero || *id != 0) {
-                        pkt = pack_hex_byte(pkt, *id);
+                        pkt = hex_byte_pack(pkt, *id);
                        lzero = 0;
                }
                id++;
        }
        if (lzero)
-                pkt = pack_hex_byte(pkt, 0);
+                pkt = hex_byte_pack(pkt, 0);
        return pkt;
 }
@@ -486,7 +486,7 @@ static void gdb_cmd_status(struct kgdb_state *ks)
        dbg_remove_all_break();
        remcom_out_buffer[0] = 'S';
-        pack_hex_byte(&remcom_out_buffer[1], ks->signo);
+        hex_byte_pack(&remcom_out_buffer[1], ks->signo);
 }
 static void gdb_get_regs_helper(struct kgdb_state *ks)
@@ -954,7 +954,7 @@ int gdb_serial_stub(struct kgdb_state *ks)
                /* Reply to host that an exception has occurred */
                ptr = remcom_out_buffer;
                *ptr++ = 'T';
-                ptr = pack_hex_byte(ptr, ks->signo);
+                ptr = hex_byte_pack(ptr, ks->signo);
                ptr += strlen(strcpy(ptr, "thread:"));
                int_to_threadref(thref, shadow_pid(current->pid));
                ptr = pack_threadid(ptr, thref);
diff --git a/kernel/events/core.c b/kernel/events/core.c
index d1a1bee35228..12a0287e0358 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -3544,7 +3544,7 @@ static void perf_mmap_close(struct vm_area_struct *vma)
                struct ring_buffer *rb = event->rb;
                atomic_long_sub((size >> PAGE_SHIFT) + 1, &user->locked_vm);
-                vma->vm_mm->locked_vm -= event->mmap_locked;
+                vma->vm_mm->pinned_vm -= event->mmap_locked;
                rcu_assign_pointer(event->rb, NULL);
                mutex_unlock(&event->mmap_mutex);
@@ -3625,7 +3625,7 @@ static int perf_mmap(struct file *file, struct vm_area_struct *vma)
        lock_limit = rlimit(RLIMIT_MEMLOCK);
        lock_limit >>= PAGE_SHIFT;
-        locked = vma->vm_mm->locked_vm + extra;
+        locked = vma->vm_mm->pinned_vm + extra;
        if ((locked > lock_limit) && perf_paranoid_tracepoint_raw() &&
                !capable(CAP_IPC_LOCK)) {
@@ -3651,7 +3651,7 @@ static int perf_mmap(struct file *file, struct vm_area_struct *vma)
        atomic_long_add(user_extra, &user->locked_vm);
        event->mmap_locked = extra;
        event->mmap_user = get_current_user();
-        vma->vm_mm->locked_vm += event->mmap_locked;
+        vma->vm_mm->pinned_vm += event->mmap_locked;
 unlock:
        if (!ret)
diff --git a/kernel/exit.c b/kernel/exit.c
index 2913b3509d42..d0b7d988f873 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -681,8 +681,6 @@ static void exit_mm(struct task_struct * tsk)
        enter_lazy_tlb(mm, current);
        /* We don't want this task to be frozen prematurely */
        clear_freeze_flag(tsk);
-        if (tsk->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
-                atomic_dec(&mm->oom_disable_count);
        task_unlock(tsk);
        mm_update_next_owner(mm);
        mmput(mm);
diff --git a/kernel/fork.c b/kernel/fork.c
index 8e6b6f4fb272..70d76191afb9 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -501,7 +501,6 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p)
        mm->cached_hole_size = ~0UL;
        mm_init_aio(mm);
        mm_init_owner(mm, p);
-        atomic_set(&mm->oom_disable_count, 0);
        if (likely(!mm_alloc_pgd(mm))) {
                mm->def_flags = 0;
@@ -816,8 +815,6 @@ good_mm:
        /* Initializing for Swap token stuff */
        mm->token_priority = 0;
        mm->last_interval = 0;
-        if (tsk->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
-                atomic_inc(&mm->oom_disable_count);
        tsk->mm = mm;
        tsk->active_mm = mm;
@@ -1391,13 +1388,8 @@ bad_fork_cleanup_io:
 bad_fork_cleanup_namespaces:
        exit_task_namespaces(p);
 bad_fork_cleanup_mm:
-        if (p->mm) {
+        if (p->mm)
-                task_lock(p);
-                if (p->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
-                        atomic_dec(&p->mm->oom_disable_count);
-                task_unlock(p);
                mmput(p->mm);
-        }
 bad_fork_cleanup_signal:
        if (!(clone_flags & CLONE_THREAD))
                free_signal_struct(p->signal);
diff --git a/kernel/printk.c b/kernel/printk.c
index b7da18391c38..1455a0d4eedd 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -532,6 +532,9 @@ static int __init ignore_loglevel_setup(char *str)
 }
 early_param("ignore_loglevel", ignore_loglevel_setup);
+module_param_named(ignore_loglevel, ignore_loglevel, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
+        "print all kernel messages to the console.");
 /*
 * Write out chars from start to end - 1 inclusive
@@ -592,9 +595,6 @@ static size_t log_prefix(const char *p, unsigned int *level, char *special)
                /* multi digit including the level and facility number */
                char *endp = NULL;
-                if (p[1] < '0' && p[1] > '9')
-                        return 0;
                lev = (simple_strtoul(&p[1], &endp, 10) & 7);
                if (endp == NULL || endp[0] != '>')
                        return 0;
@@ -1108,6 +1108,10 @@ static int __init console_suspend_disable(char *str)
        return 1;
 }
 __setup("no_console_suspend", console_suspend_disable);
+module_param_named(console_suspend, console_suspend_enabled,
+                bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
+        " and hibernate operations");
 /**
 * suspend_console - suspend the console subsystem
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index ba5070ce5765..5b0951aa0496 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -41,6 +41,7 @@ struct cpu_stopper {
 };
 static DEFINE_PER_CPU(struct cpu_stopper, cpu_stopper);
+static bool stop_machine_initialized = false;
 static void cpu_stop_init_done(struct cpu_stop_done *done, unsigned int nr_todo)
 {
@@ -386,6 +387,8 @@ static int __init cpu_stop_init(void)
        cpu_stop_cpu_callback(&cpu_stop_cpu_notifier, CPU_ONLINE, bcpu);
        register_cpu_notifier(&cpu_stop_cpu_notifier);
+        stop_machine_initialized = true;
        return 0;
 }
 early_initcall(cpu_stop_init);
@@ -485,6 +488,25 @@ int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus)
                                            .num_threads = num_online_cpus(),
                                            .active_cpus = cpus };
+        if (!stop_machine_initialized) {
+                /*
+                 * Handle the case where stop_machine() is called
+                 * early in boot before stop_machine() has been
+                 * initialized.
+                 */
+                unsigned long flags;
+                int ret;
+                WARN_ON_ONCE(smdata.num_threads != 1);
+                local_irq_save(flags);
+                hard_irq_disable();
+                ret = (*fn)(data);
+                local_irq_restore(flags);
+                return ret;
+        }
        /* Set the initial state and stop all online cpus. */
        set_state(&smdata, STOPMACHINE_PREPARE);
        return stop_cpus(cpu_online_mask, stop_machine_cpu_stop, &smdata);
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index a9a5de07c4f1..47bfa16430d7 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -145,6 +145,10 @@ cond_syscall(sys_io_submit);
 cond_syscall(sys_io_cancel);
 cond_syscall(sys_io_getevents);
 cond_syscall(sys_syslog);
+cond_syscall(sys_process_vm_readv);
+cond_syscall(sys_process_vm_writev);
+cond_syscall(compat_sys_process_vm_readv);
+cond_syscall(compat_sys_process_vm_writev);
 /* arch-specific weak syscall entries */
 cond_syscall(sys_pciconfig_read);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 2fe2bc2a57ea..ae2719643854 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -57,6 +57,7 @@
 #include <linux/pipe_fs_i.h>
 #include <linux/oom.h>
 #include <linux/kmod.h>
+#include <linux/capability.h>
 #include <asm/uaccess.h>
 #include <asm/processor.h>
@@ -134,6 +135,7 @@ static int minolduid;
 static int min_percpu_pagelist_fract = 8;
 static int ngroups_max = NGROUPS_MAX;
+static const int cap_last_cap = CAP_LAST_CAP;
 #ifdef CONFIG_INOTIFY_USER
 #include <linux/inotify.h>
@@ -732,6 +734,13 @@ static struct ctl_table kern_table[] = {
                .mode           = 0444,
                .proc_handler   = proc_dointvec,
        },
+        {
+                .procname       = "cap_last_cap",
+                .data           = (void *)&cap_last_cap,
+                .maxlen         = sizeof(int),
+                .mode           = 0444,
+                .proc_handler   = proc_dointvec,
+        },
 #if defined(CONFIG_LOCKUP_DETECTOR)
        {
                .procname       = "watchdog",
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index d680381b0e9c..1d7bca7f4f52 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -481,6 +481,8 @@ static void watchdog_disable(int cpu)
        }
 }
+/* sysctl functions */
+#ifdef CONFIG_SYSCTL
 static void watchdog_enable_all_cpus(void)
 {
        int cpu;
@@ -510,8 +512,6 @@ static void watchdog_disable_all_cpus(void)
 }
-/* sysctl functions */
-#ifdef CONFIG_SYSCTL
 /*
 * proc handler for /proc/sys/kernel/nmi_watchdog,watchdog_thresh
 */
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index c583a57cddfe..82928f5ea049 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -248,8 +248,9 @@ config DEFAULT_HUNG_TASK_TIMEOUT
          to determine when a task has become non-responsive and should
          be considered hung.
-          It can be adjusted at runtime via the kernel.hung_task_timeout
+          It can be adjusted at runtime via the kernel.hung_task_timeout_secs
-          sysctl or by writing a value to /proc/sys/kernel/hung_task_timeout.
+          sysctl or by writing a value to
+          /proc/sys/kernel/hung_task_timeout_secs.
          A timeout of 0 disables the check.  The default is two minutes.
          Keeping the default should be fine in most cases.
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 2f4412e4d071..0d4a127dd9b3 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -419,7 +419,7 @@ int __bitmap_parse(const char *buf, unsigned int buflen,
 {
        int c, old_c, totaldigits, ndigits, nchunks, nbits;
        u32 chunk;
-        const char __user *ubuf = buf;
+        const char __user __force *ubuf = (const char __user __force *)buf;
        bitmap_zero(maskp, nmaskbits);
@@ -504,7 +504,9 @@ int bitmap_parse_user(const char __user *ubuf,
 {
        if (!access_ok(VERIFY_READ, ubuf, ulen))
                return -EFAULT;
-        return __bitmap_parse((const char *)ubuf, ulen, 1, maskp, nmaskbits);
+        return __bitmap_parse((const char __force *)ubuf,
+                                ulen, 1, maskp, nmaskbits);
 }
 EXPORT_SYMBOL(bitmap_parse_user);
@@ -594,7 +596,7 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
 {
        unsigned a, b;
        int c, old_c, totaldigits;
-        const char __user *ubuf = buf;
+        const char __user __force *ubuf = (const char __user __force *)buf;
        int exp_digit, in_range;
        totaldigits = c = 0;
@@ -694,7 +696,7 @@ int bitmap_parselist_user(const char __user *ubuf,
 {
        if (!access_ok(VERIFY_READ, ubuf, ulen))
                return -EFAULT;
-        return __bitmap_parselist((const char *)ubuf,
+        return __bitmap_parselist((const char __force *)ubuf,
                                        ulen, 1, maskp, nmaskbits);
 }
 EXPORT_SYMBOL(bitmap_parselist_user);
diff --git a/lib/idr.c b/lib/idr.c
index 5acf9bb10968..bbf211aea4eb 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -767,8 +767,8 @@ EXPORT_SYMBOL(ida_pre_get);
 * @starting_id: id to start search at
 * @p_id:       pointer to the allocated handle
 *
- * Allocate new ID above or equal to @ida.  It should be called with
+ * Allocate new ID above or equal to @starting_id.  It should be called
- * any required locks.
+ * with any required locks.
 *
 * If memory is required, it will return %-EAGAIN, you should unlock
 * and go back to the ida_pre_get() call.  If the ida is full, it will
diff --git a/lib/kstrtox.c b/lib/kstrtox.c
index 5e066759f551..7a94c8f14e29 100644
--- a/lib/kstrtox.c
+++ b/lib/kstrtox.c
@@ -18,26 +18,40 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <asm/uaccess.h>
+#include "kstrtox.h"
-static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
+const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
 {
-        unsigned long long acc;
+        if (*base == 0) {
-        int ok;
-        if (base == 0) {
                if (s[0] == '0') {
                        if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
-                                base = 16;
+                                *base = 16;
                        else
-                                base = 8;
+                                *base = 8;
                } else
-                        base = 10;
+                        *base = 10;
        }
-        if (base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
+        if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
                s += 2;
+        return s;
+}
-        acc = 0;
+/*
-        ok = 0;
+ * Convert non-negative integer string representation in explicitly given radix
+ * to an integer.
+ * Return number of characters consumed maybe or-ed with overflow bit.
+ * If overflow occurs, result integer (incorrect) is still returned.
+ *
+ * Don't you dare use this function.
+ */
+unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *res)
+{
+        unsigned int rv;
+        int overflow;
+        *res = 0;
+        rv = 0;
+        overflow = 0;
        while (*s) {
                unsigned int val;
@@ -45,23 +59,40 @@ static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
                        val = *s - '0';
                else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
                        val = _tolower(*s) - 'a' + 10;
-                else if (*s == '\n' && *(s + 1) == '\0')
-                        break;
                else
-                        return -EINVAL;
+                        break;
                if (val >= base)
-                        return -EINVAL;
+                        break;
-                if (acc > div_u64(ULLONG_MAX - val, base))
+                if (*res > div_u64(ULLONG_MAX - val, base))
-                        return -ERANGE;
+                        overflow = 1;
-                acc = acc * base + val;
+                *res = *res * base + val;
-                ok = 1;
+                rv++;
                s++;
        }
-        if (!ok)
+        if (overflow)
+                rv |= KSTRTOX_OVERFLOW;
+        return rv;
+}
+static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
+{
+        unsigned long long _res;
+        unsigned int rv;
+        s = _parse_integer_fixup_radix(s, &base);
+        rv = _parse_integer(s, base, &_res);
+        if (rv & KSTRTOX_OVERFLOW)
+                return -ERANGE;
+        rv &= ~KSTRTOX_OVERFLOW;
+        if (rv == 0)
+                return -EINVAL;
+        s += rv;
+        if (*s == '\n')
+                s++;
+        if (*s)
                return -EINVAL;
-        *res = acc;
+        *res = _res;
        return 0;
 }
diff --git a/lib/kstrtox.h b/lib/kstrtox.h
new file mode 100644
index 000000000000..f13eeeaf441d
--- /dev/null
+++ b/lib/kstrtox.h
@@ -0,0 +1,8 @@
+#ifndef _LIB_KSTRTOX_H
+#define _LIB_KSTRTOX_H
+#define KSTRTOX_OVERFLOW        (1U << 31)
+const char *_parse_integer_fixup_radix(const char *s, unsigned int *base);
+unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *res);
+#endif
diff --git a/lib/percpu_counter.c b/lib/percpu_counter.c
index f087105ed914..f8a3f1a829b8 100644
--- a/lib/percpu_counter.c
+++ b/lib/percpu_counter.c
@@ -10,8 +10,10 @@
 #include <linux/module.h>
 #include <linux/debugobjects.h>
+#ifdef CONFIG_HOTPLUG_CPU
 static LIST_HEAD(percpu_counters);
 static DEFINE_MUTEX(percpu_counters_lock);
+#endif
 #ifdef CONFIG_DEBUG_OBJECTS_PERCPU_COUNTER
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index a2f9da59c197..d9df7454519c 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -576,7 +576,6 @@ int radix_tree_tag_get(struct radix_tree_root *root,
 {
        unsigned int height, shift;
        struct radix_tree_node *node;
-        int saw_unset_tag = 0;
        /* check the root's tag bit */
        if (!root_tag_get(root, tag))
@@ -603,15 +602,10 @@ int radix_tree_tag_get(struct radix_tree_root *root,
                        return 0;
                offset = (index >> shift) & RADIX_TREE_MAP_MASK;
-                /*
-                 * This is just a debug check.  Later, we can bale as soon as
-                 * we see an unset tag.
-                 */
                if (!tag_get(node, tag, offset))
-                        saw_unset_tag = 1;
+                        return 0;
                if (height == 1)
-                        return !!tag_get(node, tag, offset);
+                        return 1;
                node = rcu_dereference_raw(node->slots[offset]);
                shift -= RADIX_TREE_MAP_SHIFT;
                height--;
diff --git a/lib/spinlock_debug.c b/lib/spinlock_debug.c
index 4755b98b6dfb..5f3eacdd6178 100644
--- a/lib/spinlock_debug.c
+++ b/lib/spinlock_debug.c
@@ -49,13 +49,10 @@ void __rwlock_init(rwlock_t *lock, const char *name,
 EXPORT_SYMBOL(__rwlock_init);
-static void spin_bug(raw_spinlock_t *lock, const char *msg)
+static void spin_dump(raw_spinlock_t *lock, const char *msg)
 {
        struct task_struct *owner = NULL;
-        if (!debug_locks_off())
-                return;
        if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT)
                owner = lock->owner;
        printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
@@ -70,6 +67,14 @@ static void spin_bug(raw_spinlock_t *lock, const char *msg)
        dump_stack();
 }
+static void spin_bug(raw_spinlock_t *lock, const char *msg)
+{
+        if (!debug_locks_off())
+                return;
+        spin_dump(lock, msg);
+}
 #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)
 static inline void
@@ -113,11 +118,7 @@ static void __spin_lock_debug(raw_spinlock_t *lock)
                /* lockup suspected: */
                if (print_once) {
                        print_once = 0;
-                        printk(KERN_EMERG "BUG: spinlock lockup on CPU#%d, "
+                        spin_dump(lock, "lockup");
-                                        "%s/%d, %p\n",
-                                raw_smp_processor_id(), current->comm,
-                                task_pid_nr(current), lock);
-                        dump_stack();
 #ifdef CONFIG_SMP
                        trigger_all_cpu_backtrace();
 #endif
diff --git a/lib/string.c b/lib/string.c
index 01fad9b203e1..dc4a86341f91 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -360,7 +360,6 @@ char *strim(char *s)
        size_t size;
        char *end;
-        s = skip_spaces(s);
        size = strlen(s);
        if (!size)
                return s;
@@ -370,7 +369,7 @@ char *strim(char *s)
                end--;
        *(end + 1) = '\0';
-        return s;
+        return skip_spaces(s);
 }
 EXPORT_SYMBOL(strim);
@@ -756,3 +755,57 @@ void *memchr(const void *s, int c, size_t n)
 }
 EXPORT_SYMBOL(memchr);
 #endif
+static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
+{
+        while (bytes) {
+                if (*start != value)
+                        return (void *)start;
+                start++;
+                bytes--;
+        }
+        return NULL;
+}
+/**
+ * memchr_inv - Find an unmatching character in an area of memory.
+ * @start: The memory area
+ * @c: Find a character other than c
+ * @bytes: The size of the area.
+ *
+ * returns the address of the first character other than @c, or %NULL
+ * if the whole buffer contains just @c.
+ */
+void *memchr_inv(const void *start, int c, size_t bytes)
+{
+        u8 value = c;
+        u64 value64;
+        unsigned int words, prefix;
+        if (bytes <= 16)
+                return check_bytes8(start, value, bytes);
+        value64 = value | value << 8 | value << 16 | value << 24;
+        value64 = (value64 & 0xffffffff) | value64 << 32;
+        prefix = 8 - ((unsigned long)start) % 8;
+        if (prefix) {
+                u8 *r = check_bytes8(start, value, prefix);
+                if (r)
+                        return r;
+                start += prefix;
+                bytes -= prefix;
+        }
+        words = bytes / 8;
+        while (words) {
+                if (*(u64 *)start != value64)
+                        return check_bytes8(start, value, 8);
+                start += 8;
+                words--;
+        }
+        return check_bytes8(start, value, bytes % 8);
+}
+EXPORT_SYMBOL(memchr_inv);
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index d7222a9c8267..993599e66e5a 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -31,17 +31,7 @@
 #include <asm/div64.h>
 #include <asm/sections.h>       /* for dereference_function_descriptor() */
-static unsigned int simple_guess_base(const char *cp)
+#include "kstrtox.h"
-{
-        if (cp[0] == '0') {
-                if (_tolower(cp[1]) == 'x' && isxdigit(cp[2]))
-                        return 16;
-                else
-                        return 8;
-        } else {
-                return 10;
-        }
-}
 /**
 * simple_strtoull - convert a string to an unsigned long long
@@ -51,23 +41,14 @@ static unsigned int simple_guess_base(const char *cp)
 */
 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
 {
-        unsigned long long result = 0;
+        unsigned long long result;
+        unsigned int rv;
-        if (!base)
+        cp = _parse_integer_fixup_radix(cp, &base);
-                base = simple_guess_base(cp);
+        rv = _parse_integer(cp, base, &result);
+        /* FIXME */
+        cp += (rv & ~KSTRTOX_OVERFLOW);
-        if (base == 16 && cp[0] == '0' && _tolower(cp[1]) == 'x')
-                cp += 2;
-        while (isxdigit(*cp)) {
-                unsigned int value;
-                value = isdigit(*cp) ? *cp - '0' : _tolower(*cp) - 'a' + 10;
-                if (value >= base)
-                        break;
-                result = result * base + value;
-                cp++;
-        }
        if (endp)
                *endp = (char *)cp;
@@ -566,7 +547,7 @@ char *mac_address_string(char *buf, char *end, u8 *addr,
        }
        for (i = 0; i < 6; i++) {
-                p = pack_hex_byte(p, addr[i]);
+                p = hex_byte_pack(p, addr[i]);
                if (fmt[0] == 'M' && i != 5)
                        *p++ = separator;
        }
@@ -686,13 +667,13 @@ char *ip6_compressed_string(char *p, const char *addr)
                lo = word & 0xff;
                if (hi) {
                        if (hi > 0x0f)
-                                p = pack_hex_byte(p, hi);
+                                p = hex_byte_pack(p, hi);
                        else
                                *p++ = hex_asc_lo(hi);
-                        p = pack_hex_byte(p, lo);
+                        p = hex_byte_pack(p, lo);
                }
                else if (lo > 0x0f)
-                        p = pack_hex_byte(p, lo);
+                        p = hex_byte_pack(p, lo);
                else
                        *p++ = hex_asc_lo(lo);
                needcolon = true;
@@ -714,8 +695,8 @@ char *ip6_string(char *p, const char *addr, const char *fmt)
        int i;
        for (i = 0; i < 8; i++) {
-                p = pack_hex_byte(p, *addr++);
+                p = hex_byte_pack(p, *addr++);
-                p = pack_hex_byte(p, *addr++);
+                p = hex_byte_pack(p, *addr++);
                if (fmt[0] == 'I' && i != 7)
                        *p++ = ':';
        }
@@ -773,7 +754,7 @@ char *uuid_string(char *buf, char *end, const u8 *addr,
        }
        for (i = 0; i < 16; i++) {
-                p = pack_hex_byte(p, addr[index[i]]);
+                p = hex_byte_pack(p, addr[index[i]]);
                switch (i) {
                case 3:
                case 5:
diff --git a/mm/Kconfig b/mm/Kconfig
index f2f1ca19ed53..011b110365c8 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -131,6 +131,9 @@ config SPARSEMEM_VMEMMAP
 config HAVE_MEMBLOCK
        boolean
+config NO_BOOTMEM
+        boolean
 # eventually, we can have this option just 'select SPARSEMEM'
 config MEMORY_HOTPLUG
        bool "Allow for memory hot-add"
diff --git a/mm/Makefile b/mm/Makefile
index 836e4163c1bf..50ec00ef2a0e 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -5,7 +5,8 @@
 mmu-y                   := nommu.o
 mmu-$(CONFIG_MMU)       := fremap.o highmem.o madvise.o memory.o mincore.o \
                           mlock.o mmap.o mprotect.o mremap.o msync.o rmap.o \
-                           vmalloc.o pagewalk.o pgtable-generic.o
+                           vmalloc.o pagewalk.o pgtable-generic.o \
+                           process_vm_access.o
 obj-y                   := filemap.o mempool.o oom_kill.o fadvise.o \
                           maccess.o page_alloc.o page-writeback.o \
diff --git a/mm/backing-dev.c b/mm/backing-dev.c
index a87da524a4a0..7520ef0bfd47 100644
--- a/mm/backing-dev.c
+++ b/mm/backing-dev.c
@@ -404,9 +404,8 @@ static int bdi_forker_thread(void *ptr)
                /*
                 * In the following loop we are going to check whether we have
                 * some work to do without any synchronization with tasks
-                 * waking us up to do work for them. So we have to set task
+                 * waking us up to do work for them. Set the task state here
-                 * state already here so that we don't miss wakeups coming
+                 * so that we don't miss wakeups after verifying conditions.
-                 * after we verify some condition.
                 */
                set_current_state(TASK_INTERRUPTIBLE);
diff --git a/mm/compaction.c b/mm/compaction.c
index 6cc604bd5649..899d95638586 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -35,10 +35,6 @@ struct compact_control {
        unsigned long migrate_pfn;      /* isolate_migratepages search base */
        bool sync;                      /* Synchronous migration */
-        /* Account for isolated anon and file pages */
-        unsigned long nr_anon;
-        unsigned long nr_file;
        unsigned int order;             /* order a direct compactor needs */
        int migratetype;                /* MOVABLE, RECLAIMABLE etc */
        struct zone *zone;
@@ -223,17 +219,13 @@ static void isolate_freepages(struct zone *zone,
 static void acct_isolated(struct zone *zone, struct compact_control *cc)
 {
        struct page *page;
-        unsigned int count[NR_LRU_LISTS] = { 0, };
+        unsigned int count[2] = { 0, };
-        list_for_each_entry(page, &cc->migratepages, lru) {
+        list_for_each_entry(page, &cc->migratepages, lru)
-                int lru = page_lru_base_type(page);
+                count[!!page_is_file_cache(page)]++;
-                count[lru]++;
-        }
-        cc->nr_anon = count[LRU_ACTIVE_ANON] + count[LRU_INACTIVE_ANON];
+        __mod_zone_page_state(zone, NR_ISOLATED_ANON, count[0]);
-        cc->nr_file = count[LRU_ACTIVE_FILE] + count[LRU_INACTIVE_FILE];
+        __mod_zone_page_state(zone, NR_ISOLATED_FILE, count[1]);
-        __mod_zone_page_state(zone, NR_ISOLATED_ANON, cc->nr_anon);
-        __mod_zone_page_state(zone, NR_ISOLATED_FILE, cc->nr_file);
 }
 /* Similar to reclaim, but different enough that they don't share logic */
@@ -269,6 +261,7 @@ static isolate_migrate_t isolate_migratepages(struct zone *zone,
        unsigned long last_pageblock_nr = 0, pageblock_nr;
        unsigned long nr_scanned = 0, nr_isolated = 0;
        struct list_head *migratelist = &cc->migratepages;
+        isolate_mode_t mode = ISOLATE_ACTIVE|ISOLATE_INACTIVE;
        /* Do not scan outside zone boundaries */
        low_pfn = max(cc->migrate_pfn, zone->zone_start_pfn);
@@ -356,8 +349,11 @@ static isolate_migrate_t isolate_migratepages(struct zone *zone,
                        continue;
                }
+                if (!cc->sync)
+                        mode |= ISOLATE_CLEAN;
                /* Try isolate the page */
-                if (__isolate_lru_page(page, ISOLATE_BOTH, 0) != 0)
+                if (__isolate_lru_page(page, mode, 0) != 0)
                        continue;
                VM_BUG_ON(PageTransCompound(page));
@@ -586,7 +582,7 @@ out:
        return ret;
 }
-unsigned long compact_zone_order(struct zone *zone,
+static unsigned long compact_zone_order(struct zone *zone,
                                 int order, gfp_t gfp_mask,
                                 bool sync)
 {
diff --git a/mm/debug-pagealloc.c b/mm/debug-pagealloc.c
index a1e3324de2b5..7cea557407f4 100644
--- a/mm/debug-pagealloc.c
+++ b/mm/debug-pagealloc.c
@@ -1,7 +1,10 @@
 #include <linux/kernel.h>
+#include <linux/string.h>
 #include <linux/mm.h>
+#include <linux/highmem.h>
 #include <linux/page-debug-flags.h>
 #include <linux/poison.h>
+#include <linux/ratelimit.h>
 static inline void set_page_poison(struct page *page)
 {
@@ -18,28 +21,13 @@ static inline bool page_poison(struct page *page)
        return test_bit(PAGE_DEBUG_FLAG_POISON, &page->debug_flags);
 }
-static void poison_highpage(struct page *page)
-{
-        /*
-         * Page poisoning for highmem pages is not implemented.
-         *
-         * This can be called from interrupt contexts.
-         * So we need to create a new kmap_atomic slot for this
-         * application and it will need interrupt protection.
-         */
-}
 static void poison_page(struct page *page)
 {
-        void *addr;
+        void *addr = kmap_atomic(page);
-        if (PageHighMem(page)) {
-                poison_highpage(page);
-                return;
-        }
        set_page_poison(page);
-        addr = page_address(page);
        memset(addr, PAGE_POISON, PAGE_SIZE);
+        kunmap_atomic(addr);
 }
 static void poison_pages(struct page *page, int n)
@@ -59,14 +47,12 @@ static bool single_bit_flip(unsigned char a, unsigned char b)
 static void check_poison_mem(unsigned char *mem, size_t bytes)
 {
+        static DEFINE_RATELIMIT_STATE(ratelimit, 5 * HZ, 10);
        unsigned char *start;
        unsigned char *end;
-        for (start = mem; start < mem + bytes; start++) {
+        start = memchr_inv(mem, PAGE_POISON, bytes);
-                if (*start != PAGE_POISON)
+        if (!start)
-                        break;
-        }
-        if (start == mem + bytes)
                return;
        for (end = mem + bytes - 1; end > start; end--) {
@@ -74,7 +60,7 @@ static void check_poison_mem(unsigned char *mem, size_t bytes)
                        break;
        }
-        if (!printk_ratelimit())
+        if (!__ratelimit(&ratelimit))
                return;
        else if (start == end && single_bit_flip(*start, PAGE_POISON))
                printk(KERN_ERR "pagealloc: single bit error\n");
@@ -86,27 +72,17 @@ static void check_poison_mem(unsigned char *mem, size_t bytes)
        dump_stack();
 }
-static void unpoison_highpage(struct page *page)
-{
-        /*
-         * See comment in poison_highpage().
-         * Highmem pages should not be poisoned for now
-         */
-        BUG_ON(page_poison(page));
-}
 static void unpoison_page(struct page *page)
 {
-        if (PageHighMem(page)) {
+        void *addr;
-                unpoison_highpage(page);
+        if (!page_poison(page))
                return;
-        }
-        if (page_poison(page)) {
-                void *addr = page_address(page);
-                check_poison_mem(addr, PAGE_SIZE);
+        addr = kmap_atomic(page);
-                clear_page_poison(page);
+        check_poison_mem(addr, PAGE_SIZE);
-        }
+        clear_page_poison(page);
+        kunmap_atomic(addr);
 }
 static void unpoison_pages(struct page *page, int n)
diff --git a/mm/highmem.c b/mm/highmem.c
index 5ef672c07f75..e159a7b1cc22 100644
--- a/mm/highmem.c
+++ b/mm/highmem.c
@@ -250,7 +250,7 @@ void *kmap_high_get(struct page *page)
 #endif
 /**
- * kunmap_high - map a highmem page into memory
+ * kunmap_high - unmap a highmem page into memory
 * @page: &struct page to unmap
 *
 * If ARCH_NEEDS_KMAP_HIGH_GET is not defined then this may be called
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index e2d1587be269..860ec211ddd6 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -89,7 +89,8 @@ struct khugepaged_scan {
        struct list_head mm_head;
        struct mm_slot *mm_slot;
        unsigned long address;
-} khugepaged_scan = {
+};
+static struct khugepaged_scan khugepaged_scan = {
        .mm_head = LIST_HEAD_INIT(khugepaged_scan.mm_head),
 };
@@ -829,7 +830,7 @@ static int do_huge_pmd_wp_page_fallback(struct mm_struct *mm,
        for (i = 0; i < HPAGE_PMD_NR; i++) {
                copy_user_highpage(pages[i], page + i,
-                                   haddr + PAGE_SHIFT*i, vma);
+                                   haddr + PAGE_SIZE * i, vma);
                __SetPageUptodate(pages[i]);
                cond_resched();
        }
@@ -1052,6 +1053,51 @@ int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
        return ret;
 }
+int move_huge_pmd(struct vm_area_struct *vma, struct vm_area_struct *new_vma,
+                  unsigned long old_addr,
+                  unsigned long new_addr, unsigned long old_end,
+                  pmd_t *old_pmd, pmd_t *new_pmd)
+{
+        int ret = 0;
+        pmd_t pmd;
+        struct mm_struct *mm = vma->vm_mm;
+        if ((old_addr & ~HPAGE_PMD_MASK) ||
+            (new_addr & ~HPAGE_PMD_MASK) ||
+            old_end - old_addr < HPAGE_PMD_SIZE ||
+            (new_vma->vm_flags & VM_NOHUGEPAGE))
+                goto out;
+        /*
+         * The destination pmd shouldn't be established, free_pgtables()
+         * should have release it.
+         */
+        if (WARN_ON(!pmd_none(*new_pmd))) {
+                VM_BUG_ON(pmd_trans_huge(*new_pmd));
+                goto out;
+        }
+        spin_lock(&mm->page_table_lock);
+        if (likely(pmd_trans_huge(*old_pmd))) {
+                if (pmd_trans_splitting(*old_pmd)) {
+                        spin_unlock(&mm->page_table_lock);
+                        wait_split_huge_page(vma->anon_vma, old_pmd);
+                        ret = -1;
+                } else {
+                        pmd = pmdp_get_and_clear(mm, old_addr, old_pmd);
+                        VM_BUG_ON(!pmd_none(*new_pmd));
+                        set_pmd_at(mm, new_addr, new_pmd, pmd);
+                        spin_unlock(&mm->page_table_lock);
+                        ret = 1;
+                }
+        } else {
+                spin_unlock(&mm->page_table_lock);
+        }
+out:
+        return ret;
+}
 int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                unsigned long addr, pgprot_t newprot)
 {
@@ -1906,7 +1952,7 @@ static void collapse_huge_page(struct mm_struct *mm,
        BUG_ON(!pmd_none(*pmd));
        page_add_new_anon_rmap(new_page, vma, address);
        set_pmd_at(mm, address, pmd, _pmd);
-        update_mmu_cache(vma, address, entry);
+        update_mmu_cache(vma, address, _pmd);
        prepare_pmd_huge_pte(pgtable, mm);
        mm->nr_ptes--;
        spin_unlock(&mm->page_table_lock);
@@ -2024,6 +2070,8 @@ static void collect_mm_slot(struct mm_slot *mm_slot)
 static unsigned int khugepaged_scan_mm_slot(unsigned int pages,
                                            struct page **hpage)
+        __releases(&khugepaged_mm_lock)
+        __acquires(&khugepaged_mm_lock)
 {
        struct mm_slot *mm_slot;
        struct mm_struct *mm;
diff --git a/mm/ksm.c b/mm/ksm.c
index 9a68b0cf0a1c..310544a379ae 100644
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -1905,7 +1905,8 @@ static ssize_t run_store(struct kobject *kobj, struct kobj_attribute *attr,
                        oom_score_adj = test_set_oom_score_adj(OOM_SCORE_ADJ_MAX);
                        err = unmerge_and_remove_all_rmap_items();
-                        test_set_oom_score_adj(oom_score_adj);
+                        compare_swap_oom_score_adj(OOM_SCORE_ADJ_MAX,
+                                                                oom_score_adj);
                        if (err) {
                                ksm_run = KSM_RUN_STOP;
                                count = err;
diff --git a/mm/memblock.c b/mm/memblock.c
index ccbf97339592..84bec4969ed5 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -58,7 +58,8 @@ static unsigned long __init_memblock memblock_addrs_overlap(phys_addr_t base1, p
        return ((base1 < (base2 + size2)) && (base2 < (base1 + size1)));
 }
-long __init_memblock memblock_overlaps_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
+static long __init_memblock memblock_overlaps_region(struct memblock_type *type,
+                                        phys_addr_t base, phys_addr_t size)
 {
        unsigned long i;
@@ -267,7 +268,7 @@ static int __init_memblock memblock_double_array(struct memblock_type *type)
        return 0;
 }
-extern int __init_memblock __weak memblock_memory_can_coalesce(phys_addr_t addr1, phys_addr_t size1,
+int __init_memblock __weak memblock_memory_can_coalesce(phys_addr_t addr1, phys_addr_t size1,
                                          phys_addr_t addr2, phys_addr_t size2)
 {
        return 1;
@@ -626,6 +627,12 @@ phys_addr_t __init memblock_phys_mem_size(void)
        return memblock.memory_size;
 }
+/* lowest address */
+phys_addr_t __init_memblock memblock_start_of_DRAM(void)
+{
+        return memblock.memory.regions[0].base;
+}
 phys_addr_t __init_memblock memblock_end_of_DRAM(void)
 {
        int idx = memblock.memory.cnt - 1;
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 3508777837c7..2d5755544afe 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -1185,7 +1185,8 @@ mem_cgroup_get_reclaim_stat_from_page(struct page *page)
 unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
                                        struct list_head *dst,
                                        unsigned long *scanned, int order,
-                                        int mode, struct zone *z,
+                                        isolate_mode_t mode,
+                                        struct zone *z,
                                        struct mem_cgroup *mem_cont,
                                        int active, int file)
 {
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 2b43ba051ac9..edc388db730a 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -1310,7 +1310,7 @@ int unpoison_memory(unsigned long pfn)
                 * to the end.
                 */
                if (PageHuge(page)) {
-                        pr_debug("MCE: Memory failure is now running on free hugepage %#lx\n", pfn);
+                        pr_info("MCE: Memory failure is now running on free hugepage %#lx\n", pfn);
                        return 0;
                }
                if (TestClearPageHWPoison(p))
@@ -1419,7 +1419,7 @@ static int soft_offline_huge_page(struct page *page, int flags)
        if (PageHWPoison(hpage)) {
                put_page(hpage);
-                pr_debug("soft offline: %#lx hugepage already poisoned\n", pfn);
+                pr_info("soft offline: %#lx hugepage already poisoned\n", pfn);
                return -EBUSY;
        }
@@ -1433,8 +1433,8 @@ static int soft_offline_huge_page(struct page *page, int flags)
                list_for_each_entry_safe(page1, page2, &pagelist, lru)
                        put_page(page1);
-                pr_debug("soft offline: %#lx: migration failed %d, type %lx\n",
+                pr_info("soft offline: %#lx: migration failed %d, type %lx\n",
-                         pfn, ret, page->flags);
+                        pfn, ret, page->flags);
                if (ret > 0)
                        ret = -EIO;
                return ret;
@@ -1505,7 +1505,7 @@ int soft_offline_page(struct page *page, int flags)
        }
        if (!PageLRU(page)) {
                pr_info("soft_offline: %#lx: unknown non LRU page type %lx\n",
-                                pfn, page->flags);
+                        pfn, page->flags);
                return -EIO;
        }
@@ -1566,7 +1566,7 @@ int soft_offline_page(struct page *page, int flags)
                }
        } else {
                pr_info("soft offline: %#lx: isolation failed: %d, page count %d, type %lx\n",
-                                pfn, ret, page_count(page), page->flags);
+                        pfn, ret, page_count(page), page->flags);
        }
        if (ret)
                return ret;
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 9c51f9f58cac..cd237f478304 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -111,7 +111,7 @@ enum zone_type policy_zone = 0;
 /*
 * run-time system-wide default policy => local allocation
 */
-struct mempolicy default_policy = {
+static struct mempolicy default_policy = {
        .refcnt = ATOMIC_INIT(1), /* never free it */
        .mode = MPOL_PREFERRED,
        .flags = MPOL_F_LOCAL,
diff --git a/mm/migrate.c b/mm/migrate.c
index 14d0a6a632f6..33358f878111 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -621,38 +621,18 @@ static int move_to_new_page(struct page *newpage, struct page *page,
        return rc;
 }
-/*
+static int __unmap_and_move(struct page *page, struct page *newpage,
- * Obtain the lock on page, remove all ptes and migrate the page
+                                int force, bool offlining, bool sync)
- * to the newly allocated page in newpage.
- */
-static int unmap_and_move(new_page_t get_new_page, unsigned long private,
-                        struct page *page, int force, bool offlining, bool sync)
 {
-        int rc = 0;
+        int rc = -EAGAIN;
-        int *result = NULL;
-        struct page *newpage = get_new_page(page, private, &result);
        int remap_swapcache = 1;
        int charge = 0;
        struct mem_cgroup *mem;
        struct anon_vma *anon_vma = NULL;
-        if (!newpage)
-                return -ENOMEM;
-        if (page_count(page) == 1) {
-                /* page was freed from under us. So we are done. */
-                goto move_newpage;
-        }
-        if (unlikely(PageTransHuge(page)))
-                if (unlikely(split_huge_page(page)))
-                        goto move_newpage;
-        /* prepare cgroup just returns 0 or -ENOMEM */
-        rc = -EAGAIN;
        if (!trylock_page(page)) {
                if (!force || !sync)
-                        goto move_newpage;
+                        goto out;
                /*
                 * It's not safe for direct compaction to call lock_page.
@@ -668,7 +648,7 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
                 * altogether.
                 */
                if (current->flags & PF_MEMALLOC)
-                        goto move_newpage;
+                        goto out;
                lock_page(page);
        }
@@ -785,27 +765,52 @@ uncharge:
                mem_cgroup_end_migration(mem, page, newpage, rc == 0);
 unlock:
        unlock_page(page);
+out:
+        return rc;
+}
-move_newpage:
+/*
+ * Obtain the lock on page, remove all ptes and migrate the page
+ * to the newly allocated page in newpage.
+ */
+static int unmap_and_move(new_page_t get_new_page, unsigned long private,
+                        struct page *page, int force, bool offlining, bool sync)
+{
+        int rc = 0;
+        int *result = NULL;
+        struct page *newpage = get_new_page(page, private, &result);
+        if (!newpage)
+                return -ENOMEM;
+        if (page_count(page) == 1) {
+                /* page was freed from under us. So we are done. */
+                goto out;
+        }
+        if (unlikely(PageTransHuge(page)))
+                if (unlikely(split_huge_page(page)))
+                        goto out;
+        rc = __unmap_and_move(page, newpage, force, offlining, sync);
+out:
        if (rc != -EAGAIN) {
-                /*
+                /*
-                 * A page that has been migrated has all references
+                 * A page that has been migrated has all references
-                 * removed and will be freed. A page that has not been
+                 * removed and will be freed. A page that has not been
-                 * migrated will have kepts its references and be
+                 * migrated will have kepts its references and be
-                 * restored.
+                 * restored.
-                 */
+                 */
-                list_del(&page->lru);
+                list_del(&page->lru);
                dec_zone_page_state(page, NR_ISOLATED_ANON +
                                page_is_file_cache(page));
                putback_lru_page(page);
        }
        /*
         * Move the new page to the LRU. If migration was not successful
         * then this will free the page.
         */
        putback_lru_page(newpage);
        if (result) {
                if (rc)
                        *result = rc;
diff --git a/mm/mlock.c b/mm/mlock.c
index 048260c4e02e..bd34b3a10852 100644
--- a/mm/mlock.c
+++ b/mm/mlock.c
@@ -110,7 +110,15 @@ void munlock_vma_page(struct page *page)
        if (TestClearPageMlocked(page)) {
                dec_zone_page_state(page, NR_MLOCK);
                if (!isolate_lru_page(page)) {
-                        int ret = try_to_munlock(page);
+                        int ret = SWAP_AGAIN;
+                        /*
+                         * Optimization: if the page was mapped just once,
+                         * that's our mapping and we don't need to check all the
+                         * other vmas.
+                         */
+                        if (page_mapcount(page) > 1)
+                                ret = try_to_munlock(page);
                        /*
                         * did try_to_unlock() succeed or punt?
                         */
@@ -549,7 +557,8 @@ SYSCALL_DEFINE1(mlockall, int, flags)
        if (!can_do_mlock())
                goto out;
-        lru_add_drain_all();    /* flush pagevec */
+        if (flags & MCL_CURRENT)
+                lru_add_drain_all();    /* flush pagevec */
        down_write(&current->mm->mmap_sem);
diff --git a/mm/mmap.c b/mm/mmap.c
index a65efd4db3e1..3c0061f744f5 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -2558,7 +2558,6 @@ int mm_take_all_locks(struct mm_struct *mm)
 {
        struct vm_area_struct *vma;
        struct anon_vma_chain *avc;
-        int ret = -EINTR;
        BUG_ON(down_read_trylock(&mm->mmap_sem));
@@ -2579,13 +2578,11 @@ int mm_take_all_locks(struct mm_struct *mm)
                                vm_lock_anon_vma(mm, avc->anon_vma);
        }
-        ret = 0;
+        return 0;
 out_unlock:
-        if (ret)
+        mm_drop_all_locks(mm);
-                mm_drop_all_locks(mm);
+        return -EINTR;
-        return ret;
 }
 static void vm_unlock_anon_vma(struct anon_vma *anon_vma)
diff --git a/mm/mremap.c b/mm/mremap.c
index 506fa44403df..d6959cb4df58 100644
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -41,8 +41,7 @@ static pmd_t *get_old_pmd(struct mm_struct *mm, unsigned long addr)
                return NULL;
        pmd = pmd_offset(pud, addr);
-        split_huge_page_pmd(mm, pmd);
+        if (pmd_none(*pmd))
-        if (pmd_none_or_clear_bad(pmd))
                return NULL;
        return pmd;
@@ -65,8 +64,6 @@ static pmd_t *alloc_new_pmd(struct mm_struct *mm, struct vm_area_struct *vma,
                return NULL;
        VM_BUG_ON(pmd_trans_huge(*pmd));
-        if (pmd_none(*pmd) && __pte_alloc(mm, vma, pmd, addr))
-                return NULL;
        return pmd;
 }
@@ -80,11 +77,7 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd,
        struct mm_struct *mm = vma->vm_mm;
        pte_t *old_pte, *new_pte, pte;
        spinlock_t *old_ptl, *new_ptl;
-        unsigned long old_start;
-        old_start = old_addr;
-        mmu_notifier_invalidate_range_start(vma->vm_mm,
-                                            old_start, old_end);
        if (vma->vm_file) {
                /*
                 * Subtle point from Rajesh Venkatasubramanian: before
@@ -111,7 +104,7 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd,
                                   new_pte++, new_addr += PAGE_SIZE) {
                if (pte_none(*old_pte))
                        continue;
-                pte = ptep_clear_flush(vma, old_addr, old_pte);
+                pte = ptep_get_and_clear(mm, old_addr, old_pte);
                pte = move_pte(pte, new_vma->vm_page_prot, old_addr, new_addr);
                set_pte_at(mm, new_addr, new_pte, pte);
        }
@@ -123,7 +116,6 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd,
        pte_unmap_unlock(old_pte - 1, old_ptl);
        if (mapping)
                mutex_unlock(&mapping->i_mmap_mutex);
-        mmu_notifier_invalidate_range_end(vma->vm_mm, old_start, old_end);
 }
 #define LATENCY_LIMIT   (64 * PAGE_SIZE)
@@ -134,22 +126,43 @@ unsigned long move_page_tables(struct vm_area_struct *vma,
 {
        unsigned long extent, next, old_end;
        pmd_t *old_pmd, *new_pmd;
+        bool need_flush = false;
        old_end = old_addr + len;
        flush_cache_range(vma, old_addr, old_end);
+        mmu_notifier_invalidate_range_start(vma->vm_mm, old_addr, old_end);
        for (; old_addr < old_end; old_addr += extent, new_addr += extent) {
                cond_resched();
                next = (old_addr + PMD_SIZE) & PMD_MASK;
-                if (next - 1 > old_end)
+                /* even if next overflowed, extent below will be ok */
-                        next = old_end;
                extent = next - old_addr;
+                if (extent > old_end - old_addr)
+                        extent = old_end - old_addr;
                old_pmd = get_old_pmd(vma->vm_mm, old_addr);
                if (!old_pmd)
                        continue;
                new_pmd = alloc_new_pmd(vma->vm_mm, vma, new_addr);
                if (!new_pmd)
                        break;
+                if (pmd_trans_huge(*old_pmd)) {
+                        int err = 0;
+                        if (extent == HPAGE_PMD_SIZE)
+                                err = move_huge_pmd(vma, new_vma, old_addr,
+                                                    new_addr, old_end,
+                                                    old_pmd, new_pmd);
+                        if (err > 0) {
+                                need_flush = true;
+                                continue;
+                        } else if (!err) {
+                                split_huge_page_pmd(vma->vm_mm, old_pmd);
+                        }
+                        VM_BUG_ON(pmd_trans_huge(*old_pmd));
+                }
+                if (pmd_none(*new_pmd) && __pte_alloc(new_vma->vm_mm, new_vma,
+                                                      new_pmd, new_addr))
+                        break;
                next = (new_addr + PMD_SIZE) & PMD_MASK;
                if (extent > next - new_addr)
                        extent = next - new_addr;
@@ -157,7 +170,12 @@ unsigned long move_page_tables(struct vm_area_struct *vma,
                        extent = LATENCY_LIMIT;
                move_ptes(vma, old_pmd, old_addr, old_addr + extent,
                                new_vma, new_pmd, new_addr);
+                need_flush = true;
        }
+        if (likely(need_flush))
+                flush_tlb_range(vma, old_end-len, old_addr);
+        mmu_notifier_invalidate_range_end(vma->vm_mm, old_end-len, old_end);
        return len + old_addr - old_end;        /* how much done */
 }
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 626303b52f3c..e916168b6e0a 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -32,12 +32,32 @@
 #include <linux/mempolicy.h>
 #include <linux/security.h>
 #include <linux/ptrace.h>
+#include <linux/freezer.h>
 int sysctl_panic_on_oom;
 int sysctl_oom_kill_allocating_task;
 int sysctl_oom_dump_tasks = 1;
 static DEFINE_SPINLOCK(zone_scan_lock);
+/*
+ * compare_swap_oom_score_adj() - compare and swap current's oom_score_adj
+ * @old_val: old oom_score_adj for compare
+ * @new_val: new oom_score_adj for swap
+ *
+ * Sets the oom_score_adj value for current to @new_val iff its present value is
+ * @old_val.  Usually used to reinstate a previous value to prevent racing with
+ * userspacing tuning the value in the interim.
+ */
+void compare_swap_oom_score_adj(int old_val, int new_val)
+{
+        struct sighand_struct *sighand = current->sighand;
+        spin_lock_irq(&sighand->siglock);
+        if (current->signal->oom_score_adj == old_val)
+                current->signal->oom_score_adj = new_val;
+        spin_unlock_irq(&sighand->siglock);
+}
 /**
 * test_set_oom_score_adj() - set current's oom_score_adj and return old value
 * @new_val: new oom_score_adj value
@@ -53,13 +73,7 @@ int test_set_oom_score_adj(int new_val)
        spin_lock_irq(&sighand->siglock);
        old_val = current->signal->oom_score_adj;
-        if (new_val != old_val) {
+        current->signal->oom_score_adj = new_val;
-                if (new_val == OOM_SCORE_ADJ_MIN)
-                        atomic_inc(&current->mm->oom_disable_count);
-                else if (old_val == OOM_SCORE_ADJ_MIN)
-                        atomic_dec(&current->mm->oom_disable_count);
-                current->signal->oom_score_adj = new_val;
-        }
        spin_unlock_irq(&sighand->siglock);
        return old_val;
@@ -172,16 +186,6 @@ unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem,
                return 0;
        /*
-         * Shortcut check for a thread sharing p->mm that is OOM_SCORE_ADJ_MIN
-         * so the entire heuristic doesn't need to be executed for something
-         * that cannot be killed.
-         */
-        if (atomic_read(&p->mm->oom_disable_count)) {
-                task_unlock(p);
-                return 0;
-        }
-        /*
         * The memory controller may have a limit of 0 bytes, so avoid a divide
         * by zero, if necessary.
         */
@@ -317,8 +321,11 @@ static struct task_struct *select_bad_process(unsigned int *ppoints,
                 * blocked waiting for another task which itself is waiting
                 * for memory. Is there a better alternative?
                 */
-                if (test_tsk_thread_flag(p, TIF_MEMDIE))
+                if (test_tsk_thread_flag(p, TIF_MEMDIE)) {
+                        if (unlikely(frozen(p)))
+                                thaw_process(p);
                        return ERR_PTR(-1UL);
+                }
                if (!p->mm)
                        continue;
@@ -435,7 +442,7 @@ static int oom_kill_task(struct task_struct *p, struct mem_cgroup *mem)
        task_unlock(p);
        /*
-         * Kill all processes sharing p->mm in other thread groups, if any.
+         * Kill all user processes sharing p->mm in other thread groups, if any.
         * They don't get access to memory reserves or a higher scheduler
         * priority, though, to avoid depletion of all memory or task
         * starvation.  This prevents mm->mmap_sem livelock when an oom killed
@@ -445,7 +452,11 @@ static int oom_kill_task(struct task_struct *p, struct mem_cgroup *mem)
         * signal.
         */
        for_each_process(q)
-                if (q->mm == mm && !same_thread_group(q, p)) {
+                if (q->mm == mm && !same_thread_group(q, p) &&
+                    !(q->flags & PF_KTHREAD)) {
+                        if (q->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
+                                continue;
                        task_lock(q);   /* Protect ->comm from prctl() */
                        pr_err("Kill process %d (%s) sharing same memory\n",
                                task_pid_nr(q), q->comm);
@@ -722,7 +733,7 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
        read_lock(&tasklist_lock);
        if (sysctl_oom_kill_allocating_task &&
            !oom_unkillable_task(current, NULL, nodemask) &&
-            current->mm && !atomic_read(&current->mm->oom_disable_count)) {
+            current->mm) {
                /*
                 * oom_kill_process() needs tasklist_lock held.  If it returns
                 * non-zero, current could not be killed so we must fallback to
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 0e309cd1b5b9..793e9874de51 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -305,7 +305,9 @@ static unsigned long task_min_dirty_limit(unsigned long bdi_dirty)
 }
 /*
- *
+ * bdi_min_ratio keeps the sum of the minimum dirty shares of all
+ * registered backing devices, which, for obvious reasons, can not
+ * exceed 100%.
 */
 static unsigned int bdi_min_ratio;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6e8ecb6e021c..9dd443d89d8b 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -318,6 +318,7 @@ static void bad_page(struct page *page)
                current->comm, page_to_pfn(page));
        dump_page(page);
+        print_modules();
        dump_stack();
 out:
        /* Leave bad fields for debug, except PageBuddy could make trouble */
@@ -1753,7 +1754,6 @@ static DEFINE_RATELIMIT_STATE(nopage_rs,
 void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...)
 {
-        va_list args;
        unsigned int filter = SHOW_MEM_FILTER_NODES;
        if ((gfp_mask & __GFP_NOWARN) || !__ratelimit(&nopage_rs))
@@ -1772,14 +1772,21 @@ void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...)
                filter &= ~SHOW_MEM_FILTER_NODES;
        if (fmt) {
-                printk(KERN_WARNING);
+                struct va_format vaf;
+                va_list args;
                va_start(args, fmt);
-                vprintk(fmt, args);
+                vaf.fmt = fmt;
+                vaf.va = &args;
+                pr_warn("%pV", &vaf);
                va_end(args);
        }
-        pr_warning("%s: page allocation failure: order:%d, mode:0x%x\n",
+        pr_warn("%s: page allocation failure: order:%d, mode:0x%x\n",
-                   current->comm, order, gfp_mask);
+                current->comm, order, gfp_mask);
        dump_stack();
        if (!should_suppress_show_mem())
diff --git a/mm/process_vm_access.c b/mm/process_vm_access.c
new file mode 100644
index 000000000000..e920aa3ce104
--- /dev/null
+++ b/mm/process_vm_access.c
@@ -0,0 +1,496 @@
+/*
+ * linux/mm/process_vm_access.c
+ *
+ * Copyright (C) 2010-2011 Christopher Yeoh <cyeoh@au1.ibm.com>, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <linux/mm.h>
+#include <linux/uio.h>
+#include <linux/sched.h>
+#include <linux/highmem.h>
+#include <linux/ptrace.h>
+#include <linux/slab.h>
+#include <linux/syscalls.h>
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+#endif
+/**
+ * process_vm_rw_pages - read/write pages from task specified
+ * @task: task to read/write from
+ * @mm: mm for task
+ * @process_pages: struct pages area that can store at least
+ *  nr_pages_to_copy struct page pointers
+ * @pa: address of page in task to start copying from/to
+ * @start_offset: offset in page to start copying from/to
+ * @len: number of bytes to copy
+ * @lvec: iovec array specifying where to copy to/from
+ * @lvec_cnt: number of elements in iovec array
+ * @lvec_current: index in iovec array we are up to
+ * @lvec_offset: offset in bytes from current iovec iov_base we are up to
+ * @vm_write: 0 means copy from, 1 means copy to
+ * @nr_pages_to_copy: number of pages to copy
+ * @bytes_copied: returns number of bytes successfully copied
+ * Returns 0 on success, error code otherwise
+ */
+static int process_vm_rw_pages(struct task_struct *task,
+                               struct mm_struct *mm,
+                               struct page **process_pages,
+                               unsigned long pa,
+                               unsigned long start_offset,
+                               unsigned long len,
+                               const struct iovec *lvec,
+                               unsigned long lvec_cnt,
+                               unsigned long *lvec_current,
+                               size_t *lvec_offset,
+                               int vm_write,
+                               unsigned int nr_pages_to_copy,
+                               ssize_t *bytes_copied)
+{
+        int pages_pinned;
+        void *target_kaddr;
+        int pgs_copied = 0;
+        int j;
+        int ret;
+        ssize_t bytes_to_copy;
+        ssize_t rc = 0;
+        *bytes_copied = 0;
+        /* Get the pages we're interested in */
+        down_read(&mm->mmap_sem);
+        pages_pinned = get_user_pages(task, mm, pa,
+                                      nr_pages_to_copy,
+                                      vm_write, 0, process_pages, NULL);
+        up_read(&mm->mmap_sem);
+        if (pages_pinned != nr_pages_to_copy) {
+                rc = -EFAULT;
+                goto end;
+        }
+        /* Do the copy for each page */
+        for (pgs_copied = 0;
+             (pgs_copied < nr_pages_to_copy) && (*lvec_current < lvec_cnt);
+             pgs_copied++) {
+                /* Make sure we have a non zero length iovec */
+                while (*lvec_current < lvec_cnt
+                       && lvec[*lvec_current].iov_len == 0)
+                        (*lvec_current)++;
+                if (*lvec_current == lvec_cnt)
+                        break;
+                /*
+                 * Will copy smallest of:
+                 * - bytes remaining in page
+                 * - bytes remaining in destination iovec
+                 */
+                bytes_to_copy = min_t(ssize_t, PAGE_SIZE - start_offset,
+                                      len - *bytes_copied);
+                bytes_to_copy = min_t(ssize_t, bytes_to_copy,
+                                      lvec[*lvec_current].iov_len
+                                      - *lvec_offset);
+                target_kaddr = kmap(process_pages[pgs_copied]) + start_offset;
+                if (vm_write)
+                        ret = copy_from_user(target_kaddr,
+                                             lvec[*lvec_current].iov_base
+                                             + *lvec_offset,
+                                             bytes_to_copy);
+                else
+                        ret = copy_to_user(lvec[*lvec_current].iov_base
+                                           + *lvec_offset,
+                                           target_kaddr, bytes_to_copy);
+                kunmap(process_pages[pgs_copied]);
+                if (ret) {
+                        *bytes_copied += bytes_to_copy - ret;
+                        pgs_copied++;
+                        rc = -EFAULT;
+                        goto end;
+                }
+                *bytes_copied += bytes_to_copy;
+                *lvec_offset += bytes_to_copy;
+                if (*lvec_offset == lvec[*lvec_current].iov_len) {
+                        /*
+                         * Need to copy remaining part of page into the
+                         * next iovec if there are any bytes left in page
+                         */
+                        (*lvec_current)++;
+                        *lvec_offset = 0;
+                        start_offset = (start_offset + bytes_to_copy)
+                                % PAGE_SIZE;
+                        if (start_offset)
+                                pgs_copied--;
+                } else {
+                        start_offset = 0;
+                }
+        }
+end:
+        if (vm_write) {
+                for (j = 0; j < pages_pinned; j++) {
+                        if (j < pgs_copied)
+                                set_page_dirty_lock(process_pages[j]);
+                        put_page(process_pages[j]);
+                }
+        } else {
+                for (j = 0; j < pages_pinned; j++)
+                        put_page(process_pages[j]);
+        }
+        return rc;
+}
+/* Maximum number of pages kmalloc'd to hold struct page's during copy */
+#define PVM_MAX_KMALLOC_PAGES (PAGE_SIZE * 2)
+/**
+ * process_vm_rw_single_vec - read/write pages from task specified
+ * @addr: start memory address of target process
+ * @len: size of area to copy to/from
+ * @lvec: iovec array specifying where to copy to/from locally
+ * @lvec_cnt: number of elements in iovec array
+ * @lvec_current: index in iovec array we are up to
+ * @lvec_offset: offset in bytes from current iovec iov_base we are up to
+ * @process_pages: struct pages area that can store at least
+ *  nr_pages_to_copy struct page pointers
+ * @mm: mm for task
+ * @task: task to read/write from
+ * @vm_write: 0 means copy from, 1 means copy to
+ * @bytes_copied: returns number of bytes successfully copied
+ * Returns 0 on success or on failure error code
+ */
+static int process_vm_rw_single_vec(unsigned long addr,
+                                    unsigned long len,
+                                    const struct iovec *lvec,
+                                    unsigned long lvec_cnt,
+                                    unsigned long *lvec_current,
+                                    size_t *lvec_offset,
+                                    struct page **process_pages,
+                                    struct mm_struct *mm,
+                                    struct task_struct *task,
+                                    int vm_write,
+                                    ssize_t *bytes_copied)
+{
+        unsigned long pa = addr & PAGE_MASK;
+        unsigned long start_offset = addr - pa;
+        unsigned long nr_pages;
+        ssize_t bytes_copied_loop;
+        ssize_t rc = 0;
+        unsigned long nr_pages_copied = 0;
+        unsigned long nr_pages_to_copy;
+        unsigned long max_pages_per_loop = PVM_MAX_KMALLOC_PAGES
+                / sizeof(struct pages *);
+        *bytes_copied = 0;
+        /* Work out address and page range required */
+        if (len == 0)
+                return 0;
+        nr_pages = (addr + len - 1) / PAGE_SIZE - addr / PAGE_SIZE + 1;
+        while ((nr_pages_copied < nr_pages) && (*lvec_current < lvec_cnt)) {
+                nr_pages_to_copy = min(nr_pages - nr_pages_copied,
+                                       max_pages_per_loop);
+                rc = process_vm_rw_pages(task, mm, process_pages, pa,
+                                         start_offset, len,
+                                         lvec, lvec_cnt,
+                                         lvec_current, lvec_offset,
+                                         vm_write, nr_pages_to_copy,
+                                         &bytes_copied_loop);
+                start_offset = 0;
+                *bytes_copied += bytes_copied_loop;
+                if (rc < 0) {
+                        return rc;
+                } else {
+                        len -= bytes_copied_loop;
+                        nr_pages_copied += nr_pages_to_copy;
+                        pa += nr_pages_to_copy * PAGE_SIZE;
+                }
+        }
+        return rc;
+}
+/* Maximum number of entries for process pages array
+   which lives on stack */
+#define PVM_MAX_PP_ARRAY_COUNT 16
+/**
+ * process_vm_rw_core - core of reading/writing pages from task specified
+ * @pid: PID of process to read/write from/to
+ * @lvec: iovec array specifying where to copy to/from locally
+ * @liovcnt: size of lvec array
+ * @rvec: iovec array specifying where to copy to/from in the other process
+ * @riovcnt: size of rvec array
+ * @flags: currently unused
+ * @vm_write: 0 if reading from other process, 1 if writing to other process
+ * Returns the number of bytes read/written or error code. May
+ *  return less bytes than expected if an error occurs during the copying
+ *  process.
+ */
+static ssize_t process_vm_rw_core(pid_t pid, const struct iovec *lvec,
+                                  unsigned long liovcnt,
+                                  const struct iovec *rvec,
+                                  unsigned long riovcnt,
+                                  unsigned long flags, int vm_write)
+{
+        struct task_struct *task;
+        struct page *pp_stack[PVM_MAX_PP_ARRAY_COUNT];
+        struct page **process_pages = pp_stack;
+        struct mm_struct *mm;
+        unsigned long i;
+        ssize_t rc = 0;
+        ssize_t bytes_copied_loop;
+        ssize_t bytes_copied = 0;
+        unsigned long nr_pages = 0;
+        unsigned long nr_pages_iov;
+        unsigned long iov_l_curr_idx = 0;
+        size_t iov_l_curr_offset = 0;
+        ssize_t iov_len;
+        /*
+         * Work out how many pages of struct pages we're going to need
+         * when eventually calling get_user_pages
+         */
+        for (i = 0; i < riovcnt; i++) {
+                iov_len = rvec[i].iov_len;
+                if (iov_len > 0) {
+                        nr_pages_iov = ((unsigned long)rvec[i].iov_base
+                                        + iov_len)
+                                / PAGE_SIZE - (unsigned long)rvec[i].iov_base
+                                / PAGE_SIZE + 1;
+                        nr_pages = max(nr_pages, nr_pages_iov);
+                }
+        }
+        if (nr_pages == 0)
+                return 0;
+        if (nr_pages > PVM_MAX_PP_ARRAY_COUNT) {
+                /* For reliability don't try to kmalloc more than
+                   2 pages worth */
+                process_pages = kmalloc(min_t(size_t, PVM_MAX_KMALLOC_PAGES,
+                                              sizeof(struct pages *)*nr_pages),
+                                        GFP_KERNEL);
+                if (!process_pages)
+                        return -ENOMEM;
+        }
+        /* Get process information */
+        rcu_read_lock();
+        task = find_task_by_vpid(pid);
+        if (task)
+                get_task_struct(task);
+        rcu_read_unlock();
+        if (!task) {
+                rc = -ESRCH;
+                goto free_proc_pages;
+        }
+        task_lock(task);
+        if (__ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
+                task_unlock(task);
+                rc = -EPERM;
+                goto put_task_struct;
+        }
+        mm = task->mm;
+        if (!mm || (task->flags & PF_KTHREAD)) {
+                task_unlock(task);
+                rc = -EINVAL;
+                goto put_task_struct;
+        }
+        atomic_inc(&mm->mm_users);
+        task_unlock(task);
+        for (i = 0; i < riovcnt && iov_l_curr_idx < liovcnt; i++) {
+                rc = process_vm_rw_single_vec(
+                        (unsigned long)rvec[i].iov_base, rvec[i].iov_len,
+                        lvec, liovcnt, &iov_l_curr_idx, &iov_l_curr_offset,
+                        process_pages, mm, task, vm_write, &bytes_copied_loop);
+                bytes_copied += bytes_copied_loop;
+                if (rc != 0) {
+                        /* If we have managed to copy any data at all then
+                           we return the number of bytes copied. Otherwise
+                           we return the error code */
+                        if (bytes_copied)
+                                rc = bytes_copied;
+                        goto put_mm;
+                }
+        }
+        rc = bytes_copied;
+put_mm:
+        mmput(mm);
+put_task_struct:
+        put_task_struct(task);
+free_proc_pages:
+        if (process_pages != pp_stack)
+                kfree(process_pages);
+        return rc;
+}
+/**
+ * process_vm_rw - check iovecs before calling core routine
+ * @pid: PID of process to read/write from/to
+ * @lvec: iovec array specifying where to copy to/from locally
+ * @liovcnt: size of lvec array
+ * @rvec: iovec array specifying where to copy to/from in the other process
+ * @riovcnt: size of rvec array
+ * @flags: currently unused
+ * @vm_write: 0 if reading from other process, 1 if writing to other process
+ * Returns the number of bytes read/written or error code. May
+ *  return less bytes than expected if an error occurs during the copying
+ *  process.
+ */
+static ssize_t process_vm_rw(pid_t pid,
+                             const struct iovec __user *lvec,
+                             unsigned long liovcnt,
+                             const struct iovec __user *rvec,
+                             unsigned long riovcnt,
+                             unsigned long flags, int vm_write)
+{
+        struct iovec iovstack_l[UIO_FASTIOV];
+        struct iovec iovstack_r[UIO_FASTIOV];
+        struct iovec *iov_l = iovstack_l;
+        struct iovec *iov_r = iovstack_r;
+        ssize_t rc;
+        if (flags != 0)
+                return -EINVAL;
+        /* Check iovecs */
+        if (vm_write)
+                rc = rw_copy_check_uvector(WRITE, lvec, liovcnt, UIO_FASTIOV,
+                                           iovstack_l, &iov_l, 1);
+        else
+                rc = rw_copy_check_uvector(READ, lvec, liovcnt, UIO_FASTIOV,
+                                           iovstack_l, &iov_l, 1);
+        if (rc <= 0)
+                goto free_iovecs;
+        rc = rw_copy_check_uvector(READ, rvec, riovcnt, UIO_FASTIOV,
+                                   iovstack_r, &iov_r, 0);
+        if (rc <= 0)
+                goto free_iovecs;
+        rc = process_vm_rw_core(pid, iov_l, liovcnt, iov_r, riovcnt, flags,
+                                vm_write);
+free_iovecs:
+        if (iov_r != iovstack_r)
+                kfree(iov_r);
+        if (iov_l != iovstack_l)
+                kfree(iov_l);
+        return rc;
+}
+SYSCALL_DEFINE6(process_vm_readv, pid_t, pid, const struct iovec __user *, lvec,
+                unsigned long, liovcnt, const struct iovec __user *, rvec,
+                unsigned long, riovcnt, unsigned long, flags)
+{
+        return process_vm_rw(pid, lvec, liovcnt, rvec, riovcnt, flags, 0);
+}
+SYSCALL_DEFINE6(process_vm_writev, pid_t, pid,
+                const struct iovec __user *, lvec,
+                unsigned long, liovcnt, const struct iovec __user *, rvec,
+                unsigned long, riovcnt, unsigned long, flags)
+{
+        return process_vm_rw(pid, lvec, liovcnt, rvec, riovcnt, flags, 1);
+}
+#ifdef CONFIG_COMPAT
+asmlinkage ssize_t
+compat_process_vm_rw(compat_pid_t pid,
+                     const struct compat_iovec __user *lvec,
+                     unsigned long liovcnt,
+                     const struct compat_iovec __user *rvec,
+                     unsigned long riovcnt,
+                     unsigned long flags, int vm_write)
+{
+        struct iovec iovstack_l[UIO_FASTIOV];
+        struct iovec iovstack_r[UIO_FASTIOV];
+        struct iovec *iov_l = iovstack_l;
+        struct iovec *iov_r = iovstack_r;
+        ssize_t rc = -EFAULT;
+        if (flags != 0)
+                return -EINVAL;
+        if (!access_ok(VERIFY_READ, lvec, liovcnt * sizeof(*lvec)))
+                goto out;
+        if (!access_ok(VERIFY_READ, rvec, riovcnt * sizeof(*rvec)))
+                goto out;
+        if (vm_write)
+                rc = compat_rw_copy_check_uvector(WRITE, lvec, liovcnt,
+                                                  UIO_FASTIOV, iovstack_l,
+                                                  &iov_l, 1);
+        else
+                rc = compat_rw_copy_check_uvector(READ, lvec, liovcnt,
+                                                  UIO_FASTIOV, iovstack_l,
+                                                  &iov_l, 1);
+        if (rc <= 0)
+                goto free_iovecs;
+        rc = compat_rw_copy_check_uvector(READ, rvec, riovcnt,
+                                          UIO_FASTIOV, iovstack_r,
+                                          &iov_r, 0);
+        if (rc <= 0)
+                goto free_iovecs;
+        rc = process_vm_rw_core(pid, iov_l, liovcnt, iov_r, riovcnt, flags,
+                           vm_write);
+free_iovecs:
+        if (iov_r != iovstack_r)
+                kfree(iov_r);
+        if (iov_l != iovstack_l)
+                kfree(iov_l);
+out:
+        return rc;
+}
+asmlinkage ssize_t
+compat_sys_process_vm_readv(compat_pid_t pid,
+                            const struct compat_iovec __user *lvec,
+                            unsigned long liovcnt,
+                            const struct compat_iovec __user *rvec,
+                            unsigned long riovcnt,
+                            unsigned long flags)
+{
+        return compat_process_vm_rw(pid, lvec, liovcnt, rvec,
+                                    riovcnt, flags, 0);
+}
+asmlinkage ssize_t
+compat_sys_process_vm_writev(compat_pid_t pid,
+                             const struct compat_iovec __user *lvec,
+                             unsigned long liovcnt,
+                             const struct compat_iovec __user *rvec,
+                             unsigned long riovcnt,
+                             unsigned long flags)
+{
+        return compat_process_vm_rw(pid, lvec, liovcnt, rvec,
+                                    riovcnt, flags, 1);
+}
+#endif
diff --git a/mm/rmap.c b/mm/rmap.c
index 8005080fb9e3..6541cf7fd1d3 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1164,7 +1164,7 @@ void page_remove_rmap(struct page *page)
 /*
 * Subfunctions of try_to_unmap: try_to_unmap_one called
- * repeatedly from either try_to_unmap_anon or try_to_unmap_file.
+ * repeatedly from try_to_unmap_ksm, try_to_unmap_anon or try_to_unmap_file.
 */
 int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
                     unsigned long address, enum ttu_flags flags)
diff --git a/mm/shmem.c b/mm/shmem.c
index 2d3577295298..fa4fa6ce13bc 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -1068,6 +1068,12 @@ int shmem_lock(struct file *file, int lock, struct user_struct *user)
                user_shm_unlock(inode->i_size, user);
                info->flags &= ~VM_LOCKED;
                mapping_clear_unevictable(file->f_mapping);
+                /*
+                 * Ensure that a racing putback_lru_page() can see
+                 * the pages of this mapping are evictable when we
+                 * skip them due to !PageLRU during the scan.
+                 */
+                smp_mb__after_clear_bit();
                scan_mapping_unevictable_pages(file->f_mapping);
        }
        retval = 0;
diff --git a/mm/slub.c b/mm/slub.c
index 95215aa6a75e..7d2a996c307e 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -655,49 +655,6 @@ static void init_object(struct kmem_cache *s, void *object, u8 val)
                memset(p + s->objsize, val, s->inuse - s->objsize);
 }
-static u8 *check_bytes8(u8 *start, u8 value, unsigned int bytes)
-{
-        while (bytes) {
-                if (*start != value)
-                        return start;
-                start++;
-                bytes--;
-        }
-        return NULL;
-}
-static u8 *check_bytes(u8 *start, u8 value, unsigned int bytes)
-{
-        u64 value64;
-        unsigned int words, prefix;
-        if (bytes <= 16)
-                return check_bytes8(start, value, bytes);
-        value64 = value | value << 8 | value << 16 | value << 24;
-        value64 = (value64 & 0xffffffff) | value64 << 32;
-        prefix = 8 - ((unsigned long)start) % 8;
-        if (prefix) {
-                u8 *r = check_bytes8(start, value, prefix);
-                if (r)
-                        return r;
-                start += prefix;
-                bytes -= prefix;
-        }
-        words = bytes / 8;
-        while (words) {
-                if (*(u64 *)start != value64)
-                        return check_bytes8(start, value, 8);
-                start += 8;
-                words--;
-        }
-        return check_bytes8(start, value, bytes % 8);
-}
 static void restore_bytes(struct kmem_cache *s, char *message, u8 data,
                                                void *from, void *to)
 {
@@ -712,7 +669,7 @@ static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
        u8 *fault;
        u8 *end;
-        fault = check_bytes(start, value, bytes);
+        fault = memchr_inv(start, value, bytes);
        if (!fault)
                return 1;
@@ -805,7 +762,7 @@ static int slab_pad_check(struct kmem_cache *s, struct page *page)
        if (!remainder)
                return 1;
-        fault = check_bytes(end - remainder, POISON_INUSE, remainder);
+        fault = memchr_inv(end - remainder, POISON_INUSE, remainder);
        if (!fault)
                return 1;
        while (end > fault && end[-1] == POISON_INUSE)
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 17bc224bce68..c9d654009125 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1617,7 +1617,7 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
        oom_score_adj = test_set_oom_score_adj(OOM_SCORE_ADJ_MAX);
        err = try_to_unuse(type);
-        test_set_oom_score_adj(oom_score_adj);
+        compare_swap_oom_score_adj(OOM_SCORE_ADJ_MAX, oom_score_adj);
        if (err) {
                /*
diff --git a/mm/thrash.c b/mm/thrash.c
index e53f7d02c17c..57ad495dbd54 100644
--- a/mm/thrash.c
+++ b/mm/thrash.c
@@ -29,7 +29,7 @@
 static DEFINE_SPINLOCK(swap_token_lock);
 struct mm_struct *swap_token_mm;
-struct mem_cgroup *swap_token_memcg;
+static struct mem_cgroup *swap_token_memcg;
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
 static struct mem_cgroup *swap_token_memcg_from_mm(struct mm_struct *mm)
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 5016f19e1661..b669aa6f6caf 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -1253,18 +1253,22 @@ EXPORT_SYMBOL_GPL(map_vm_area);
 DEFINE_RWLOCK(vmlist_lock);
 struct vm_struct *vmlist;
-static void insert_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
+static void setup_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
                              unsigned long flags, void *caller)
 {
-        struct vm_struct *tmp, **p;
        vm->flags = flags;
        vm->addr = (void *)va->va_start;
        vm->size = va->va_end - va->va_start;
        vm->caller = caller;
        va->private = vm;
        va->flags |= VM_VM_AREA;
+}
+static void insert_vmalloc_vmlist(struct vm_struct *vm)
+{
+        struct vm_struct *tmp, **p;
+        vm->flags &= ~VM_UNLIST;
        write_lock(&vmlist_lock);
        for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {
                if (tmp->addr >= vm->addr)
@@ -1275,6 +1279,13 @@ static void insert_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
        write_unlock(&vmlist_lock);
 }
+static void insert_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
+                              unsigned long flags, void *caller)
+{
+        setup_vmalloc_vm(vm, va, flags, caller);
+        insert_vmalloc_vmlist(vm);
+}
 static struct vm_struct *__get_vm_area_node(unsigned long size,
                unsigned long align, unsigned long flags, unsigned long start,
                unsigned long end, int node, gfp_t gfp_mask, void *caller)
@@ -1313,7 +1324,18 @@ static struct vm_struct *__get_vm_area_node(unsigned long size,
                return NULL;
        }
-        insert_vmalloc_vm(area, va, flags, caller);
+        /*
+         * When this function is called from __vmalloc_node_range,
+         * we do not add vm_struct to vmlist here to avoid
+         * accessing uninitialized members of vm_struct such as
+         * pages and nr_pages fields. They will be set later.
+         * To distinguish it from others, we use a VM_UNLIST flag.
+         */
+        if (flags & VM_UNLIST)
+                setup_vmalloc_vm(area, va, flags, caller);
+        else
+                insert_vmalloc_vm(area, va, flags, caller);
        return area;
 }
@@ -1381,17 +1403,20 @@ struct vm_struct *remove_vm_area(const void *addr)
        va = find_vmap_area((unsigned long)addr);
        if (va && va->flags & VM_VM_AREA) {
                struct vm_struct *vm = va->private;
-                struct vm_struct *tmp, **p;
-                /*
+                if (!(vm->flags & VM_UNLIST)) {
-                 * remove from list and disallow access to this vm_struct
+                        struct vm_struct *tmp, **p;
-                 * before unmap. (address range confliction is maintained by
+                        /*
-                 * vmap.)
+                         * remove from list and disallow access to
-                 */
+                         * this vm_struct before unmap. (address range
-                write_lock(&vmlist_lock);
+                         * confliction is maintained by vmap.)
-                for (p = &vmlist; (tmp = *p) != vm; p = &tmp->next)
+                         */
-                        ;
+                        write_lock(&vmlist_lock);
-                *p = tmp->next;
+                        for (p = &vmlist; (tmp = *p) != vm; p = &tmp->next)
-                write_unlock(&vmlist_lock);
+                                ;
+                        *p = tmp->next;
+                        write_unlock(&vmlist_lock);
+                }
                vmap_debug_free_range(va->va_start, va->va_end);
                free_unmap_vmap_area(va);
@@ -1568,8 +1593,8 @@ static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
        return area->addr;
 fail:
-        warn_alloc_failed(gfp_mask, order, "vmalloc: allocation failure, "
+        warn_alloc_failed(gfp_mask, order,
-                          "allocated %ld of %ld bytes\n",
+                          "vmalloc: allocation failure, allocated %ld of %ld bytes\n",
                          (area->nr_pages*PAGE_SIZE), area->size);
        vfree(area->addr);
        return NULL;
@@ -1600,17 +1625,22 @@ void *__vmalloc_node_range(unsigned long size, unsigned long align,
        size = PAGE_ALIGN(size);
        if (!size || (size >> PAGE_SHIFT) > totalram_pages)
-                return NULL;
+                goto fail;
-        area = __get_vm_area_node(size, align, VM_ALLOC, start, end, node,
-                                  gfp_mask, caller);
+        area = __get_vm_area_node(size, align, VM_ALLOC | VM_UNLIST,
+                                  start, end, node, gfp_mask, caller);
        if (!area)
-                return NULL;
+                goto fail;
        addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);
        /*
+         * In this function, newly allocated vm_struct is not added
+         * to vmlist at __get_vm_area_node(). so, it is added here.
+         */
+        insert_vmalloc_vmlist(area);
+        /*
         * A ref_count = 3 is needed because the vm_struct and vmap_area
         * structures allocated in the __get_vm_area_node() function contain
         * references to the virtual address of the vmalloc'ed block.
@@ -1618,6 +1648,12 @@ void *__vmalloc_node_range(unsigned long size, unsigned long align,
        kmemleak_alloc(addr, real_size, 3, gfp_mask);
        return addr;
+fail:
+        warn_alloc_failed(gfp_mask, 0,
+                          "vmalloc: allocation failure: %lu bytes\n",
+                          real_size);
+        return NULL;
 }
 /**
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 9fdfce7ba403..a90c603a8d02 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -495,15 +495,6 @@ static pageout_t pageout(struct page *page, struct address_space *mapping,
                        return PAGE_ACTIVATE;
                }
-                /*
-                 * Wait on writeback if requested to. This happens when
-                 * direct reclaiming a large contiguous area and the
-                 * first attempt to free a range of pages fails.
-                 */
-                if (PageWriteback(page) &&
-                    (sc->reclaim_mode & RECLAIM_MODE_SYNC))
-                        wait_on_page_writeback(page);
                if (!PageWriteback(page)) {
                        /* synchronous write or broken a_ops? */
                        ClearPageReclaim(page);
@@ -642,13 +633,14 @@ redo:
                lru = LRU_UNEVICTABLE;
                add_page_to_unevictable_list(page);
                /*
-                 * When racing with an mlock clearing (page is
+                 * When racing with an mlock or AS_UNEVICTABLE clearing
-                 * unlocked), make sure that if the other thread does
+                 * (page is unlocked) make sure that if the other thread
-                 * not observe our setting of PG_lru and fails
+                 * does not observe our setting of PG_lru and fails
-                 * isolation, we see PG_mlocked cleared below and move
+                 * isolation/check_move_unevictable_page,
+                 * we see PG_mlocked/AS_UNEVICTABLE cleared below and move
                 * the page back to the evictable list.
                 *
-                 * The other side is TestClearPageMlocked().
+                 * The other side is TestClearPageMlocked() or shmem_lock().
                 */
                smp_mb();
        }
@@ -759,7 +751,10 @@ static noinline_for_stack void free_page_list(struct list_head *free_pages)
 */
 static unsigned long shrink_page_list(struct list_head *page_list,
                                      struct zone *zone,
-                                      struct scan_control *sc)
+                                      struct scan_control *sc,
+                                      int priority,
+                                      unsigned long *ret_nr_dirty,
+                                      unsigned long *ret_nr_writeback)
 {
        LIST_HEAD(ret_pages);
        LIST_HEAD(free_pages);
@@ -767,6 +762,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
        unsigned long nr_dirty = 0;
        unsigned long nr_congested = 0;
        unsigned long nr_reclaimed = 0;
+        unsigned long nr_writeback = 0;
        cond_resched();
@@ -803,13 +799,12 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                        (PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));
                if (PageWriteback(page)) {
+                        nr_writeback++;
                        /*
-                         * Synchronous reclaim is performed in two passes,
+                         * Synchronous reclaim cannot queue pages for
-                         * first an asynchronous pass over the list to
+                         * writeback due to the possibility of stack overflow
-                         * start parallel writeback, and a second synchronous
+                         * but if it encounters a page under writeback, wait
-                         * pass to wait for the IO to complete.  Wait here
+                         * for the IO to complete.
-                         * for any page for which writeback has already
-                         * started.
                         */
                        if ((sc->reclaim_mode & RECLAIM_MODE_SYNC) &&
                            may_enter_fs)
@@ -865,6 +860,25 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                if (PageDirty(page)) {
                        nr_dirty++;
+                        /*
+                         * Only kswapd can writeback filesystem pages to
+                         * avoid risk of stack overflow but do not writeback
+                         * unless under significant pressure.
+                         */
+                        if (page_is_file_cache(page) &&
+                                        (!current_is_kswapd() || priority >= DEF_PRIORITY - 2)) {
+                                /*
+                                 * Immediately reclaim when written back.
+                                 * Similar in principal to deactivate_page()
+                                 * except we already have the page isolated
+                                 * and know it's dirty
+                                 */
+                                inc_zone_page_state(page, NR_VMSCAN_IMMEDIATE);
+                                SetPageReclaim(page);
+                                goto keep_locked;
+                        }
                        if (references == PAGEREF_RECLAIM_CLEAN)
                                goto keep_locked;
                        if (!may_enter_fs)
@@ -999,6 +1013,8 @@ keep_lumpy:
        list_splice(&ret_pages, page_list);
        count_vm_events(PGACTIVATE, pgactivate);
+        *ret_nr_dirty += nr_dirty;
+        *ret_nr_writeback += nr_writeback;
        return nr_reclaimed;
 }
@@ -1012,23 +1028,27 @@ keep_lumpy:
 *
 * returns 0 on success, -ve errno on failure.
 */
-int __isolate_lru_page(struct page *page, int mode, int file)
+int __isolate_lru_page(struct page *page, isolate_mode_t mode, int file)
 {
+        bool all_lru_mode;
        int ret = -EINVAL;
        /* Only take pages on the LRU. */
        if (!PageLRU(page))
                return ret;
+        all_lru_mode = (mode & (ISOLATE_ACTIVE|ISOLATE_INACTIVE)) ==
+                (ISOLATE_ACTIVE|ISOLATE_INACTIVE);
        /*
         * When checking the active state, we need to be sure we are
         * dealing with comparible boolean values.  Take the logical not
         * of each.
         */
-        if (mode != ISOLATE_BOTH && (!PageActive(page) != !mode))
+        if (!all_lru_mode && !PageActive(page) != !(mode & ISOLATE_ACTIVE))
                return ret;
-        if (mode != ISOLATE_BOTH && page_is_file_cache(page) != file)
+        if (!all_lru_mode && !!page_is_file_cache(page) != file)
                return ret;
        /*
@@ -1041,6 +1061,12 @@ int __isolate_lru_page(struct page *page, int mode, int file)
        ret = -EBUSY;
+        if ((mode & ISOLATE_CLEAN) && (PageDirty(page) || PageWriteback(page)))
+                return ret;
+        if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
+                return ret;
        if (likely(get_page_unless_zero(page))) {
                /*
                 * Be careful not to clear PageLRU until after we're
@@ -1076,7 +1102,8 @@ int __isolate_lru_page(struct page *page, int mode, int file)
 */
 static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
                struct list_head *src, struct list_head *dst,
-                unsigned long *scanned, int order, int mode, int file)
+                unsigned long *scanned, int order, isolate_mode_t mode,
+                int file)
 {
        unsigned long nr_taken = 0;
        unsigned long nr_lumpy_taken = 0;
@@ -1201,8 +1228,8 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
 static unsigned long isolate_pages_global(unsigned long nr,
                                        struct list_head *dst,
                                        unsigned long *scanned, int order,
-                                        int mode, struct zone *z,
+                                        isolate_mode_t mode,
-                                        int active, int file)
+                                        struct zone *z, int active, int file)
 {
        int lru = LRU_BASE;
        if (active)
@@ -1394,7 +1421,7 @@ static noinline_for_stack void update_isolated_counts(struct zone *zone,
 }
 /*
- * Returns true if the caller should wait to clean dirty/writeback pages.
+ * Returns true if a direct reclaim should wait on pages under writeback.
 *
 * If we are direct reclaiming for contiguous pages and we do not reclaim
 * everything in the list, try again and wait for writeback IO to complete.
@@ -1448,6 +1475,9 @@ shrink_inactive_list(unsigned long nr_to_scan, struct zone *zone,
        unsigned long nr_taken;
        unsigned long nr_anon;
        unsigned long nr_file;
+        unsigned long nr_dirty = 0;
+        unsigned long nr_writeback = 0;
+        isolate_mode_t reclaim_mode = ISOLATE_INACTIVE;
        while (unlikely(too_many_isolated(zone, file, sc))) {
                congestion_wait(BLK_RW_ASYNC, HZ/10);
@@ -1458,15 +1488,21 @@ shrink_inactive_list(unsigned long nr_to_scan, struct zone *zone,
        }
        set_reclaim_mode(priority, sc, false);
+        if (sc->reclaim_mode & RECLAIM_MODE_LUMPYRECLAIM)
+                reclaim_mode |= ISOLATE_ACTIVE;
        lru_add_drain();
+        if (!sc->may_unmap)
+                reclaim_mode |= ISOLATE_UNMAPPED;
+        if (!sc->may_writepage)
+                reclaim_mode |= ISOLATE_CLEAN;
        spin_lock_irq(&zone->lru_lock);
        if (scanning_global_lru(sc)) {
-                nr_taken = isolate_pages_global(nr_to_scan,
+                nr_taken = isolate_pages_global(nr_to_scan, &page_list,
-                        &page_list, &nr_scanned, sc->order,
+                        &nr_scanned, sc->order, reclaim_mode, zone, 0, file);
-                        sc->reclaim_mode & RECLAIM_MODE_LUMPYRECLAIM ?
-                                        ISOLATE_BOTH : ISOLATE_INACTIVE,
-                        zone, 0, file);
                zone->pages_scanned += nr_scanned;
                if (current_is_kswapd())
                        __count_zone_vm_events(PGSCAN_KSWAPD, zone,
@@ -1475,12 +1511,9 @@ shrink_inactive_list(unsigned long nr_to_scan, struct zone *zone,
                        __count_zone_vm_events(PGSCAN_DIRECT, zone,
                                               nr_scanned);
        } else {
-                nr_taken = mem_cgroup_isolate_pages(nr_to_scan,
+                nr_taken = mem_cgroup_isolate_pages(nr_to_scan, &page_list,
-                        &page_list, &nr_scanned, sc->order,
+                        &nr_scanned, sc->order, reclaim_mode, zone,
-                        sc->reclaim_mode & RECLAIM_MODE_LUMPYRECLAIM ?
+                        sc->mem_cgroup, 0, file);
-                                        ISOLATE_BOTH : ISOLATE_INACTIVE,
-                        zone, sc->mem_cgroup,
-                        0, file);
                /*
                 * mem_cgroup_isolate_pages() keeps track of
                 * scanned pages on its own.
@@ -1496,12 +1529,14 @@ shrink_inactive_list(unsigned long nr_to_scan, struct zone *zone,
        spin_unlock_irq(&zone->lru_lock);
-        nr_reclaimed = shrink_page_list(&page_list, zone, sc);
+        nr_reclaimed = shrink_page_list(&page_list, zone, sc, priority,
+                                                &nr_dirty, &nr_writeback);
        /* Check if we should syncronously wait for writeback */
        if (should_reclaim_stall(nr_taken, nr_reclaimed, priority, sc)) {
                set_reclaim_mode(priority, sc, true);
-                nr_reclaimed += shrink_page_list(&page_list, zone, sc);
+                nr_reclaimed += shrink_page_list(&page_list, zone, sc,
+                                        priority, &nr_dirty, &nr_writeback);
        }
        local_irq_disable();
@@ -1511,6 +1546,32 @@ shrink_inactive_list(unsigned long nr_to_scan, struct zone *zone,
        putback_lru_pages(zone, sc, nr_anon, nr_file, &page_list);
+        /*
+         * If reclaim is isolating dirty pages under writeback, it implies
+         * that the long-lived page allocation rate is exceeding the page
+         * laundering rate. Either the global limits are not being effective
+         * at throttling processes due to the page distribution throughout
+         * zones or there is heavy usage of a slow backing device. The
+         * only option is to throttle from reclaim context which is not ideal
+         * as there is no guarantee the dirtying process is throttled in the
+         * same way balance_dirty_pages() manages.
+         *
+         * This scales the number of dirty pages that must be under writeback
+         * before throttling depending on priority. It is a simple backoff
+         * function that has the most effect in the range DEF_PRIORITY to
+         * DEF_PRIORITY-2 which is the priority reclaim is considered to be
+         * in trouble and reclaim is considered to be in trouble.
+         *
+         * DEF_PRIORITY   100% isolated pages must be PageWriteback to throttle
+         * DEF_PRIORITY-1  50% must be PageWriteback
+         * DEF_PRIORITY-2  25% must be PageWriteback, kswapd in trouble
+         * ...
+         * DEF_PRIORITY-6 For SWAP_CLUSTER_MAX isolated pages, throttle if any
+         *                     isolated page is PageWriteback
+         */
+        if (nr_writeback && nr_writeback >= (nr_taken >> (DEF_PRIORITY-priority)))
+                wait_iff_congested(zone, BLK_RW_ASYNC, HZ/10);
        trace_mm_vmscan_lru_shrink_inactive(zone->zone_pgdat->node_id,
                zone_idx(zone),
                nr_scanned, nr_reclaimed,
@@ -1582,19 +1643,26 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
        struct page *page;
        struct zone_reclaim_stat *reclaim_stat = get_reclaim_stat(zone, sc);
        unsigned long nr_rotated = 0;
+        isolate_mode_t reclaim_mode = ISOLATE_ACTIVE;
        lru_add_drain();
+        if (!sc->may_unmap)
+                reclaim_mode |= ISOLATE_UNMAPPED;
+        if (!sc->may_writepage)
+                reclaim_mode |= ISOLATE_CLEAN;
        spin_lock_irq(&zone->lru_lock);
        if (scanning_global_lru(sc)) {
                nr_taken = isolate_pages_global(nr_pages, &l_hold,
                                                &pgscanned, sc->order,
-                                                ISOLATE_ACTIVE, zone,
+                                                reclaim_mode, zone,
                                                1, file);
                zone->pages_scanned += pgscanned;
        } else {
                nr_taken = mem_cgroup_isolate_pages(nr_pages, &l_hold,
                                                &pgscanned, sc->order,
-                                                ISOLATE_ACTIVE, zone,
+                                                reclaim_mode, zone,
                                                sc->mem_cgroup, 1, file);
                /*
                 * mem_cgroup_isolate_pages() keeps track of
@@ -1795,12 +1863,19 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
        enum lru_list l;
        int noswap = 0;
        bool force_scan = false;
-        unsigned long nr_force_scan[2];
-        /* kswapd does zone balancing and needs to scan this zone */
+        /*
+         * If the zone or memcg is small, nr[l] can be 0.  This
+         * results in no scanning on this priority and a potential
+         * priority drop.  Global direct reclaim can go to the next
+         * zone and tends to have no problems. Global kswapd is for
+         * zone balancing and it needs to scan a minimum amount. When
+         * reclaiming for a memcg, a priority drop can cause high
+         * latencies, so it's better to scan a minimum amount there as
+         * well.
+         */
        if (scanning_global_lru(sc) && current_is_kswapd())
                force_scan = true;
-        /* memcg may have small limit and need to avoid priority drop */
        if (!scanning_global_lru(sc))
                force_scan = true;
@@ -1810,8 +1885,6 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
                fraction[0] = 0;
                fraction[1] = 1;
                denominator = 1;
-                nr_force_scan[0] = 0;
-                nr_force_scan[1] = SWAP_CLUSTER_MAX;
                goto out;
        }
@@ -1828,8 +1901,6 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
                        fraction[0] = 1;
                        fraction[1] = 0;
                        denominator = 1;
-                        nr_force_scan[0] = SWAP_CLUSTER_MAX;
-                        nr_force_scan[1] = 0;
                        goto out;
                }
        }
@@ -1878,11 +1949,6 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
        fraction[0] = ap;
        fraction[1] = fp;
        denominator = ap + fp + 1;
-        if (force_scan) {
-                unsigned long scan = SWAP_CLUSTER_MAX;
-                nr_force_scan[0] = div64_u64(scan * ap, denominator);
-                nr_force_scan[1] = div64_u64(scan * fp, denominator);
-        }
 out:
        for_each_evictable_lru(l) {
                int file = is_file_lru(l);
@@ -1891,20 +1957,10 @@ out:
                scan = zone_nr_lru_pages(zone, sc, l);
                if (priority || noswap) {
                        scan >>= priority;
+                        if (!scan && force_scan)
+                                scan = SWAP_CLUSTER_MAX;
                        scan = div64_u64(scan * fraction[file], denominator);
                }
-                /*
-                 * If zone is small or memcg is small, nr[l] can be 0.
-                 * This results no-scan on this priority and priority drop down.
-                 * For global direct reclaim, it can visit next zone and tend
-                 * not to have problems. For global kswapd, it's for zone
-                 * balancing and it need to scan a small amounts. When using
-                 * memcg, priority drop can cause big latency. So, it's better
-                 * to scan small amount. See may_noscan above.
-                 */
-                if (!scan && force_scan)
-                        scan = nr_force_scan[file];
                nr[l] = scan;
        }
 }
@@ -1983,12 +2039,14 @@ static void shrink_zone(int priority, struct zone *zone,
        enum lru_list l;
        unsigned long nr_reclaimed, nr_scanned;
        unsigned long nr_to_reclaim = sc->nr_to_reclaim;
+        struct blk_plug plug;
 restart:
        nr_reclaimed = 0;
        nr_scanned = sc->nr_scanned;
        get_scan_count(zone, sc, nr, priority);
+        blk_start_plug(&plug);
        while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
                                        nr[LRU_INACTIVE_FILE]) {
                for_each_evictable_lru(l) {
@@ -2012,6 +2070,7 @@ restart:
                if (nr_reclaimed >= nr_to_reclaim && priority < DEF_PRIORITY)
                        break;
        }
+        blk_finish_plug(&plug);
        sc->nr_reclaimed += nr_reclaimed;
        /*
@@ -2044,14 +2103,19 @@ restart:
 *
 * If a zone is deemed to be full of pinned pages then just give it a light
 * scan then give up on it.
+ *
+ * This function returns true if a zone is being reclaimed for a costly
+ * high-order allocation and compaction is either ready to begin or deferred.
+ * This indicates to the caller that it should retry the allocation or fail.
 */
-static void shrink_zones(int priority, struct zonelist *zonelist,
+static bool shrink_zones(int priority, struct zonelist *zonelist,
                                        struct scan_control *sc)
 {
        struct zoneref *z;
        struct zone *zone;
        unsigned long nr_soft_reclaimed;
        unsigned long nr_soft_scanned;
+        bool should_abort_reclaim = false;
        for_each_zone_zonelist_nodemask(zone, z, zonelist,
                                        gfp_zone(sc->gfp_mask), sc->nodemask) {
@@ -2066,6 +2130,23 @@ static void shrink_zones(int priority, struct zonelist *zonelist,
                                continue;
                        if (zone->all_unreclaimable && priority != DEF_PRIORITY)
                                continue;       /* Let kswapd poll it */
+                        if (COMPACTION_BUILD) {
+                                /*
+                                 * If we already have plenty of memory free for
+                                 * compaction in this zone, don't free any more.
+                                 * Even though compaction is invoked for any
+                                 * non-zero order, only frequent costly order
+                                 * reclamation is disruptive enough to become a
+                                 * noticable problem, like transparent huge page
+                                 * allocations.
+                                 */
+                                if (sc->order > PAGE_ALLOC_COSTLY_ORDER &&
+                                        (compaction_suitable(zone, sc->order) ||
+                                         compaction_deferred(zone))) {
+                                        should_abort_reclaim = true;
+                                        continue;
+                                }
+                        }
                        /*
                         * This steals pages from memory cgroups over softlimit
                         * and returns the number of reclaimed pages and
@@ -2083,6 +2164,8 @@ static void shrink_zones(int priority, struct zonelist *zonelist,
                shrink_zone(priority, zone, sc);
        }
+        return should_abort_reclaim;
 }
 static bool zone_reclaimable(struct zone *zone)
@@ -2147,7 +2230,9 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
                sc->nr_scanned = 0;
                if (!priority)
                        disable_swap_token(sc->mem_cgroup);
-                shrink_zones(priority, zonelist, sc);
+                if (shrink_zones(priority, zonelist, sc))
+                        break;
                /*
                 * Don't shrink slabs when reclaiming memory from
                 * over limit cgroups
@@ -2690,6 +2775,8 @@ out:
                        /* If balanced, clear the congested flag */
                        zone_clear_flag(zone, ZONE_CONGESTED);
+                        if (i <= *classzone_idx)
+                                balanced += zone->present_pages;
                }
        }
@@ -2763,7 +2850,9 @@ static void kswapd_try_to_sleep(pg_data_t *pgdat, int order, int classzone_idx)
 static int kswapd(void *p)
 {
        unsigned long order, new_order;
+        unsigned balanced_order;
        int classzone_idx, new_classzone_idx;
+        int balanced_classzone_idx;
        pg_data_t *pgdat = (pg_data_t*)p;
        struct task_struct *tsk = current;
@@ -2794,7 +2883,9 @@ static int kswapd(void *p)
        set_freezable();
        order = new_order = 0;
+        balanced_order = 0;
        classzone_idx = new_classzone_idx = pgdat->nr_zones - 1;
+        balanced_classzone_idx = classzone_idx;
        for ( ; ; ) {
                int ret;
@@ -2803,7 +2894,8 @@ static int kswapd(void *p)
                 * new request of a similar or harder type will succeed soon
                 * so consider going to sleep on the basis we reclaimed at
                 */
-                if (classzone_idx >= new_classzone_idx && order == new_order) {
+                if (balanced_classzone_idx >= new_classzone_idx &&
+                                        balanced_order == new_order) {
                        new_order = pgdat->kswapd_max_order;
                        new_classzone_idx = pgdat->classzone_idx;
                        pgdat->kswapd_max_order =  0;
@@ -2818,9 +2910,12 @@ static int kswapd(void *p)
                        order = new_order;
                        classzone_idx = new_classzone_idx;
                } else {
-                        kswapd_try_to_sleep(pgdat, order, classzone_idx);
+                        kswapd_try_to_sleep(pgdat, balanced_order,
+                                                balanced_classzone_idx);
                        order = pgdat->kswapd_max_order;
                        classzone_idx = pgdat->classzone_idx;
+                        new_order = order;
+                        new_classzone_idx = classzone_idx;
                        pgdat->kswapd_max_order = 0;
                        pgdat->classzone_idx = pgdat->nr_zones - 1;
                }
@@ -2835,7 +2930,9 @@ static int kswapd(void *p)
                 */
                if (!ret) {
                        trace_mm_vmscan_kswapd_wake(pgdat->node_id, order);
-                        order = balance_pgdat(pgdat, order, &classzone_idx);
+                        balanced_classzone_idx = classzone_idx;
+                        balanced_order = balance_pgdat(pgdat, order,
+                                                &balanced_classzone_idx);
                }
        }
        return 0;
@@ -3347,66 +3444,12 @@ void scan_mapping_unevictable_pages(struct address_space *mapping)
 }
-/**
+static void warn_scan_unevictable_pages(void)
- * scan_zone_unevictable_pages - check unevictable list for evictable pages
- * @zone - zone of which to scan the unevictable list
- *
- * Scan @zone's unevictable LRU lists to check for pages that have become
- * evictable.  Move those that have to @zone's inactive list where they
- * become candidates for reclaim, unless shrink_inactive_zone() decides
- * to reactivate them.  Pages that are still unevictable are rotated
- * back onto @zone's unevictable list.
- */
-#define SCAN_UNEVICTABLE_BATCH_SIZE 16UL /* arbitrary lock hold batch size */
-static void scan_zone_unevictable_pages(struct zone *zone)
 {
-        struct list_head *l_unevictable = &zone->lru[LRU_UNEVICTABLE].list;
+        printk_once(KERN_WARNING
-        unsigned long scan;
+                    "The scan_unevictable_pages sysctl/node-interface has been "
-        unsigned long nr_to_scan = zone_page_state(zone, NR_UNEVICTABLE);
+                    "disabled for lack of a legitimate use case.  If you have "
+                    "one, please send an email to linux-mm@kvack.org.\n");
-        while (nr_to_scan > 0) {
-                unsigned long batch_size = min(nr_to_scan,
-                                                SCAN_UNEVICTABLE_BATCH_SIZE);
-                spin_lock_irq(&zone->lru_lock);
-                for (scan = 0;  scan < batch_size; scan++) {
-                        struct page *page = lru_to_page(l_unevictable);
-                        if (!trylock_page(page))
-                                continue;
-                        prefetchw_prev_lru_page(page, l_unevictable, flags);
-                        if (likely(PageLRU(page) && PageUnevictable(page)))
-                                check_move_unevictable_page(page, zone);
-                        unlock_page(page);
-                }
-                spin_unlock_irq(&zone->lru_lock);
-                nr_to_scan -= batch_size;
-        }
-}
-/**
- * scan_all_zones_unevictable_pages - scan all unevictable lists for evictable pages
- *
- * A really big hammer:  scan all zones' unevictable LRU lists to check for
- * pages that have become evictable.  Move those back to the zones'
- * inactive list where they become candidates for reclaim.
- * This occurs when, e.g., we have unswappable pages on the unevictable lists,
- * and we add swap to the system.  As such, it runs in the context of a task
- * that has possibly/probably made some previously unevictable pages
- * evictable.
- */
-static void scan_all_zones_unevictable_pages(void)
-{
-        struct zone *zone;
-        for_each_zone(zone) {
-                scan_zone_unevictable_pages(zone);
-        }
 }
 /*
@@ -3419,11 +3462,8 @@ int scan_unevictable_handler(struct ctl_table *table, int write,
                           void __user *buffer,
                           size_t *length, loff_t *ppos)
 {
+        warn_scan_unevictable_pages();
        proc_doulongvec_minmax(table, write, buffer, length, ppos);
-        if (write && *(unsigned long *)table->data)
-                scan_all_zones_unevictable_pages();
        scan_unevictable_pages = 0;
        return 0;
 }
@@ -3438,6 +3478,7 @@ static ssize_t read_scan_unevictable_node(struct sys_device *dev,
                                          struct sysdev_attribute *attr,
                                          char *buf)
 {
+        warn_scan_unevictable_pages();
        return sprintf(buf, "0\n");     /* always zero; should fit... */
 }
@@ -3445,19 +3486,7 @@ static ssize_t write_scan_unevictable_node(struct sys_device *dev,
                                           struct sysdev_attribute *attr,
                                        const char *buf, size_t count)
 {
-        struct zone *node_zones = NODE_DATA(dev->id)->node_zones;
+        warn_scan_unevictable_pages();
-        struct zone *zone;
-        unsigned long res;
-        unsigned long req = strict_strtoul(buf, 10, &res);
-        if (!req)
-                return 1;       /* zero is no-op */
-        for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
-                if (!populated_zone(zone))
-                        continue;
-                scan_zone_unevictable_pages(zone);
-        }
        return 1;
 }
diff --git a/mm/vmstat.c b/mm/vmstat.c
index d52b13d28e8f..8fd603b1665e 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -78,7 +78,7 @@ void vm_events_fold_cpu(int cpu)
 *
 * vm_stat contains the global counters
 */
-atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
+atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS] __cacheline_aligned_in_smp;
 EXPORT_SYMBOL(vm_stat);
 #ifdef CONFIG_SMP
@@ -702,6 +702,7 @@ const char * const vmstat_text[] = {
        "nr_unstable",
        "nr_bounce",
        "nr_vmscan_write",
+        "nr_vmscan_immediate_reclaim",
        "nr_writeback_temp",
        "nr_isolated_anon",
        "nr_isolated_file",
diff --git a/net/nfc/nfc.h b/net/nfc/nfc.h
index b6753f45624e..d86583f4831d 100644
--- a/net/nfc/nfc.h
+++ b/net/nfc/nfc.h
@@ -27,7 +27,7 @@
 #include <net/nfc/nfc.h>
 #include <net/sock.h>
-__attribute__((format (printf, 2, 3)))
+__printf(2, 3)
 int nfc_printk(const char *level, const char *fmt, ...);
 #define nfc_info(fmt, arg...) nfc_printk(KERN_INFO, fmt, ##arg)
diff --git a/net/rds/rds.h b/net/rds/rds.h
index da8adac2bf06..7eaba1831f0d 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -36,8 +36,8 @@
 #define rdsdebug(fmt, args...) pr_debug("%s(): " fmt, __func__ , ##args)
 #else
 /* sigh, pr_debug() causes unused variable warnings */
-static inline void __attribute__ ((format (printf, 1, 2)))
+static inline __printf(1, 2)
-rdsdebug(char *fmt, ...)
+void rdsdebug(char *fmt, ...)
 {
 }
 #endif
@@ -625,8 +625,8 @@ void rds_for_each_conn_info(struct socket *sock, unsigned int len,
                          struct rds_info_lengths *lens,
                          int (*visitor)(struct rds_connection *, void *),
                          size_t item_len);
-void __rds_conn_error(struct rds_connection *conn, const char *, ...)
+__printf(2, 3)
-                                __attribute__ ((format (printf, 2, 3)));
+void __rds_conn_error(struct rds_connection *conn, const char *, ...);
 #define rds_conn_error(conn, fmt...) \
        __rds_conn_error(conn, KERN_WARNING "RDS: " fmt)
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 30d70abb4e2c..dd5cc00ed559 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -971,9 +971,8 @@ static void svc_unregister(const struct svc_serv *serv)
 /*
 * Printk the given error with the address of the client that caused it.
 */
-static int
+static __printf(2, 3)
-__attribute__ ((format (printf, 2, 3)))
+int svc_printk(struct svc_rqst *rqstp, const char *fmt, ...)
-svc_printk(struct svc_rqst *rqstp, const char *fmt, ...)
 {
        va_list args;
        int     r;
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 0b3e35c9ef08..5e93342d22f9 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -240,9 +240,8 @@ our $NonptrType;
 our $Type;
 our $Declare;
-our $UTF8       = qr {
+our $NON_ASCII_UTF8     = qr{
-        [\x09\x0A\x0D\x20-\x7E]              # ASCII
+        [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
-        | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
        |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
        | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
        |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
@@ -251,6 +250,11 @@ our $UTF8	= qr {
        |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
 }x;
+our $UTF8       = qr{
+        [\x09\x0A\x0D\x20-\x7E]              # ASCII
+        | $NON_ASCII_UTF8
+}x;
 our $typeTypedefs = qr{(?x:
        (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
        atomic_t
@@ -1330,6 +1334,9 @@ sub process {
        my $signoff = 0;
        my $is_patch = 0;
+        my $in_header_lines = 1;
+        my $in_commit_log = 0;          #Scanning lines before patch
        our @report = ();
        our $cnt_lines = 0;
        our $cnt_error = 0;
@@ -1497,7 +1504,6 @@ sub process {
                if ($line =~ /^diff --git.*?(\S+)$/) {
                        $realfile = $1;
                        $realfile =~ s@^([^/]*)/@@;
                } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
                        $realfile = $1;
                        $realfile =~ s@^([^/]*)/@@;
@@ -1536,6 +1542,7 @@ sub process {
 # Check the patch for a signoff:
                if ($line =~ /^\s*signed-off-by:/i) {
                        $signoff++;
+                        $in_commit_log = 0;
                }
 # Check signature styles
@@ -1613,6 +1620,21 @@ sub process {
                            "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
                }
+# Check if it's the start of a commit log
+# (not a header line and we haven't seen the patch filename)
+                if ($in_header_lines && $realfile =~ /^$/ &&
+                    $rawline !~ /^(commit\b|from\b|\w+:).+$/i) {
+                        $in_header_lines = 0;
+                        $in_commit_log = 1;
+                }
+# Still not yet in a patch, check for any UTF-8
+                if ($in_commit_log && $realfile =~ /^$/ &&
+                    $rawline =~ /$NON_ASCII_UTF8/) {
+                        CHK("UTF8_BEFORE_PATCH",
+                            "8-bit UTF-8 used in possible commit log\n" . $herecurr);
+                }
 # ignore non-hunk lines and lines being removed
                next if (!$hunk_line || $line =~ /^-/);
@@ -3151,10 +3173,10 @@ sub process {
                             "consider using a completion\n" . $herecurr);
                }
-# recommend kstrto* over simple_strto*
+# recommend kstrto* over simple_strto* and strict_strto*
-                if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
+                if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
                        WARN("CONSIDER_KSTRTO",
-                             "consider using kstrto* in preference to simple_$1\n" . $herecurr);
+                             "$1 is obsolete, use k$3 instead\n" . $herecurr);
                }
 # check for __initcall(), use device_initcall() explicitly please
                if ($line =~ /^.\s*__initcall\s*\(/) {
diff --git a/security/keys/compat.c b/security/keys/compat.c
index 338b510e9027..4c48e13448f8 100644
--- a/security/keys/compat.c
+++ b/security/keys/compat.c
@@ -38,7 +38,7 @@ long compat_keyctl_instantiate_key_iov(
        ret = compat_rw_copy_check_uvector(WRITE, _payload_iov, ioc,
                                           ARRAY_SIZE(iovstack),
-                                           iovstack, &iov);
+                                           iovstack, &iov, 1);
        if (ret < 0)
                return ret;
        if (ret == 0)
diff --git a/security/keys/encrypted-keys/encrypted.c b/security/keys/encrypted-keys/encrypted.c
index f33804c1b4c8..dcc843cb0f80 100644
--- a/security/keys/encrypted-keys/encrypted.c
+++ b/security/keys/encrypted-keys/encrypted.c
@@ -293,7 +293,7 @@ static char *datablob_format(struct encrypted_key_payload *epayload,
        /* convert the hex encoded iv, encrypted-data and HMAC to ascii */
        bufp = &ascii_buf[len];
        for (i = 0; i < (asciiblob_len - len) / 2; i++)
-                bufp = pack_hex_byte(bufp, iv[i]);
+                bufp = hex_byte_pack(bufp, iv[i]);
 out:
        return ascii_buf;
 }
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index eca51918c951..0b3f5d72af1c 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -1065,7 +1065,7 @@ long keyctl_instantiate_key_iov(key_serial_t id,
                goto no_payload;
        ret = rw_copy_check_uvector(WRITE, _payload_iov, ioc,
-                                    ARRAY_SIZE(iovstack), iovstack, &iov);
+                                    ARRAY_SIZE(iovstack), iovstack, &iov, 1);
        if (ret < 0)
                return ret;
        if (ret == 0)
diff --git a/security/keys/trusted.c b/security/keys/trusted.c
index 0964fc236946..0ed5fdf238a2 100644
--- a/security/keys/trusted.c
+++ b/security/keys/trusted.c
@@ -1098,7 +1098,7 @@ static long trusted_read(const struct key *key, char __user *buffer,
        bufp = ascii_buf;
        for (i = 0; i < p->blob_len; i++)
-                bufp = pack_hex_byte(bufp, p->blob[i]);
+                bufp = hex_byte_pack(bufp, p->blob[i]);
        if ((copy_to_user(buffer, ascii_buf, 2 * p->blob_len)) != 0) {
                kfree(ascii_buf);
                return -EFAULT;
diff --git a/sound/firewire/cmp.c b/sound/firewire/cmp.c
index 14cacbc655dd..76294f2ae47f 100644
--- a/sound/firewire/cmp.c
+++ b/sound/firewire/cmp.c
@@ -32,7 +32,7 @@ enum bus_reset_handling {
        SUCCEED_ON_BUS_RESET,
 };
-static __attribute__((format(printf, 2, 3)))
+static __printf(2, 3)
 void cmp_error(struct cmp_connection *c, const char *fmt, ...)
 {
        va_list va;