From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id C1299138334 for ; Thu, 5 Dec 2019 15:17:09 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 9A5E4E0898; Thu, 5 Dec 2019 15:17:07 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 6911EE0898 for ; Thu, 5 Dec 2019 15:17:07 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id DD7C034D80A for ; Thu, 5 Dec 2019 15:17:05 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id B2B9E2A5 for ; Thu, 5 Dec 2019 15:17:03 +0000 (UTC) From: "Alice Ferrazzi" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Alice Ferrazzi" Message-ID: <1575558962.4f401f0d67bf9ea50c8d9ebc772844fd26b4e99d.alicef@gentoo> Subject: [gentoo-commits] proj/linux-patches:4.9 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1205_linux-4.9.206.patch X-VCS-Directories: / X-VCS-Committer: alicef X-VCS-Committer-Name: Alice Ferrazzi X-VCS-Revision: 4f401f0d67bf9ea50c8d9ebc772844fd26b4e99d X-VCS-Branch: 4.9 Date: Thu, 5 Dec 2019 15:17:03 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 1f2a3923-4ab8-41ee-8832-5f888b856099 X-Archives-Hash: a5aef92c758899b66138613b8a3891ae commit: 4f401f0d67bf9ea50c8d9ebc772844fd26b4e99d Author: Alice Ferrazzi gentoo org> AuthorDate: Thu Dec 5 15:16:02 2019 +0000 Commit: Alice Ferrazzi gentoo org> CommitDate: Thu Dec 5 15:16:02 2019 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=4f401f0d Linux patch 4.9.206 Signed-off-by: Alice Ferrazzi gentoo.org> 0000_README | 8 + 1205_linux-4.9.206.patch | 3543 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 3551 insertions(+) diff --git a/0000_README b/0000_README index 88b037e..d192ca8 100644 --- a/0000_README +++ b/0000_README @@ -859,6 +859,14 @@ Patch: 1203_linux-4.9.204.patch From: http://www.kernel.org Desc: Linux 4.9.204 +Patch: 1204_linux-4.9.205.patch +From: http://www.kernel.org +Desc: Linux 4.9.204 + +Patch: 1205_linux-4.9.206.patch +From: http://www.kernel.org +Desc: Linux 4.9.204 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1205_linux-4.9.206.patch b/1205_linux-4.9.206.patch new file mode 100644 index 0000000..1304b1a --- /dev/null +++ b/1205_linux-4.9.206.patch @@ -0,0 +1,3543 @@ +diff --git a/Documentation/hid/uhid.txt b/Documentation/hid/uhid.txt +index c8656dd029a9..958fff945304 100644 +--- a/Documentation/hid/uhid.txt ++++ b/Documentation/hid/uhid.txt +@@ -160,7 +160,7 @@ them but you should handle them according to your needs. + UHID_OUTPUT: + This is sent if the HID device driver wants to send raw data to the I/O + device on the interrupt channel. You should read the payload and forward it to +- the device. The payload is of type "struct uhid_data_req". ++ the device. The payload is of type "struct uhid_output_req". + This may be received even though you haven't received UHID_OPEN, yet. + + UHID_GET_REPORT: +diff --git a/Makefile b/Makefile +index fc1a58ef7e56..55a91bc3d8f9 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 9 +-SUBLEVEL = 205 ++SUBLEVEL = 206 + EXTRAVERSION = + NAME = Roaring Lionus + +diff --git a/arch/arm/Kconfig.debug b/arch/arm/Kconfig.debug +index d83f7c369e51..a5625430bef6 100644 +--- a/arch/arm/Kconfig.debug ++++ b/arch/arm/Kconfig.debug +@@ -1340,21 +1340,21 @@ config DEBUG_OMAP2PLUS_UART + depends on ARCH_OMAP2PLUS + + config DEBUG_IMX_UART_PORT +- int "i.MX Debug UART Port Selection" if DEBUG_IMX1_UART || \ +- DEBUG_IMX25_UART || \ +- DEBUG_IMX21_IMX27_UART || \ +- DEBUG_IMX31_UART || \ +- DEBUG_IMX35_UART || \ +- DEBUG_IMX50_UART || \ +- DEBUG_IMX51_UART || \ +- DEBUG_IMX53_UART || \ +- DEBUG_IMX6Q_UART || \ +- DEBUG_IMX6SL_UART || \ +- DEBUG_IMX6SX_UART || \ +- DEBUG_IMX6UL_UART || \ +- DEBUG_IMX7D_UART ++ int "i.MX Debug UART Port Selection" ++ depends on DEBUG_IMX1_UART || \ ++ DEBUG_IMX25_UART || \ ++ DEBUG_IMX21_IMX27_UART || \ ++ DEBUG_IMX31_UART || \ ++ DEBUG_IMX35_UART || \ ++ DEBUG_IMX50_UART || \ ++ DEBUG_IMX51_UART || \ ++ DEBUG_IMX53_UART || \ ++ DEBUG_IMX6Q_UART || \ ++ DEBUG_IMX6SL_UART || \ ++ DEBUG_IMX6SX_UART || \ ++ DEBUG_IMX6UL_UART || \ ++ DEBUG_IMX7D_UART + default 1 +- depends on ARCH_MXC + help + Choose UART port on which kernel low-level debug messages + should be output. +diff --git a/arch/arm/boot/dts/imx53-voipac-dmm-668.dtsi b/arch/arm/boot/dts/imx53-voipac-dmm-668.dtsi +index ba689fbd0e41..301cf8d45947 100644 +--- a/arch/arm/boot/dts/imx53-voipac-dmm-668.dtsi ++++ b/arch/arm/boot/dts/imx53-voipac-dmm-668.dtsi +@@ -17,12 +17,8 @@ + + memory@70000000 { + device_type = "memory"; +- reg = <0x70000000 0x20000000>; +- }; +- +- memory@b0000000 { +- device_type = "memory"; +- reg = <0xb0000000 0x20000000>; ++ reg = <0x70000000 0x20000000>, ++ <0xb0000000 0x20000000>; + }; + + regulators { +diff --git a/arch/arm/mach-ks8695/board-acs5k.c b/arch/arm/mach-ks8695/board-acs5k.c +index e4d709c8ed32..76d3083f1f63 100644 +--- a/arch/arm/mach-ks8695/board-acs5k.c ++++ b/arch/arm/mach-ks8695/board-acs5k.c +@@ -92,7 +92,7 @@ static struct i2c_board_info acs5k_i2c_devs[] __initdata = { + }, + }; + +-static void acs5k_i2c_init(void) ++static void __init acs5k_i2c_init(void) + { + /* The gpio interface */ + platform_device_register(&acs5k_i2c_device); +diff --git a/arch/arm64/kernel/head.S b/arch/arm64/kernel/head.S +index db6ff1944c41..3b10b9395960 100644 +--- a/arch/arm64/kernel/head.S ++++ b/arch/arm64/kernel/head.S +@@ -686,6 +686,7 @@ secondary_startup: + /* + * Common entry point for secondary CPUs. + */ ++ bl __cpu_secondary_check52bitva + bl __cpu_setup // initialise processor + bl __enable_mmu + ldr x8, =__secondary_switched +@@ -759,6 +760,31 @@ ENTRY(__enable_mmu) + ret + ENDPROC(__enable_mmu) + ++ENTRY(__cpu_secondary_check52bitva) ++#ifdef CONFIG_ARM64_52BIT_VA ++ ldr_l x0, vabits_user ++ cmp x0, #52 ++ b.ne 2f ++ ++ mrs_s x0, SYS_ID_AA64MMFR2_EL1 ++ and x0, x0, #(0xf << ID_AA64MMFR2_LVA_SHIFT) ++ cbnz x0, 2f ++ ++ adr_l x0, va52mismatch ++ mov w1, #1 ++ strb w1, [x0] ++ dmb sy ++ dc ivac, x0 // Invalidate potentially stale cache line ++ ++ update_early_cpu_boot_status CPU_STUCK_IN_KERNEL, x0, x1 ++1: wfe ++ wfi ++ b 1b ++ ++#endif ++2: ret ++ENDPROC(__cpu_secondary_check52bitva) ++ + __no_granule_support: + /* Indicate that this CPU can't boot and is stuck in the kernel */ + update_early_cpu_boot_status CPU_STUCK_IN_KERNEL, x1, x2 +diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c +index cfd33f18f437..b2d6de9f6f4f 100644 +--- a/arch/arm64/kernel/smp.c ++++ b/arch/arm64/kernel/smp.c +@@ -136,6 +136,7 @@ static int boot_secondary(unsigned int cpu, struct task_struct *idle) + } + + static DECLARE_COMPLETION(cpu_running); ++bool va52mismatch __ro_after_init; + + int __cpu_up(unsigned int cpu, struct task_struct *idle) + { +@@ -164,10 +165,15 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle) + + if (!cpu_online(cpu)) { + pr_crit("CPU%u: failed to come online\n", cpu); ++ ++ if (IS_ENABLED(CONFIG_ARM64_52BIT_VA) && va52mismatch) ++ pr_crit("CPU%u: does not support 52-bit VAs\n", cpu); ++ + ret = -EIO; + } + } else { + pr_err("CPU%u: failed to boot: %d\n", cpu, ret); ++ return ret; + } + + secondary_data.stack = NULL; +diff --git a/arch/microblaze/Makefile b/arch/microblaze/Makefile +index 740f2b82a182..491676a6cde5 100644 +--- a/arch/microblaze/Makefile ++++ b/arch/microblaze/Makefile +@@ -75,19 +75,21 @@ archclean: + + linux.bin linux.bin.gz linux.bin.ub: vmlinux + $(Q)$(MAKE) $(build)=$(boot) $(boot)/$@ ++ @echo 'Kernel: $(boot)/$@ is ready' ' (#'`cat .version`')' + + simpleImage.%: vmlinux + $(Q)$(MAKE) $(build)=$(boot) $(boot)/$@ ++ @echo 'Kernel: $(boot)/$@ is ready' ' (#'`cat .version`')' + + define archhelp + echo '* linux.bin - Create raw binary' + echo ' linux.bin.gz - Create compressed raw binary' + echo ' linux.bin.ub - Create U-Boot wrapped raw binary' +- echo ' simpleImage.
- ELF image with $(arch)/boot/dts/
.dts linked in' +- echo ' - stripped elf with fdt blob' +- echo ' simpleImage.
.unstrip - full ELF image with fdt blob' +- echo ' *_defconfig - Select default config from arch/microblaze/configs' +- echo '' ++ echo ' simpleImage.
- Create the following images with
.dtb linked in' ++ echo ' simpleImage.
: raw image' ++ echo ' simpleImage.
.ub : raw image with U-Boot header' ++ echo ' simpleImage.
.unstrip: ELF (identical to vmlinux)' ++ echo ' simpleImage.
.strip : stripped ELF' + echo ' Targets with
embed a device tree blob inside the image' + echo ' These targets support board with firmware that does not' + echo ' support passing a device tree directly. Replace
with the' +diff --git a/arch/microblaze/boot/Makefile b/arch/microblaze/boot/Makefile +index 0f3fe6a151dc..22bed08ec7f2 100644 +--- a/arch/microblaze/boot/Makefile ++++ b/arch/microblaze/boot/Makefile +@@ -8,15 +8,12 @@ OBJCOPYFLAGS := -R .note -R .comment -R .note.gnu.build-id -O binary + + $(obj)/linux.bin: vmlinux FORCE + $(call if_changed,objcopy) +- @echo 'Kernel: $@ is ready' ' (#'`cat .version`')' + + $(obj)/linux.bin.ub: $(obj)/linux.bin FORCE + $(call if_changed,uimage) +- @echo 'Kernel: $@ is ready' ' (#'`cat .version`')' + + $(obj)/linux.bin.gz: $(obj)/linux.bin FORCE + $(call if_changed,gzip) +- @echo 'Kernel: $@ is ready' ' (#'`cat .version`')' + + quiet_cmd_cp = CP $< $@$2 + cmd_cp = cat $< >$@$2 || (rm -f $@ && echo false) +@@ -34,6 +31,5 @@ $(obj)/simpleImage.%: vmlinux FORCE + $(call if_changed,objcopy) + $(call if_changed,uimage) + $(call if_changed,strip,.strip) +- @echo 'Kernel: $(UIMAGE_OUT) is ready' ' (#'`cat .version`')' + + clean-files += simpleImage.*.unstrip linux.bin.ub dts/*.dtb +diff --git a/arch/openrisc/kernel/entry.S b/arch/openrisc/kernel/entry.S +index fec8bf97d806..c17e8451d997 100644 +--- a/arch/openrisc/kernel/entry.S ++++ b/arch/openrisc/kernel/entry.S +@@ -179,7 +179,7 @@ handler: ;\ + * occured. in fact they never do. if you need them use + * values saved on stack (for SPR_EPC, SPR_ESR) or content + * of r4 (for SPR_EEAR). for details look at EXCEPTION_HANDLE() +- * in 'arch/or32/kernel/head.S' ++ * in 'arch/openrisc/kernel/head.S' + */ + + /* =====================================================[ exceptions] === */ +diff --git a/arch/openrisc/kernel/head.S b/arch/openrisc/kernel/head.S +index f14793306b03..98dd6860bc0b 100644 +--- a/arch/openrisc/kernel/head.S ++++ b/arch/openrisc/kernel/head.S +@@ -1596,7 +1596,7 @@ _string_esr_irq_bug: + + /* + * .data section should be page aligned +- * (look into arch/or32/kernel/vmlinux.lds) ++ * (look into arch/openrisc/kernel/vmlinux.lds.S) + */ + .section .data,"aw" + .align 8192 +diff --git a/arch/powerpc/boot/dts/bamboo.dts b/arch/powerpc/boot/dts/bamboo.dts +index aa68911f6560..084b82ba7493 100644 +--- a/arch/powerpc/boot/dts/bamboo.dts ++++ b/arch/powerpc/boot/dts/bamboo.dts +@@ -268,8 +268,10 @@ + /* Outbound ranges, one memory and one IO, + * later cannot be changed. Chip supports a second + * IO range but we don't use it for now ++ * The chip also supports a larger memory range but ++ * it's not naturally aligned, so our code will break + */ +- ranges = <0x02000000 0x00000000 0xa0000000 0x00000000 0xa0000000 0x00000000 0x40000000 ++ ranges = <0x02000000 0x00000000 0xa0000000 0x00000000 0xa0000000 0x00000000 0x20000000 + 0x02000000 0x00000000 0x00000000 0x00000000 0xe0000000 0x00000000 0x00100000 + 0x01000000 0x00000000 0x00000000 0x00000000 0xe8000000 0x00000000 0x00010000>; + +diff --git a/arch/powerpc/include/asm/cputable.h b/arch/powerpc/include/asm/cputable.h +index 4e54282c29b4..cf51aea47510 100644 +--- a/arch/powerpc/include/asm/cputable.h ++++ b/arch/powerpc/include/asm/cputable.h +@@ -44,6 +44,7 @@ extern int machine_check_e500(struct pt_regs *regs); + extern int machine_check_e200(struct pt_regs *regs); + extern int machine_check_47x(struct pt_regs *regs); + int machine_check_8xx(struct pt_regs *regs); ++int machine_check_83xx(struct pt_regs *regs); + + extern void cpu_down_flush_e500v2(void); + extern void cpu_down_flush_e500mc(void); +diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h +index ceb168cd3b81..26aeeaad3267 100644 +--- a/arch/powerpc/include/asm/reg.h ++++ b/arch/powerpc/include/asm/reg.h +@@ -663,6 +663,8 @@ + #define SRR1_PROGTRAP 0x00020000 /* Trap */ + #define SRR1_PROGADDR 0x00010000 /* SRR0 contains subsequent addr */ + ++#define SRR1_MCE_MCP 0x00080000 /* Machine check signal caused interrupt */ ++ + #define SPRN_HSRR0 0x13A /* Save/Restore Register 0 */ + #define SPRN_HSRR1 0x13B /* Save/Restore Register 1 */ + #define HSRR1_DENORM 0x00100000 /* Denorm exception */ +diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c +index 6a82ef039c50..7471ed48f41f 100644 +--- a/arch/powerpc/kernel/cputable.c ++++ b/arch/powerpc/kernel/cputable.c +@@ -1162,6 +1162,7 @@ static struct cpu_spec __initdata cpu_specs[] = { + .machine_check = machine_check_generic, + .platform = "ppc603", + }, ++#ifdef CONFIG_PPC_83xx + { /* e300c1 (a 603e core, plus some) on 83xx */ + .pvr_mask = 0x7fff0000, + .pvr_value = 0x00830000, +@@ -1172,7 +1173,7 @@ static struct cpu_spec __initdata cpu_specs[] = { + .icache_bsize = 32, + .dcache_bsize = 32, + .cpu_setup = __setup_cpu_603, +- .machine_check = machine_check_generic, ++ .machine_check = machine_check_83xx, + .platform = "ppc603", + }, + { /* e300c2 (an e300c1 core, plus some, minus FPU) on 83xx */ +@@ -1186,7 +1187,7 @@ static struct cpu_spec __initdata cpu_specs[] = { + .icache_bsize = 32, + .dcache_bsize = 32, + .cpu_setup = __setup_cpu_603, +- .machine_check = machine_check_generic, ++ .machine_check = machine_check_83xx, + .platform = "ppc603", + }, + { /* e300c3 (e300c1, plus one IU, half cache size) on 83xx */ +@@ -1200,7 +1201,7 @@ static struct cpu_spec __initdata cpu_specs[] = { + .icache_bsize = 32, + .dcache_bsize = 32, + .cpu_setup = __setup_cpu_603, +- .machine_check = machine_check_generic, ++ .machine_check = machine_check_83xx, + .num_pmcs = 4, + .oprofile_cpu_type = "ppc/e300", + .oprofile_type = PPC_OPROFILE_FSL_EMB, +@@ -1217,12 +1218,13 @@ static struct cpu_spec __initdata cpu_specs[] = { + .icache_bsize = 32, + .dcache_bsize = 32, + .cpu_setup = __setup_cpu_603, +- .machine_check = machine_check_generic, ++ .machine_check = machine_check_83xx, + .num_pmcs = 4, + .oprofile_cpu_type = "ppc/e300", + .oprofile_type = PPC_OPROFILE_FSL_EMB, + .platform = "ppc603", + }, ++#endif + { /* default match, we assume split I/D cache & TB (non-601)... */ + .pvr_mask = 0x00000000, + .pvr_value = 0x00000000, +diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c +index b0245bed6f54..b868f07c4246 100644 +--- a/arch/powerpc/kernel/prom.c ++++ b/arch/powerpc/kernel/prom.c +@@ -128,7 +128,7 @@ static void __init move_device_tree(void) + p = __va(memblock_alloc(size, PAGE_SIZE)); + memcpy(p, initial_boot_params, size); + initial_boot_params = p; +- DBG("Moved device tree to 0x%p\n", p); ++ DBG("Moved device tree to 0x%px\n", p); + } + + DBG("<- move_device_tree\n"); +@@ -651,7 +651,7 @@ void __init early_init_devtree(void *params) + { + phys_addr_t limit; + +- DBG(" -> early_init_devtree(%p)\n", params); ++ DBG(" -> early_init_devtree(%px)\n", params); + + /* Too early to BUG_ON(), do it by hand */ + if (!early_init_dt_verify(params)) +@@ -711,7 +711,7 @@ void __init early_init_devtree(void *params) + memblock_allow_resize(); + memblock_dump_all(); + +- DBG("Phys. mem: %llx\n", memblock_phys_mem_size()); ++ DBG("Phys. mem: %llx\n", (unsigned long long)memblock_phys_mem_size()); + + /* We may need to relocate the flat tree, do it now. + * FIXME .. and the initrd too? */ +diff --git a/arch/powerpc/mm/fault.c b/arch/powerpc/mm/fault.c +index 9376e8e53bfa..2791f568bdb2 100644 +--- a/arch/powerpc/mm/fault.c ++++ b/arch/powerpc/mm/fault.c +@@ -521,21 +521,22 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) + switch (regs->trap) { + case 0x300: + case 0x380: +- printk(KERN_ALERT "Unable to handle kernel paging request for " +- "data at address 0x%08lx\n", regs->dar); ++ pr_alert("BUG: %s at 0x%08lx\n", ++ regs->dar < PAGE_SIZE ? "Kernel NULL pointer dereference" : ++ "Unable to handle kernel data access", regs->dar); + break; + case 0x400: + case 0x480: +- printk(KERN_ALERT "Unable to handle kernel paging request for " +- "instruction fetch\n"); ++ pr_alert("BUG: Unable to handle kernel instruction fetch%s", ++ regs->nip < PAGE_SIZE ? " (NULL pointer?)\n" : "\n"); + break; + case 0x600: +- printk(KERN_ALERT "Unable to handle kernel paging request for " +- "unaligned access at address 0x%08lx\n", regs->dar); ++ pr_alert("BUG: Unable to handle kernel unaligned access at 0x%08lx\n", ++ regs->dar); + break; + default: +- printk(KERN_ALERT "Unable to handle kernel paging request for " +- "unknown fault\n"); ++ pr_alert("BUG: Unable to handle unknown paging fault at 0x%08lx\n", ++ regs->dar); + break; + } + printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n", +diff --git a/arch/powerpc/mm/ppc_mmu_32.c b/arch/powerpc/mm/ppc_mmu_32.c +index 2a049fb8523d..96c52271e9c2 100644 +--- a/arch/powerpc/mm/ppc_mmu_32.c ++++ b/arch/powerpc/mm/ppc_mmu_32.c +@@ -52,7 +52,7 @@ struct batrange { /* stores address ranges mapped by BATs */ + phys_addr_t v_block_mapped(unsigned long va) + { + int b; +- for (b = 0; b < 4; ++b) ++ for (b = 0; b < ARRAY_SIZE(bat_addrs); ++b) + if (va >= bat_addrs[b].start && va < bat_addrs[b].limit) + return bat_addrs[b].phys + (va - bat_addrs[b].start); + return 0; +@@ -64,7 +64,7 @@ phys_addr_t v_block_mapped(unsigned long va) + unsigned long p_block_mapped(phys_addr_t pa) + { + int b; +- for (b = 0; b < 4; ++b) ++ for (b = 0; b < ARRAY_SIZE(bat_addrs); ++b) + if (pa >= bat_addrs[b].phys + && pa < (bat_addrs[b].limit-bat_addrs[b].start) + +bat_addrs[b].phys) +diff --git a/arch/powerpc/platforms/83xx/misc.c b/arch/powerpc/platforms/83xx/misc.c +index d75c9816a5c9..2b6589fe812d 100644 +--- a/arch/powerpc/platforms/83xx/misc.c ++++ b/arch/powerpc/platforms/83xx/misc.c +@@ -14,6 +14,7 @@ + #include + #include + ++#include + #include + #include + #include +@@ -150,3 +151,19 @@ void __init mpc83xx_setup_arch(void) + + mpc83xx_setup_pci(); + } ++ ++int machine_check_83xx(struct pt_regs *regs) ++{ ++ u32 mask = 1 << (31 - IPIC_MCP_WDT); ++ ++ if (!(regs->msr & SRR1_MCE_MCP) || !(ipic_get_mcp_status() & mask)) ++ return machine_check_generic(regs); ++ ipic_clear_mcp_status(mask); ++ ++ if (debugger_fault_handler(regs)) ++ return 1; ++ ++ die("Watchdog NMI Reset", regs, 0); ++ ++ return 1; ++} +diff --git a/arch/powerpc/platforms/powernv/eeh-powernv.c b/arch/powerpc/platforms/powernv/eeh-powernv.c +index 2354ea51e871..6189c4cf56c3 100644 +--- a/arch/powerpc/platforms/powernv/eeh-powernv.c ++++ b/arch/powerpc/platforms/powernv/eeh-powernv.c +@@ -546,8 +546,8 @@ static void pnv_eeh_get_phb_diag(struct eeh_pe *pe) + static int pnv_eeh_get_phb_state(struct eeh_pe *pe) + { + struct pnv_phb *phb = pe->phb->private_data; +- u8 fstate; +- __be16 pcierr; ++ u8 fstate = 0; ++ __be16 pcierr = 0; + s64 rc; + int result = 0; + +@@ -585,8 +585,8 @@ static int pnv_eeh_get_phb_state(struct eeh_pe *pe) + static int pnv_eeh_get_pe_state(struct eeh_pe *pe) + { + struct pnv_phb *phb = pe->phb->private_data; +- u8 fstate; +- __be16 pcierr; ++ u8 fstate = 0; ++ __be16 pcierr = 0; + s64 rc; + int result; + +diff --git a/arch/powerpc/platforms/powernv/pci-ioda.c b/arch/powerpc/platforms/powernv/pci-ioda.c +index 8015e40bc7ee..3ec673b4ca6c 100644 +--- a/arch/powerpc/platforms/powernv/pci-ioda.c ++++ b/arch/powerpc/platforms/powernv/pci-ioda.c +@@ -599,8 +599,8 @@ static int pnv_ioda_unfreeze_pe(struct pnv_phb *phb, int pe_no, int opt) + static int pnv_ioda_get_pe_state(struct pnv_phb *phb, int pe_no) + { + struct pnv_ioda_pe *slave, *pe; +- u8 fstate, state; +- __be16 pcierr; ++ u8 fstate = 0, state; ++ __be16 pcierr = 0; + s64 rc; + + /* Sanity check on PE number */ +diff --git a/arch/powerpc/platforms/powernv/pci.c b/arch/powerpc/platforms/powernv/pci.c +index db7b8020f68e..98cc8ba07c23 100644 +--- a/arch/powerpc/platforms/powernv/pci.c ++++ b/arch/powerpc/platforms/powernv/pci.c +@@ -482,8 +482,8 @@ static void pnv_pci_handle_eeh_config(struct pnv_phb *phb, u32 pe_no) + static void pnv_pci_config_check_eeh(struct pci_dn *pdn) + { + struct pnv_phb *phb = pdn->phb->private_data; +- u8 fstate; +- __be16 pcierr; ++ u8 fstate = 0; ++ __be16 pcierr = 0; + unsigned int pe_no; + s64 rc; + +diff --git a/arch/powerpc/platforms/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c +index 999b04819d69..5abb8e2239a5 100644 +--- a/arch/powerpc/platforms/pseries/dlpar.c ++++ b/arch/powerpc/platforms/pseries/dlpar.c +@@ -63,6 +63,10 @@ static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa) + + name = (char *)ccwa + be32_to_cpu(ccwa->name_offset); + prop->name = kstrdup(name, GFP_KERNEL); ++ if (!prop->name) { ++ dlpar_free_cc_property(prop); ++ return NULL; ++ } + + prop->length = be32_to_cpu(ccwa->prop_length); + value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset); +diff --git a/arch/powerpc/platforms/pseries/hotplug-memory.c b/arch/powerpc/platforms/pseries/hotplug-memory.c +index 656bbbd731d0..6c12b02f4a61 100644 +--- a/arch/powerpc/platforms/pseries/hotplug-memory.c ++++ b/arch/powerpc/platforms/pseries/hotplug-memory.c +@@ -294,6 +294,7 @@ static u32 lookup_lmb_associativity_index(struct of_drconf_cell *lmb) + + aa_index = find_aa_index(dr_node, ala_prop, lmb_assoc); + ++ of_node_put(dr_node); + dlpar_free_cc_nodes(lmb_node); + return aa_index; + } +diff --git a/arch/powerpc/xmon/xmon.c b/arch/powerpc/xmon/xmon.c +index 687e8b8bf5c6..899288b71145 100644 +--- a/arch/powerpc/xmon/xmon.c ++++ b/arch/powerpc/xmon/xmon.c +@@ -3043,7 +3043,7 @@ void dump_segments(void) + + printf("sr0-15 ="); + for (i = 0; i < 16; ++i) +- printf(" %x", mfsrin(i)); ++ printf(" %x", mfsrin(i << 28)); + printf("\n"); + } + #endif +diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c +index 37c254677ccd..d8fd2eadcda7 100644 +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -319,19 +319,30 @@ static void kvm_s390_cpu_feat_init(void) + + int kvm_arch_init(void *opaque) + { ++ int rc; ++ + kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long)); + if (!kvm_s390_dbf) + return -ENOMEM; + + if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) { +- debug_unregister(kvm_s390_dbf); +- return -ENOMEM; ++ rc = -ENOMEM; ++ goto out_debug_unreg; + } + + kvm_s390_cpu_feat_init(); + + /* Register floating interrupt controller interface. */ +- return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); ++ rc = kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC); ++ if (rc) { ++ pr_err("Failed to register FLIC rc=%d\n", rc); ++ goto out_debug_unreg; ++ } ++ return 0; ++ ++out_debug_unreg: ++ debug_unregister(kvm_s390_dbf); ++ return rc; + } + + void kvm_arch_exit(void) +diff --git a/arch/s390/mm/gup.c b/arch/s390/mm/gup.c +index 97fc449a7470..cf045f56581e 100644 +--- a/arch/s390/mm/gup.c ++++ b/arch/s390/mm/gup.c +@@ -38,7 +38,8 @@ static inline int gup_pte_range(pmd_t *pmdp, pmd_t pmd, unsigned long addr, + VM_BUG_ON(!pfn_valid(pte_pfn(pte))); + page = pte_page(pte); + head = compound_head(page); +- if (!page_cache_get_speculative(head)) ++ if (WARN_ON_ONCE(page_ref_count(head) < 0) ++ || !page_cache_get_speculative(head)) + return 0; + if (unlikely(pte_val(pte) != pte_val(*ptep))) { + put_page(head); +@@ -76,7 +77,8 @@ static inline int gup_huge_pmd(pmd_t *pmdp, pmd_t pmd, unsigned long addr, + refs++; + } while (addr += PAGE_SIZE, addr != end); + +- if (!page_cache_add_speculative(head, refs)) { ++ if (WARN_ON_ONCE(page_ref_count(head) < 0) ++ || !page_cache_add_speculative(head, refs)) { + *nr -= refs; + return 0; + } +@@ -150,7 +152,8 @@ static int gup_huge_pud(pud_t *pudp, pud_t pud, unsigned long addr, + refs++; + } while (addr += PAGE_SIZE, addr != end); + +- if (!page_cache_add_speculative(head, refs)) { ++ if (WARN_ON_ONCE(page_ref_count(head) < 0) ++ || !page_cache_add_speculative(head, refs)) { + *nr -= refs; + return 0; + } +diff --git a/arch/um/Kconfig.debug b/arch/um/Kconfig.debug +index 68205fd3b08c..6ae7f0f434a9 100644 +--- a/arch/um/Kconfig.debug ++++ b/arch/um/Kconfig.debug +@@ -18,6 +18,7 @@ config GPROF + config GCOV + bool "Enable gcov support" + depends on DEBUG_INFO ++ depends on !KCOV + help + This option allows developers to retrieve coverage data from a UML + session. +diff --git a/arch/x86/mm/gup.c b/arch/x86/mm/gup.c +index d7db45bdfb3b..82f727fbbbd2 100644 +--- a/arch/x86/mm/gup.c ++++ b/arch/x86/mm/gup.c +@@ -202,9 +202,12 @@ static int __gup_device_huge_pmd(pmd_t pmd, unsigned long addr, + undo_dev_pagemap(nr, nr_start, pages); + return 0; + } ++ if (unlikely(!try_get_page(page))) { ++ put_dev_pagemap(pgmap); ++ return 0; ++ } + SetPageReferenced(page); + pages[*nr] = page; +- get_page(page); + put_dev_pagemap(pgmap); + (*nr)++; + pfn++; +@@ -230,6 +233,8 @@ static noinline int gup_huge_pmd(pmd_t pmd, unsigned long addr, + + refs = 0; + head = pmd_page(pmd); ++ if (WARN_ON_ONCE(page_ref_count(head) <= 0)) ++ return 0; + page = head + ((addr & ~PMD_MASK) >> PAGE_SHIFT); + do { + VM_BUG_ON_PAGE(compound_head(page) != head, page); +@@ -289,6 +294,8 @@ static noinline int gup_huge_pud(pud_t pud, unsigned long addr, + + refs = 0; + head = pud_page(pud); ++ if (WARN_ON_ONCE(page_ref_count(head) <= 0)) ++ return 0; + page = head + ((addr & ~PUD_MASK) >> PAGE_SHIFT); + do { + VM_BUG_ON_PAGE(compound_head(page) != head, page); +diff --git a/crypto/crypto_user.c b/crypto/crypto_user.c +index c90a1727cd2c..60cf7d163731 100644 +--- a/crypto/crypto_user.c ++++ b/crypto/crypto_user.c +@@ -277,30 +277,33 @@ drop_alg: + + static int crypto_dump_report(struct sk_buff *skb, struct netlink_callback *cb) + { +- struct crypto_alg *alg; ++ const size_t start_pos = cb->args[0]; ++ size_t pos = 0; + struct crypto_dump_info info; +- int err; +- +- if (cb->args[0]) +- goto out; +- +- cb->args[0] = 1; ++ struct crypto_alg *alg; ++ int res; + + info.in_skb = cb->skb; + info.out_skb = skb; + info.nlmsg_seq = cb->nlh->nlmsg_seq; + info.nlmsg_flags = NLM_F_MULTI; + ++ down_read(&crypto_alg_sem); + list_for_each_entry(alg, &crypto_alg_list, cra_list) { +- err = crypto_report_alg(alg, &info); +- if (err) +- goto out_err; ++ if (pos >= start_pos) { ++ res = crypto_report_alg(alg, &info); ++ if (res == -EMSGSIZE) ++ break; ++ if (res) ++ goto out; ++ } ++ pos++; + } +- ++ cb->args[0] = pos; ++ res = skb->len; + out: +- return skb->len; +-out_err: +- return err; ++ up_read(&crypto_alg_sem); ++ return res; + } + + static int crypto_dump_report_done(struct netlink_callback *cb) +@@ -483,7 +486,7 @@ static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + if ((type == (CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE) && + (nlh->nlmsg_flags & NLM_F_DUMP))) { + struct crypto_alg *alg; +- u16 dump_alloc = 0; ++ unsigned long dump_alloc = 0; + + if (link->dump == NULL) + return -EINVAL; +@@ -491,16 +494,16 @@ static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + down_read(&crypto_alg_sem); + list_for_each_entry(alg, &crypto_alg_list, cra_list) + dump_alloc += CRYPTO_REPORT_MAXSIZE; ++ up_read(&crypto_alg_sem); + + { + struct netlink_dump_control c = { + .dump = link->dump, + .done = link->done, +- .min_dump_alloc = dump_alloc, ++ .min_dump_alloc = min(dump_alloc, 65535UL), + }; + err = netlink_dump_start(crypto_nlsk, skb, nlh, &c); + } +- up_read(&crypto_alg_sem); + + return err; + } +diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c +index 8e38249311bd..a9158858f54c 100644 +--- a/drivers/acpi/acpi_lpss.c ++++ b/drivers/acpi/acpi_lpss.c +@@ -448,12 +448,7 @@ static int acpi_lpss_create_device(struct acpi_device *adev, + * have _PS0 and _PS3 without _PSC (and no power resources), so + * acpi_bus_init_power() will assume that the BIOS has put them into D0. + */ +- ret = acpi_device_fix_up_power(adev); +- if (ret) { +- /* Skip the device, but continue the namespace scan. */ +- ret = 0; +- goto err_out; +- } ++ acpi_device_fix_up_power(adev); + + adev->driver_data = pdata; + pdev = acpi_create_platform_device(adev, dev_desc->properties); +diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c +index 0375c6024062..a6e3c8dc2be4 100644 +--- a/drivers/acpi/apei/ghes.c ++++ b/drivers/acpi/apei/ghes.c +@@ -203,40 +203,40 @@ static int ghes_estatus_pool_init(void) + return 0; + } + +-static void ghes_estatus_pool_free_chunk_page(struct gen_pool *pool, ++static void ghes_estatus_pool_free_chunk(struct gen_pool *pool, + struct gen_pool_chunk *chunk, + void *data) + { +- free_page(chunk->start_addr); ++ vfree((void *)chunk->start_addr); + } + + static void ghes_estatus_pool_exit(void) + { + gen_pool_for_each_chunk(ghes_estatus_pool, +- ghes_estatus_pool_free_chunk_page, NULL); ++ ghes_estatus_pool_free_chunk, NULL); + gen_pool_destroy(ghes_estatus_pool); + } + + static int ghes_estatus_pool_expand(unsigned long len) + { +- unsigned long i, pages, size, addr; +- int ret; ++ unsigned long size, addr; + + ghes_estatus_pool_size_request += PAGE_ALIGN(len); + size = gen_pool_size(ghes_estatus_pool); + if (size >= ghes_estatus_pool_size_request) + return 0; +- pages = (ghes_estatus_pool_size_request - size) / PAGE_SIZE; +- for (i = 0; i < pages; i++) { +- addr = __get_free_page(GFP_KERNEL); +- if (!addr) +- return -ENOMEM; +- ret = gen_pool_add(ghes_estatus_pool, addr, PAGE_SIZE, -1); +- if (ret) +- return ret; +- } + +- return 0; ++ addr = (unsigned long)vmalloc(PAGE_ALIGN(len)); ++ if (!addr) ++ return -ENOMEM; ++ ++ /* ++ * New allocation must be visible in all pgd before it can be found by ++ * an NMI allocating from the pool. ++ */ ++ vmalloc_sync_all(); ++ ++ return gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1); + } + + static struct ghes *ghes_new(struct acpi_hest_generic *generic) +diff --git a/drivers/base/platform.c b/drivers/base/platform.c +index 14ff40371f01..f90b1b9bbad0 100644 +--- a/drivers/base/platform.c ++++ b/drivers/base/platform.c +@@ -27,6 +27,7 @@ + #include + #include + #include ++#include + + #include "base.h" + #include "power/power.h" +@@ -516,6 +517,8 @@ struct platform_device *platform_device_register_full( + if (!pdev->dev.dma_mask) + goto err; + ++ kmemleak_ignore(pdev->dev.dma_mask); ++ + *pdev->dev.dma_mask = pdevinfo->dma_mask; + pdev->dev.coherent_dma_mask = pdevinfo->dma_mask; + } +diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c +index 83482721bc01..f5c24459fc5c 100644 +--- a/drivers/block/drbd/drbd_main.c ++++ b/drivers/block/drbd/drbd_main.c +@@ -793,7 +793,6 @@ int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cm + + if (nc->tentative && connection->agreed_pro_version < 92) { + rcu_read_unlock(); +- mutex_unlock(&sock->mutex); + drbd_err(connection, "--dry-run is not supported by peer"); + return -EOPNOTSUPP; + } +diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c +index abee91940a36..b809f325c2be 100644 +--- a/drivers/block/drbd/drbd_nl.c ++++ b/drivers/block/drbd/drbd_nl.c +@@ -1508,6 +1508,30 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis + } + } + ++static int disk_opts_check_al_size(struct drbd_device *device, struct disk_conf *dc) ++{ ++ int err = -EBUSY; ++ ++ if (device->act_log && ++ device->act_log->nr_elements == dc->al_extents) ++ return 0; ++ ++ drbd_suspend_io(device); ++ /* If IO completion is currently blocked, we would likely wait ++ * "forever" for the activity log to become unused. So we don't. */ ++ if (atomic_read(&device->ap_bio_cnt)) ++ goto out; ++ ++ wait_event(device->al_wait, lc_try_lock(device->act_log)); ++ drbd_al_shrink(device); ++ err = drbd_check_al_size(device, dc); ++ lc_unlock(device->act_log); ++ wake_up(&device->al_wait); ++out: ++ drbd_resume_io(device); ++ return err; ++} ++ + int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info) + { + struct drbd_config_context adm_ctx; +@@ -1570,15 +1594,12 @@ int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info) + } + } + +- drbd_suspend_io(device); +- wait_event(device->al_wait, lc_try_lock(device->act_log)); +- drbd_al_shrink(device); +- err = drbd_check_al_size(device, new_disk_conf); +- lc_unlock(device->act_log); +- wake_up(&device->al_wait); +- drbd_resume_io(device); +- ++ err = disk_opts_check_al_size(device, new_disk_conf); + if (err) { ++ /* Could be just "busy". Ignore? ++ * Introduce dedicated error code? */ ++ drbd_msg_put_info(adm_ctx.reply_skb, ++ "Try again without changing current al-extents setting"); + retcode = ERR_NOMEM; + goto fail_unlock; + } +@@ -1927,9 +1948,9 @@ int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info) + } + } + +- if (device->state.conn < C_CONNECTED && +- device->state.role == R_PRIMARY && device->ed_uuid && +- (device->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) { ++ if (device->state.pdsk != D_UP_TO_DATE && device->ed_uuid && ++ (device->state.role == R_PRIMARY || device->state.peer == R_PRIMARY) && ++ (device->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) { + drbd_err(device, "Can only attach to data with current UUID=%016llX\n", + (unsigned long long)device->ed_uuid); + retcode = ERR_DATA_NOT_CURRENT; +diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c +index 8e8e4ccb128f..a10ff6e8c20b 100644 +--- a/drivers/block/drbd/drbd_receiver.c ++++ b/drivers/block/drbd/drbd_receiver.c +@@ -4037,6 +4037,7 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info + struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; + enum determine_dev_size dd = DS_UNCHANGED; + sector_t p_size, p_usize, p_csize, my_usize; ++ sector_t new_size, cur_size; + int ldsc = 0; /* local disk size changed */ + enum dds_flags ddsf; + +@@ -4044,6 +4045,7 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info + if (!peer_device) + return config_unknown_volume(connection, pi); + device = peer_device->device; ++ cur_size = drbd_get_capacity(device->this_bdev); + + p_size = be64_to_cpu(p->d_size); + p_usize = be64_to_cpu(p->u_size); +@@ -4054,7 +4056,6 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info + device->p_size = p_size; + + if (get_ldev(device)) { +- sector_t new_size, cur_size; + rcu_read_lock(); + my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; + rcu_read_unlock(); +@@ -4072,7 +4073,6 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info + /* Never shrink a device with usable data during connect. + But allow online shrinking if we are connected. */ + new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); +- cur_size = drbd_get_capacity(device->this_bdev); + if (new_size < cur_size && + device->state.disk >= D_OUTDATED && + device->state.conn < C_CONNECTED) { +@@ -4137,9 +4137,36 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info + * + * However, if he sends a zero current size, + * take his (user-capped or) backing disk size anyways. ++ * ++ * Unless of course he does not have a disk himself. ++ * In which case we ignore this completely. + */ ++ sector_t new_size = p_csize ?: p_usize ?: p_size; + drbd_reconsider_queue_parameters(device, NULL, o); +- drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); ++ if (new_size == 0) { ++ /* Ignore, peer does not know nothing. */ ++ } else if (new_size == cur_size) { ++ /* nothing to do */ ++ } else if (cur_size != 0 && p_size == 0) { ++ drbd_warn(device, "Ignored diskless peer device size (peer:%llu != me:%llu sectors)!\n", ++ (unsigned long long)new_size, (unsigned long long)cur_size); ++ } else if (new_size < cur_size && device->state.role == R_PRIMARY) { ++ drbd_err(device, "The peer's device size is too small! (%llu < %llu sectors); demote me first!\n", ++ (unsigned long long)new_size, (unsigned long long)cur_size); ++ conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); ++ return -EIO; ++ } else { ++ /* I believe the peer, if ++ * - I don't have a current size myself ++ * - we agree on the size anyways ++ * - I do have a current size, am Secondary, ++ * and he has the only disk ++ * - I do have a current size, am Primary, ++ * and he has the only disk, ++ * which is larger than my current size ++ */ ++ drbd_set_my_capacity(device, new_size); ++ } + } + + if (get_ldev(device)) { +@@ -4425,6 +4452,25 @@ static int receive_state(struct drbd_connection *connection, struct packet_info + if (peer_state.conn == C_AHEAD) + ns.conn = C_BEHIND; + ++ /* TODO: ++ * if (primary and diskless and peer uuid != effective uuid) ++ * abort attach on peer; ++ * ++ * If this node does not have good data, was already connected, but ++ * the peer did a late attach only now, trying to "negotiate" with me, ++ * AND I am currently Primary, possibly frozen, with some specific ++ * "effective" uuid, this should never be reached, really, because ++ * we first send the uuids, then the current state. ++ * ++ * In this scenario, we already dropped the connection hard ++ * when we received the unsuitable uuids (receive_uuids(). ++ * ++ * Should we want to change this, that is: not drop the connection in ++ * receive_uuids() already, then we would need to add a branch here ++ * that aborts the attach of "unsuitable uuids" on the peer in case ++ * this node is currently Diskless Primary. ++ */ ++ + if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && + get_ldev_if_state(device, D_NEGOTIATING)) { + int cr; /* consider resync */ +diff --git a/drivers/block/drbd/drbd_state.h b/drivers/block/drbd/drbd_state.h +index 6c9d5d4a8a75..110f64d9e91c 100644 +--- a/drivers/block/drbd/drbd_state.h ++++ b/drivers/block/drbd/drbd_state.h +@@ -126,7 +126,7 @@ extern enum drbd_state_rv _drbd_set_state(struct drbd_device *, union drbd_state + enum chg_state_flags, + struct completion *done); + extern void print_st_err(struct drbd_device *, union drbd_state, +- union drbd_state, int); ++ union drbd_state, enum drbd_state_rv); + + enum drbd_state_rv + _conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val, +diff --git a/drivers/char/hw_random/stm32-rng.c b/drivers/char/hw_random/stm32-rng.c +index 83c695938a2d..f53d47e3355d 100644 +--- a/drivers/char/hw_random/stm32-rng.c ++++ b/drivers/char/hw_random/stm32-rng.c +@@ -166,6 +166,13 @@ static int stm32_rng_probe(struct platform_device *ofdev) + return devm_hwrng_register(dev, &priv->rng); + } + ++static int stm32_rng_remove(struct platform_device *ofdev) ++{ ++ pm_runtime_disable(&ofdev->dev); ++ ++ return 0; ++} ++ + #ifdef CONFIG_PM + static int stm32_rng_runtime_suspend(struct device *dev) + { +@@ -202,6 +209,7 @@ static struct platform_driver stm32_rng_driver = { + .of_match_table = stm32_rng_match, + }, + .probe = stm32_rng_probe, ++ .remove = stm32_rng_remove, + }; + + module_platform_driver(stm32_rng_driver); +diff --git a/drivers/clk/at91/clk-main.c b/drivers/clk/at91/clk-main.c +index 2f97a843d6d6..90988e7a5b47 100644 +--- a/drivers/clk/at91/clk-main.c ++++ b/drivers/clk/at91/clk-main.c +@@ -162,7 +162,7 @@ at91_clk_register_main_osc(struct regmap *regmap, + if (bypass) + regmap_update_bits(regmap, + AT91_CKGR_MOR, MOR_KEY_MASK | +- AT91_PMC_MOSCEN, ++ AT91_PMC_OSCBYPASS, + AT91_PMC_OSCBYPASS | AT91_PMC_KEY); + + hw = &osc->hw; +@@ -354,7 +354,10 @@ static int clk_main_probe_frequency(struct regmap *regmap) + regmap_read(regmap, AT91_CKGR_MCFR, &mcfr); + if (mcfr & AT91_PMC_MAINRDY) + return 0; +- usleep_range(MAINF_LOOP_MIN_WAIT, MAINF_LOOP_MAX_WAIT); ++ if (system_state < SYSTEM_RUNNING) ++ udelay(MAINF_LOOP_MIN_WAIT); ++ else ++ usleep_range(MAINF_LOOP_MIN_WAIT, MAINF_LOOP_MAX_WAIT); + } while (time_before(prep_time, timeout)); + + return -ETIMEDOUT; +diff --git a/drivers/clk/at91/sckc.c b/drivers/clk/at91/sckc.c +index ab6ecefc49ad..43ba2a8b03fa 100644 +--- a/drivers/clk/at91/sckc.c ++++ b/drivers/clk/at91/sckc.c +@@ -74,7 +74,10 @@ static int clk_slow_osc_prepare(struct clk_hw *hw) + + writel(tmp | AT91_SCKC_OSC32EN, sckcr); + +- usleep_range(osc->startup_usec, osc->startup_usec + 1); ++ if (system_state < SYSTEM_RUNNING) ++ udelay(osc->startup_usec); ++ else ++ usleep_range(osc->startup_usec, osc->startup_usec + 1); + + return 0; + } +@@ -197,7 +200,10 @@ static int clk_slow_rc_osc_prepare(struct clk_hw *hw) + + writel(readl(sckcr) | AT91_SCKC_RCEN, sckcr); + +- usleep_range(osc->startup_usec, osc->startup_usec + 1); ++ if (system_state < SYSTEM_RUNNING) ++ udelay(osc->startup_usec); ++ else ++ usleep_range(osc->startup_usec, osc->startup_usec + 1); + + return 0; + } +@@ -310,7 +316,10 @@ static int clk_sam9x5_slow_set_parent(struct clk_hw *hw, u8 index) + + writel(tmp, sckcr); + +- usleep_range(SLOWCK_SW_TIME_USEC, SLOWCK_SW_TIME_USEC + 1); ++ if (system_state < SYSTEM_RUNNING) ++ udelay(SLOWCK_SW_TIME_USEC); ++ else ++ usleep_range(SLOWCK_SW_TIME_USEC, SLOWCK_SW_TIME_USEC + 1); + + return 0; + } +@@ -443,7 +452,10 @@ static int clk_sama5d4_slow_osc_prepare(struct clk_hw *hw) + return 0; + } + +- usleep_range(osc->startup_usec, osc->startup_usec + 1); ++ if (system_state < SYSTEM_RUNNING) ++ udelay(osc->startup_usec); ++ else ++ usleep_range(osc->startup_usec, osc->startup_usec + 1); + osc->prepared = true; + + return 0; +diff --git a/drivers/clk/samsung/clk-exynos5420.c b/drivers/clk/samsung/clk-exynos5420.c +index 13c09a740840..2bb88d125113 100644 +--- a/drivers/clk/samsung/clk-exynos5420.c ++++ b/drivers/clk/samsung/clk-exynos5420.c +@@ -170,12 +170,18 @@ static const unsigned long exynos5x_clk_regs[] __initconst = { + GATE_BUS_CPU, + GATE_SCLK_CPU, + CLKOUT_CMU_CPU, ++ CPLL_CON0, ++ DPLL_CON0, + EPLL_CON0, + EPLL_CON1, + EPLL_CON2, + RPLL_CON0, + RPLL_CON1, + RPLL_CON2, ++ IPLL_CON0, ++ SPLL_CON0, ++ VPLL_CON0, ++ MPLL_CON0, + SRC_TOP0, + SRC_TOP1, + SRC_TOP2, +diff --git a/drivers/crypto/mxc-scc.c b/drivers/crypto/mxc-scc.c +index ee4be1b0d30b..0a57b3db2d67 100644 +--- a/drivers/crypto/mxc-scc.c ++++ b/drivers/crypto/mxc-scc.c +@@ -178,12 +178,12 @@ static int mxc_scc_get_data(struct mxc_scc_ctx *ctx, + else + from = scc->black_memory; + +- dev_dbg(scc->dev, "pcopy: from 0x%p %d bytes\n", from, ++ dev_dbg(scc->dev, "pcopy: from 0x%p %zu bytes\n", from, + ctx->dst_nents * 8); + len = sg_pcopy_from_buffer(ablkreq->dst, ctx->dst_nents, + from, ctx->size, ctx->offset); + if (!len) { +- dev_err(scc->dev, "pcopy err from 0x%p (len=%d)\n", from, len); ++ dev_err(scc->dev, "pcopy err from 0x%p (len=%zu)\n", from, len); + return -EINVAL; + } + +@@ -274,7 +274,7 @@ static int mxc_scc_put_data(struct mxc_scc_ctx *ctx, + len = sg_pcopy_to_buffer(req->src, ctx->src_nents, + to, len, ctx->offset); + if (!len) { +- dev_err(scc->dev, "pcopy err to 0x%p (len=%d)\n", to, len); ++ dev_err(scc->dev, "pcopy err to 0x%p (len=%zu)\n", to, len); + return -EINVAL; + } + +@@ -335,9 +335,9 @@ static void mxc_scc_ablkcipher_next(struct mxc_scc_ctx *ctx, + return; + } + +- dev_dbg(scc->dev, "Start encryption (0x%p/0x%p)\n", +- (void *)readl(scc->base + SCC_SCM_RED_START), +- (void *)readl(scc->base + SCC_SCM_BLACK_START)); ++ dev_dbg(scc->dev, "Start encryption (0x%x/0x%x)\n", ++ readl(scc->base + SCC_SCM_RED_START), ++ readl(scc->base + SCC_SCM_BLACK_START)); + + /* clear interrupt control registers */ + writel(SCC_SCM_INTR_CTRL_CLR_INTR, +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 9aeab4ff2d81..42d1b350afd2 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -196,6 +196,18 @@ static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type) + return 0; /* we know nothing about this usage type */ + } + ++/* ++ * Concatenate usage which defines 16 bits or less with the ++ * currently defined usage page to form a 32 bit usage ++ */ ++ ++static void complete_usage(struct hid_parser *parser, unsigned int index) ++{ ++ parser->local.usage[index] &= 0xFFFF; ++ parser->local.usage[index] |= ++ (parser->global.usage_page & 0xFFFF) << 16; ++} ++ + /* + * Add a usage to the temporary parser table. + */ +@@ -207,6 +219,14 @@ static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size) + return -1; + } + parser->local.usage[parser->local.usage_index] = usage; ++ ++ /* ++ * If Usage item only includes usage id, concatenate it with ++ * currently defined usage page ++ */ ++ if (size <= 2) ++ complete_usage(parser, parser->local.usage_index); ++ + parser->local.usage_size[parser->local.usage_index] = size; + parser->local.collection_index[parser->local.usage_index] = + parser->collection_stack_ptr ? +@@ -523,13 +543,32 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + * usage value." + */ + +-static void hid_concatenate_usage_page(struct hid_parser *parser) ++static void hid_concatenate_last_usage_page(struct hid_parser *parser) + { + int i; ++ unsigned int usage_page; ++ unsigned int current_page; + +- for (i = 0; i < parser->local.usage_index; i++) +- if (parser->local.usage_size[i] <= 2) +- parser->local.usage[i] += parser->global.usage_page << 16; ++ if (!parser->local.usage_index) ++ return; ++ ++ usage_page = parser->global.usage_page; ++ ++ /* ++ * Concatenate usage page again only if last declared Usage Page ++ * has not been already used in previous usages concatenation ++ */ ++ for (i = parser->local.usage_index - 1; i >= 0; i--) { ++ if (parser->local.usage_size[i] > 2) ++ /* Ignore extended usages */ ++ continue; ++ ++ current_page = parser->local.usage[i] >> 16; ++ if (current_page == usage_page) ++ break; ++ ++ complete_usage(parser, i); ++ } + } + + /* +@@ -541,7 +580,7 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item) + __u32 data; + int ret; + +- hid_concatenate_usage_page(parser); ++ hid_concatenate_last_usage_page(parser); + + data = item_udata(item); + +@@ -756,7 +795,7 @@ static int hid_scan_main(struct hid_parser *parser, struct hid_item *item) + __u32 data; + int i; + +- hid_concatenate_usage_page(parser); ++ hid_concatenate_last_usage_page(parser); + + data = item_udata(item); + +diff --git a/drivers/hid/intel-ish-hid/ishtp-hid.c b/drivers/hid/intel-ish-hid/ishtp-hid.c +index 277983aa1d90..d0b902285fc3 100644 +--- a/drivers/hid/intel-ish-hid/ishtp-hid.c ++++ b/drivers/hid/intel-ish-hid/ishtp-hid.c +@@ -222,7 +222,7 @@ int ishtp_hid_probe(unsigned int cur_hid_dev, + err_hid_device: + kfree(hid_data); + err_hid_data: +- kfree(hid); ++ hid_destroy_device(hid); + return rv; + } + +diff --git a/drivers/infiniband/hw/qib/qib_sdma.c b/drivers/infiniband/hw/qib/qib_sdma.c +index 891873b38a1e..5f3f197678b7 100644 +--- a/drivers/infiniband/hw/qib/qib_sdma.c ++++ b/drivers/infiniband/hw/qib/qib_sdma.c +@@ -600,8 +600,10 @@ retry: + dw = (len + 3) >> 2; + addr = dma_map_single(&ppd->dd->pcidev->dev, sge->vaddr, + dw << 2, DMA_TO_DEVICE); +- if (dma_mapping_error(&ppd->dd->pcidev->dev, addr)) ++ if (dma_mapping_error(&ppd->dd->pcidev->dev, addr)) { ++ ret = -ENOMEM; + goto unmap; ++ } + sdmadesc[0] = 0; + make_sdma_desc(ppd, sdmadesc, (u64) addr, dw, dwoffset); + /* SDmaUseLargeBuf has to be set in every descriptor */ +diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c +index 74de1ae48d4f..af68be201c29 100644 +--- a/drivers/infiniband/ulp/srp/ib_srp.c ++++ b/drivers/infiniband/ulp/srp/ib_srp.c +@@ -2180,6 +2180,7 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd) + + if (srp_post_send(ch, iu, len)) { + shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n"); ++ scmnd->result = DID_ERROR << 16; + goto err_unmap; + } + +diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c +index ecba666afadb..cca26e6f38b3 100644 +--- a/drivers/input/serio/gscps2.c ++++ b/drivers/input/serio/gscps2.c +@@ -382,9 +382,9 @@ static int gscps2_probe(struct parisc_device *dev) + goto fail; + #endif + +- printk(KERN_INFO "serio: %s port at 0x%p irq %d @ %s\n", ++ pr_info("serio: %s port at 0x%08lx irq %d @ %s\n", + ps2port->port->name, +- ps2port->addr, ++ hpa, + ps2port->padev->irq, + ps2port->port->phys); + +diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c +index 852858e5d8d0..92f541db98a0 100644 +--- a/drivers/input/serio/hp_sdc.c ++++ b/drivers/input/serio/hp_sdc.c +@@ -887,8 +887,8 @@ static int __init hp_sdc_init(void) + "HP SDC NMI", &hp_sdc)) + goto err2; + +- printk(KERN_INFO PREFIX "HP SDC at 0x%p, IRQ %d (NMI IRQ %d)\n", +- (void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi); ++ pr_info(PREFIX "HP SDC at 0x%08lx, IRQ %d (NMI IRQ %d)\n", ++ hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi); + + hp_sdc_status_in8(); + hp_sdc_data_in8(); +diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c +index e81acb2b6ee7..c898c70472bb 100644 +--- a/drivers/iommu/amd_iommu.c ++++ b/drivers/iommu/amd_iommu.c +@@ -176,10 +176,14 @@ static struct lock_class_key reserved_rbtree_key; + static inline int match_hid_uid(struct device *dev, + struct acpihid_map_entry *entry) + { ++ struct acpi_device *adev = ACPI_COMPANION(dev); + const char *hid, *uid; + +- hid = acpi_device_hid(ACPI_COMPANION(dev)); +- uid = acpi_device_uid(ACPI_COMPANION(dev)); ++ if (!adev) ++ return -ENODEV; ++ ++ hid = acpi_device_hid(adev); ++ uid = acpi_device_uid(adev); + + if (!hid || !(*hid)) + return -ENODEV; +diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c +index 3643cba71351..742c1fa870da 100644 +--- a/drivers/md/dm-flakey.c ++++ b/drivers/md/dm-flakey.c +@@ -258,20 +258,31 @@ static void flakey_map_bio(struct dm_target *ti, struct bio *bio) + + static void corrupt_bio_data(struct bio *bio, struct flakey_c *fc) + { +- unsigned bio_bytes = bio_cur_bytes(bio); +- char *data = bio_data(bio); ++ unsigned int corrupt_bio_byte = fc->corrupt_bio_byte - 1; ++ ++ struct bvec_iter iter; ++ struct bio_vec bvec; ++ ++ if (!bio_has_data(bio)) ++ return; + + /* +- * Overwrite the Nth byte of the data returned. ++ * Overwrite the Nth byte of the bio's data, on whichever page ++ * it falls. + */ +- if (data && bio_bytes >= fc->corrupt_bio_byte) { +- data[fc->corrupt_bio_byte - 1] = fc->corrupt_bio_value; +- +- DMDEBUG("Corrupting data bio=%p by writing %u to byte %u " +- "(rw=%c bi_opf=%u bi_sector=%llu cur_bytes=%u)\n", +- bio, fc->corrupt_bio_value, fc->corrupt_bio_byte, +- (bio_data_dir(bio) == WRITE) ? 'w' : 'r', bio->bi_opf, +- (unsigned long long)bio->bi_iter.bi_sector, bio_bytes); ++ bio_for_each_segment(bvec, bio, iter) { ++ if (bio_iter_len(bio, iter) > corrupt_bio_byte) { ++ char *segment = (page_address(bio_iter_page(bio, iter)) ++ + bio_iter_offset(bio, iter)); ++ segment[corrupt_bio_byte] = fc->corrupt_bio_value; ++ DMDEBUG("Corrupting data bio=%p by writing %u to byte %u " ++ "(rw=%c bi_opf=%u bi_sector=%llu size=%u)\n", ++ bio, fc->corrupt_bio_value, fc->corrupt_bio_byte, ++ (bio_data_dir(bio) == WRITE) ? 'w' : 'r', bio->bi_opf, ++ (unsigned long long)bio->bi_iter.bi_sector, bio->bi_iter.bi_size); ++ break; ++ } ++ corrupt_bio_byte -= bio_iter_len(bio, iter); + } + } + +diff --git a/drivers/media/platform/atmel/atmel-isc.c b/drivers/media/platform/atmel/atmel-isc.c +index ccfe13b7d3f8..ecf9fb08f36b 100644 +--- a/drivers/media/platform/atmel/atmel-isc.c ++++ b/drivers/media/platform/atmel/atmel-isc.c +@@ -1297,8 +1297,11 @@ static int isc_parse_dt(struct device *dev, struct isc_device *isc) + break; + } + +- subdev_entity->asd = devm_kzalloc(dev, +- sizeof(*subdev_entity->asd), GFP_KERNEL); ++ /* asd will be freed by the subsystem once it's added to the ++ * notifier list ++ */ ++ subdev_entity->asd = kzalloc(sizeof(*subdev_entity->asd), ++ GFP_KERNEL); + if (subdev_entity->asd == NULL) { + of_node_put(rem); + ret = -ENOMEM; +@@ -1432,6 +1435,7 @@ static int atmel_isc_probe(struct platform_device *pdev) + &subdev_entity->notifier); + if (ret) { + dev_err(dev, "fail to register async notifier\n"); ++ kfree(subdev_entity->asd); + goto cleanup_subdev; + } + +diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c +index b3d8b9592f8a..6c0c5de2527b 100644 +--- a/drivers/media/v4l2-core/v4l2-ctrls.c ++++ b/drivers/media/v4l2-core/v4l2-ctrls.c +@@ -1007,6 +1007,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, + case V4L2_CID_FLASH_STROBE_STOP: + case V4L2_CID_AUTO_FOCUS_START: + case V4L2_CID_AUTO_FOCUS_STOP: ++ case V4L2_CID_DO_WHITE_BALANCE: + *type = V4L2_CTRL_TYPE_BUTTON; + *flags |= V4L2_CTRL_FLAG_WRITE_ONLY | + V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +diff --git a/drivers/misc/mei/bus.c b/drivers/misc/mei/bus.c +index 0c98ed44df05..582b24d2c479 100644 +--- a/drivers/misc/mei/bus.c ++++ b/drivers/misc/mei/bus.c +@@ -765,15 +765,16 @@ static struct device_type mei_cl_device_type = { + + /** + * mei_cl_bus_set_name - set device name for me client device ++ * - ++ * Example: 0000:00:16.0-55213584-9a29-4916-badf-0fb7ed682aeb + * + * @cldev: me client device + */ + static inline void mei_cl_bus_set_name(struct mei_cl_device *cldev) + { +- dev_set_name(&cldev->dev, "mei:%s:%pUl:%02X", +- cldev->name, +- mei_me_cl_uuid(cldev->me_cl), +- mei_me_cl_ver(cldev->me_cl)); ++ dev_set_name(&cldev->dev, "%s-%pUl", ++ dev_name(cldev->bus->dev), ++ mei_me_cl_uuid(cldev->me_cl)); + } + + /** +diff --git a/drivers/mtd/mtdcore.h b/drivers/mtd/mtdcore.h +index 55fdb8e1fd2a..488b652ba9e6 100644 +--- a/drivers/mtd/mtdcore.h ++++ b/drivers/mtd/mtdcore.h +@@ -6,7 +6,7 @@ + extern struct mutex mtd_table_mutex; + + struct mtd_info *__mtd_next_device(int i); +-int add_mtd_device(struct mtd_info *mtd); ++int __must_check add_mtd_device(struct mtd_info *mtd); + int del_mtd_device(struct mtd_info *mtd); + int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int); + int del_mtd_partitions(struct mtd_info *); +diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c +index fccdd49bb964..5e2d1aa5e81e 100644 +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -648,10 +648,21 @@ int mtd_add_partition(struct mtd_info *master, const char *name, + list_add(&new->list, &mtd_partitions); + mutex_unlock(&mtd_partitions_mutex); + +- add_mtd_device(&new->mtd); ++ ret = add_mtd_device(&new->mtd); ++ if (ret) ++ goto err_remove_part; + + mtd_add_partition_attrs(new); + ++ return 0; ++ ++err_remove_part: ++ mutex_lock(&mtd_partitions_mutex); ++ list_del(&new->list); ++ mutex_unlock(&mtd_partitions_mutex); ++ ++ free_partition(new); ++ + return ret; + } + EXPORT_SYMBOL_GPL(mtd_add_partition); +@@ -696,28 +707,42 @@ int add_mtd_partitions(struct mtd_info *master, + { + struct mtd_part *slave; + uint64_t cur_offset = 0; +- int i; ++ int i, ret; + + printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name); + + for (i = 0; i < nbparts; i++) { + slave = allocate_partition(master, parts + i, i, cur_offset); + if (IS_ERR(slave)) { +- del_mtd_partitions(master); +- return PTR_ERR(slave); ++ ret = PTR_ERR(slave); ++ goto err_del_partitions; + } + + mutex_lock(&mtd_partitions_mutex); + list_add(&slave->list, &mtd_partitions); + mutex_unlock(&mtd_partitions_mutex); + +- add_mtd_device(&slave->mtd); ++ ret = add_mtd_device(&slave->mtd); ++ if (ret) { ++ mutex_lock(&mtd_partitions_mutex); ++ list_del(&slave->list); ++ mutex_unlock(&mtd_partitions_mutex); ++ ++ free_partition(slave); ++ goto err_del_partitions; ++ } ++ + mtd_add_partition_attrs(slave); + + cur_offset = slave->offset + slave->mtd.size; + } + + return 0; ++ ++err_del_partitions: ++ del_mtd_partitions(master); ++ ++ return ret; + } + + static DEFINE_SPINLOCK(part_parser_lock); +diff --git a/drivers/mtd/nand/sunxi_nand.c b/drivers/mtd/nand/sunxi_nand.c +index e26c4f880df6..886355bfa761 100644 +--- a/drivers/mtd/nand/sunxi_nand.c ++++ b/drivers/mtd/nand/sunxi_nand.c +@@ -1420,7 +1420,7 @@ static int sunxi_nfc_hw_ecc_write_page_dma(struct mtd_info *mtd, + sunxi_nfc_randomizer_enable(mtd); + + writel((NAND_CMD_RNDIN << 8) | NAND_CMD_PAGEPROG, +- nfc->regs + NFC_REG_RCMD_SET); ++ nfc->regs + NFC_REG_WCMD_SET); + + dma_async_issue_pending(nfc->dmac); + +diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c +index ad2b57c6b13f..211ee13d36ed 100644 +--- a/drivers/mtd/ubi/build.c ++++ b/drivers/mtd/ubi/build.c +@@ -1146,10 +1146,10 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway) + ubi_wl_close(ubi); + ubi_free_internal_volumes(ubi); + vfree(ubi->vtbl); +- put_mtd_device(ubi->mtd); + vfree(ubi->peb_buf); + vfree(ubi->fm_buf); + ubi_msg(ubi, "mtd%d is detached", ubi->mtd->index); ++ put_mtd_device(ubi->mtd); + put_device(&ubi->dev); + return 0; + } +diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c +index 88b1897aeb40..7826f7c4ec2f 100644 +--- a/drivers/mtd/ubi/kapi.c ++++ b/drivers/mtd/ubi/kapi.c +@@ -227,9 +227,9 @@ out_unlock: + out_free: + kfree(desc); + out_put_ubi: +- ubi_put_device(ubi); + ubi_err(ubi, "cannot open device %d, volume %d, error %d", + ubi_num, vol_id, err); ++ ubi_put_device(ubi); + return ERR_PTR(err); + } + EXPORT_SYMBOL_GPL(ubi_open_volume); +diff --git a/drivers/net/can/c_can/c_can.c b/drivers/net/can/c_can/c_can.c +index 7d35f6737499..4ead5a18b794 100644 +--- a/drivers/net/can/c_can/c_can.c ++++ b/drivers/net/can/c_can/c_can.c +@@ -52,6 +52,7 @@ + #define CONTROL_EX_PDR BIT(8) + + /* control register */ ++#define CONTROL_SWR BIT(15) + #define CONTROL_TEST BIT(7) + #define CONTROL_CCE BIT(6) + #define CONTROL_DISABLE_AR BIT(5) +@@ -572,6 +573,26 @@ static void c_can_configure_msg_objects(struct net_device *dev) + IF_MCONT_RCV_EOB); + } + ++static int c_can_software_reset(struct net_device *dev) ++{ ++ struct c_can_priv *priv = netdev_priv(dev); ++ int retry = 0; ++ ++ if (priv->type != BOSCH_D_CAN) ++ return 0; ++ ++ priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_SWR | CONTROL_INIT); ++ while (priv->read_reg(priv, C_CAN_CTRL_REG) & CONTROL_SWR) { ++ msleep(20); ++ if (retry++ > 100) { ++ netdev_err(dev, "CCTRL: software reset failed\n"); ++ return -EIO; ++ } ++ } ++ ++ return 0; ++} ++ + /* + * Configure C_CAN chip: + * - enable/disable auto-retransmission +@@ -581,6 +602,11 @@ static void c_can_configure_msg_objects(struct net_device *dev) + static int c_can_chip_config(struct net_device *dev) + { + struct c_can_priv *priv = netdev_priv(dev); ++ int err; ++ ++ err = c_can_software_reset(dev); ++ if (err) ++ return err; + + /* enable automatic retransmission */ + priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_ENABLE_AR); +diff --git a/drivers/net/can/usb/peak_usb/pcan_usb.c b/drivers/net/can/usb/peak_usb/pcan_usb.c +index e626c2afbbb1..0e1fc6c4360e 100644 +--- a/drivers/net/can/usb/peak_usb/pcan_usb.c ++++ b/drivers/net/can/usb/peak_usb/pcan_usb.c +@@ -441,8 +441,8 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n, + } + if ((n & PCAN_USB_ERROR_BUS_LIGHT) == 0) { + /* no error (back to active state) */ +- mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE; +- return 0; ++ new_state = CAN_STATE_ERROR_ACTIVE; ++ break; + } + break; + +@@ -465,9 +465,9 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n, + } + + if ((n & PCAN_USB_ERROR_BUS_HEAVY) == 0) { +- /* no error (back to active state) */ +- mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE; +- return 0; ++ /* no error (back to warning state) */ ++ new_state = CAN_STATE_ERROR_WARNING; ++ break; + } + break; + +@@ -506,6 +506,11 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n, + mc->pdev->dev.can.can_stats.error_warning++; + break; + ++ case CAN_STATE_ERROR_ACTIVE: ++ cf->can_id |= CAN_ERR_CRTL; ++ cf->data[1] = CAN_ERR_CRTL_ACTIVE; ++ break; ++ + default: + /* CAN_STATE_MAX (trick to handle other errors) */ + cf->can_id |= CAN_ERR_CRTL; +diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c +index c2cd540e9c9e..a3a8d7b62f3f 100644 +--- a/drivers/net/dsa/bcm_sf2.c ++++ b/drivers/net/dsa/bcm_sf2.c +@@ -405,11 +405,10 @@ static int bcm_sf2_sw_mdio_write(struct mii_bus *bus, int addr, int regnum, + * send them to our master MDIO bus controller + */ + if (addr == BRCM_PSEUDO_PHY_ADDR && priv->indir_phy_mask & BIT(addr)) +- bcm_sf2_sw_indir_rw(priv, 0, addr, regnum, val); ++ return bcm_sf2_sw_indir_rw(priv, 0, addr, regnum, val); + else +- mdiobus_write_nested(priv->master_mii_bus, addr, regnum, val); +- +- return 0; ++ return mdiobus_write_nested(priv->master_mii_bus, addr, ++ regnum, val); + } + + static irqreturn_t bcm_sf2_switch_0_isr(int irq, void *dev_id) +diff --git a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c +index 974713b19ab6..5e1f03590aaf 100644 +--- a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c ++++ b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c +@@ -478,7 +478,9 @@ static void atl1e_mdio_write(struct net_device *netdev, int phy_id, + { + struct atl1e_adapter *adapter = netdev_priv(netdev); + +- atl1e_write_phy_reg(&adapter->hw, reg_num & MDIO_REG_ADDR_MASK, val); ++ if (atl1e_write_phy_reg(&adapter->hw, ++ reg_num & MDIO_REG_ADDR_MASK, val)) ++ netdev_err(netdev, "write phy register failed\n"); + } + + static int atl1e_mii_ioctl(struct net_device *netdev, +diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c +index a0d640243df2..30e93041bf83 100644 +--- a/drivers/net/ethernet/cadence/macb.c ++++ b/drivers/net/ethernet/cadence/macb.c +@@ -2364,14 +2364,14 @@ static int macb_clk_init(struct platform_device *pdev, struct clk **pclk, + *pclk = devm_clk_get(&pdev->dev, "pclk"); + if (IS_ERR(*pclk)) { + err = PTR_ERR(*pclk); +- dev_err(&pdev->dev, "failed to get macb_clk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to get macb_clk (%d)\n", err); + return err; + } + + *hclk = devm_clk_get(&pdev->dev, "hclk"); + if (IS_ERR(*hclk)) { + err = PTR_ERR(*hclk); +- dev_err(&pdev->dev, "failed to get hclk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to get hclk (%d)\n", err); + return err; + } + +@@ -2385,25 +2385,25 @@ static int macb_clk_init(struct platform_device *pdev, struct clk **pclk, + + err = clk_prepare_enable(*pclk); + if (err) { +- dev_err(&pdev->dev, "failed to enable pclk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to enable pclk (%d)\n", err); + return err; + } + + err = clk_prepare_enable(*hclk); + if (err) { +- dev_err(&pdev->dev, "failed to enable hclk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to enable hclk (%d)\n", err); + goto err_disable_pclk; + } + + err = clk_prepare_enable(*tx_clk); + if (err) { +- dev_err(&pdev->dev, "failed to enable tx_clk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to enable tx_clk (%d)\n", err); + goto err_disable_hclk; + } + + err = clk_prepare_enable(*rx_clk); + if (err) { +- dev_err(&pdev->dev, "failed to enable rx_clk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to enable rx_clk (%d)\n", err); + goto err_disable_txclk; + } + +@@ -2823,7 +2823,7 @@ static int at91ether_clk_init(struct platform_device *pdev, struct clk **pclk, + + err = clk_prepare_enable(*pclk); + if (err) { +- dev_err(&pdev->dev, "failed to enable pclk (%u)\n", err); ++ dev_err(&pdev->dev, "failed to enable pclk (%d)\n", err); + return err; + } + +diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c +index 92ea760c4822..1b07c6216e2a 100644 +--- a/drivers/net/ethernet/freescale/fec_main.c ++++ b/drivers/net/ethernet/freescale/fec_main.c +@@ -3530,6 +3530,11 @@ fec_drv_remove(struct platform_device *pdev) + struct net_device *ndev = platform_get_drvdata(pdev); + struct fec_enet_private *fep = netdev_priv(ndev); + struct device_node *np = pdev->dev.of_node; ++ int ret; ++ ++ ret = pm_runtime_get_sync(&pdev->dev); ++ if (ret < 0) ++ return ret; + + cancel_work_sync(&fep->tx_timeout_work); + fec_ptp_stop(pdev); +@@ -3537,13 +3542,17 @@ fec_drv_remove(struct platform_device *pdev) + fec_enet_mii_remove(fep); + if (fep->reg_phy) + regulator_disable(fep->reg_phy); +- pm_runtime_put(&pdev->dev); +- pm_runtime_disable(&pdev->dev); ++ + if (of_phy_is_fixed_link(np)) + of_phy_deregister_fixed_link(np); + of_node_put(fep->phy_node); + free_netdev(ndev); + ++ clk_disable_unprepare(fep->clk_ahb); ++ clk_disable_unprepare(fep->clk_ipg); ++ pm_runtime_put_noidle(&pdev->dev); ++ pm_runtime_disable(&pdev->dev); ++ + return 0; + } + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c +index d676088512cf..c9fb589690ee 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c +@@ -786,11 +786,9 @@ static int mlx5_pci_init(struct mlx5_core_dev *dev, struct mlx5_priv *priv) + + priv->numa_node = dev_to_node(&dev->pdev->dev); + +- priv->dbg_root = debugfs_create_dir(dev_name(&pdev->dev), mlx5_debugfs_root); +- if (!priv->dbg_root) { +- dev_err(&pdev->dev, "Cannot create debugfs dir, aborting\n"); +- return -ENOMEM; +- } ++ if (mlx5_debugfs_root) ++ priv->dbg_root = ++ debugfs_create_dir(pci_name(pdev), mlx5_debugfs_root); + + err = mlx5_pci_enable_device(dev); + if (err) { +diff --git a/drivers/net/ethernet/sfc/ef10.c b/drivers/net/ethernet/sfc/ef10.c +index 3d5d5d54c103..22bc3dc44298 100644 +--- a/drivers/net/ethernet/sfc/ef10.c ++++ b/drivers/net/ethernet/sfc/ef10.c +@@ -5093,22 +5093,25 @@ static const struct efx_ef10_nvram_type_info efx_ef10_nvram_types[] = { + { NVRAM_PARTITION_TYPE_LICENSE, 0, 0, "sfc_license" }, + { NVRAM_PARTITION_TYPE_PHY_MIN, 0xff, 0, "sfc_phy_fw" }, + }; ++#define EF10_NVRAM_PARTITION_COUNT ARRAY_SIZE(efx_ef10_nvram_types) + + static int efx_ef10_mtd_probe_partition(struct efx_nic *efx, + struct efx_mcdi_mtd_partition *part, +- unsigned int type) ++ unsigned int type, ++ unsigned long *found) + { + MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_METADATA_IN_LEN); + MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_METADATA_OUT_LENMAX); + const struct efx_ef10_nvram_type_info *info; + size_t size, erase_size, outlen; ++ int type_idx = 0; + bool protected; + int rc; + +- for (info = efx_ef10_nvram_types; ; info++) { +- if (info == +- efx_ef10_nvram_types + ARRAY_SIZE(efx_ef10_nvram_types)) ++ for (type_idx = 0; ; type_idx++) { ++ if (type_idx == EF10_NVRAM_PARTITION_COUNT) + return -ENODEV; ++ info = efx_ef10_nvram_types + type_idx; + if ((type & ~info->type_mask) == info->type) + break; + } +@@ -5121,6 +5124,13 @@ static int efx_ef10_mtd_probe_partition(struct efx_nic *efx, + if (protected) + return -ENODEV; /* hide it */ + ++ /* If we've already exposed a partition of this type, hide this ++ * duplicate. All operations on MTDs are keyed by the type anyway, ++ * so we can't act on the duplicate. ++ */ ++ if (__test_and_set_bit(type_idx, found)) ++ return -EEXIST; ++ + part->nvram_type = type; + + MCDI_SET_DWORD(inbuf, NVRAM_METADATA_IN_TYPE, type); +@@ -5149,6 +5159,7 @@ static int efx_ef10_mtd_probe_partition(struct efx_nic *efx, + static int efx_ef10_mtd_probe(struct efx_nic *efx) + { + MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_PARTITIONS_OUT_LENMAX); ++ DECLARE_BITMAP(found, EF10_NVRAM_PARTITION_COUNT) = { 0 }; + struct efx_mcdi_mtd_partition *parts; + size_t outlen, n_parts_total, i, n_parts; + unsigned int type; +@@ -5177,11 +5188,13 @@ static int efx_ef10_mtd_probe(struct efx_nic *efx) + for (i = 0; i < n_parts_total; i++) { + type = MCDI_ARRAY_DWORD(outbuf, NVRAM_PARTITIONS_OUT_TYPE_ID, + i); +- rc = efx_ef10_mtd_probe_partition(efx, &parts[n_parts], type); +- if (rc == 0) +- n_parts++; +- else if (rc != -ENODEV) ++ rc = efx_ef10_mtd_probe_partition(efx, &parts[n_parts], type, ++ found); ++ if (rc == -EEXIST || rc == -ENODEV) ++ continue; ++ if (rc) + goto fail; ++ n_parts++; + } + + rc = efx_mtd_add(efx, &parts[0].common, n_parts, sizeof(*parts)); +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c +index d07520fb969e..62ccbd47c1db 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c +@@ -59,7 +59,9 @@ static int sun7i_gmac_init(struct platform_device *pdev, void *priv) + gmac->clk_enabled = 1; + } else { + clk_set_rate(gmac->tx_clk, SUN7I_GMAC_MII_RATE); +- clk_prepare(gmac->tx_clk); ++ ret = clk_prepare(gmac->tx_clk); ++ if (ret) ++ return ret; + } + + return 0; +diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c +index 6237236b7c4c..b1dcc7448b4f 100644 +--- a/drivers/net/macvlan.c ++++ b/drivers/net/macvlan.c +@@ -334,10 +334,11 @@ static void macvlan_broadcast_enqueue(struct macvlan_port *port, + } + spin_unlock(&port->bc_queue.lock); + ++ schedule_work(&port->bc_work); ++ + if (err) + goto free_nskb; + +- schedule_work(&port->bc_work); + return; + + free_nskb: +diff --git a/drivers/net/slip/slip.c b/drivers/net/slip/slip.c +index b2317b3a542a..7ec96c3e38a6 100644 +--- a/drivers/net/slip/slip.c ++++ b/drivers/net/slip/slip.c +@@ -860,6 +860,7 @@ err_free_chan: + sl->tty = NULL; + tty->disc_data = NULL; + clear_bit(SLF_INUSE, &sl->flags); ++ sl_free_netdev(sl->dev); + free_netdev(sl->dev); + + err_exit: +diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c +index 7a62316c570d..b2c1e872d5ed 100644 +--- a/drivers/net/wan/fsl_ucc_hdlc.c ++++ b/drivers/net/wan/fsl_ucc_hdlc.c +@@ -1117,7 +1117,6 @@ static int ucc_hdlc_probe(struct platform_device *pdev) + if (register_hdlc_device(dev)) { + ret = -ENOBUFS; + pr_err("ucc_hdlc: unable to register hdlc device\n"); +- free_netdev(dev); + goto free_dev; + } + +diff --git a/drivers/net/wireless/ath/ath6kl/cfg80211.c b/drivers/net/wireless/ath/ath6kl/cfg80211.c +index b7fe0af4cb24..650d2f6446a6 100644 +--- a/drivers/net/wireless/ath/ath6kl/cfg80211.c ++++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c +@@ -934,7 +934,7 @@ static int ath6kl_set_probed_ssids(struct ath6kl *ar, + else + ssid_list[i].flag = ANY_SSID_FLAG; + +- if (n_match_ssid == 0) ++ if (ar->wiphy->max_match_sets != 0 && n_match_ssid == 0) + ssid_list[i].flag |= MATCH_SSID_FLAG; + } + +@@ -1088,7 +1088,7 @@ void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted) + if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) { + for (i = 0; i < vif->scan_req->n_ssids; i++) { + ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, +- i + 1, DISABLE_SSID_FLAG, ++ i, DISABLE_SSID_FLAG, + 0, NULL); + } + } +diff --git a/drivers/net/wireless/marvell/mwifiex/debugfs.c b/drivers/net/wireless/marvell/mwifiex/debugfs.c +index ae2b69db5994..6eacea28d7ac 100644 +--- a/drivers/net/wireless/marvell/mwifiex/debugfs.c ++++ b/drivers/net/wireless/marvell/mwifiex/debugfs.c +@@ -296,15 +296,13 @@ mwifiex_histogram_read(struct file *file, char __user *ubuf, + "total samples = %d\n", + atomic_read(&phist_data->num_samples)); + +- p += sprintf(p, "rx rates (in Mbps): 0=1M 1=2M"); +- p += sprintf(p, "2=5.5M 3=11M 4=6M 5=9M 6=12M\n"); +- p += sprintf(p, "7=18M 8=24M 9=36M 10=48M 11=54M"); +- p += sprintf(p, "12-27=MCS0-15(BW20) 28-43=MCS0-15(BW40)\n"); ++ p += sprintf(p, ++ "rx rates (in Mbps): 0=1M 1=2M 2=5.5M 3=11M 4=6M 5=9M 6=12M\n" ++ "7=18M 8=24M 9=36M 10=48M 11=54M 12-27=MCS0-15(BW20) 28-43=MCS0-15(BW40)\n"); + + if (ISSUPP_11ACENABLED(priv->adapter->fw_cap_info)) { +- p += sprintf(p, "44-53=MCS0-9(VHT:BW20)"); +- p += sprintf(p, "54-63=MCS0-9(VHT:BW40)"); +- p += sprintf(p, "64-73=MCS0-9(VHT:BW80)\n\n"); ++ p += sprintf(p, ++ "44-53=MCS0-9(VHT:BW20) 54-63=MCS0-9(VHT:BW40) 64-73=MCS0-9(VHT:BW80)\n\n"); + } else { + p += sprintf(p, "\n"); + } +@@ -333,7 +331,7 @@ mwifiex_histogram_read(struct file *file, char __user *ubuf, + for (i = 0; i < MWIFIEX_MAX_NOISE_FLR; i++) { + value = atomic_read(&phist_data->noise_flr[i]); + if (value) +- p += sprintf(p, "noise_flr[-%02ddBm] = %d\n", ++ p += sprintf(p, "noise_flr[%02ddBm] = %d\n", + (int)(i-128), value); + } + for (i = 0; i < MWIFIEX_MAX_SIG_STRENGTH; i++) { +diff --git a/drivers/net/wireless/marvell/mwifiex/scan.c b/drivers/net/wireless/marvell/mwifiex/scan.c +index 7e96b6a37946..828c6f5eb83c 100644 +--- a/drivers/net/wireless/marvell/mwifiex/scan.c ++++ b/drivers/net/wireless/marvell/mwifiex/scan.c +@@ -1890,15 +1890,17 @@ mwifiex_parse_single_response_buf(struct mwifiex_private *priv, u8 **bss_info, + ETH_ALEN)) + mwifiex_update_curr_bss_params(priv, + bss); +- cfg80211_put_bss(priv->wdev.wiphy, bss); +- } + +- if ((chan->flags & IEEE80211_CHAN_RADAR) || +- (chan->flags & IEEE80211_CHAN_NO_IR)) { +- mwifiex_dbg(adapter, INFO, +- "radar or passive channel %d\n", +- channel); +- mwifiex_save_hidden_ssid_channels(priv, bss); ++ if ((chan->flags & IEEE80211_CHAN_RADAR) || ++ (chan->flags & IEEE80211_CHAN_NO_IR)) { ++ mwifiex_dbg(adapter, INFO, ++ "radar or passive channel %d\n", ++ channel); ++ mwifiex_save_hidden_ssid_channels(priv, ++ bss); ++ } ++ ++ cfg80211_put_bss(priv->wdev.wiphy, bss); + } + } + } else { +diff --git a/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c b/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c +index 6113624ccec3..17e3d5e83062 100644 +--- a/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c ++++ b/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c +@@ -446,12 +446,13 @@ static int rtl8187_init_urbs(struct ieee80211_hw *dev) + skb_queue_tail(&priv->rx_queue, skb); + usb_anchor_urb(entry, &priv->anchored); + ret = usb_submit_urb(entry, GFP_KERNEL); +- usb_put_urb(entry); + if (ret) { + skb_unlink(skb, &priv->rx_queue); + usb_unanchor_urb(entry); ++ usb_put_urb(entry); + goto err; + } ++ usb_put_urb(entry); + } + return ret; + +diff --git a/drivers/pinctrl/pinctrl-xway.c b/drivers/pinctrl/pinctrl-xway.c +index dd85ad1807f5..8ea1c6e2a6b2 100644 +--- a/drivers/pinctrl/pinctrl-xway.c ++++ b/drivers/pinctrl/pinctrl-xway.c +@@ -1748,14 +1748,6 @@ static int pinmux_xway_probe(struct platform_device *pdev) + } + xway_pctrl_desc.pins = xway_info.pads; + +- /* register the gpio chip */ +- xway_chip.parent = &pdev->dev; +- ret = devm_gpiochip_add_data(&pdev->dev, &xway_chip, NULL); +- if (ret) { +- dev_err(&pdev->dev, "Failed to register gpio chip\n"); +- return ret; +- } +- + /* setup the data needed by pinctrl */ + xway_pctrl_desc.name = dev_name(&pdev->dev); + xway_pctrl_desc.npins = xway_chip.ngpio; +@@ -1777,10 +1769,33 @@ static int pinmux_xway_probe(struct platform_device *pdev) + return ret; + } + +- /* finish with registering the gpio range in pinctrl */ +- xway_gpio_range.npins = xway_chip.ngpio; +- xway_gpio_range.base = xway_chip.base; +- pinctrl_add_gpio_range(xway_info.pctrl, &xway_gpio_range); ++ /* register the gpio chip */ ++ xway_chip.parent = &pdev->dev; ++ xway_chip.owner = THIS_MODULE; ++ xway_chip.of_node = pdev->dev.of_node; ++ ret = devm_gpiochip_add_data(&pdev->dev, &xway_chip, NULL); ++ if (ret) { ++ dev_err(&pdev->dev, "Failed to register gpio chip\n"); ++ return ret; ++ } ++ ++ /* ++ * For DeviceTree-supported systems, the gpio core checks the ++ * pinctrl's device node for the "gpio-ranges" property. ++ * If it is present, it takes care of adding the pin ranges ++ * for the driver. In this case the driver can skip ahead. ++ * ++ * In order to remain compatible with older, existing DeviceTree ++ * files which don't set the "gpio-ranges" property or systems that ++ * utilize ACPI the driver has to call gpiochip_add_pin_range(). ++ */ ++ if (!of_property_read_bool(pdev->dev.of_node, "gpio-ranges")) { ++ /* finish with registering the gpio range in pinctrl */ ++ xway_gpio_range.npins = xway_chip.ngpio; ++ xway_gpio_range.base = xway_chip.base; ++ pinctrl_add_gpio_range(xway_info.pctrl, &xway_gpio_range); ++ } ++ + dev_info(&pdev->dev, "Init done\n"); + return 0; + } +diff --git a/drivers/pinctrl/sh-pfc/pfc-sh7264.c b/drivers/pinctrl/sh-pfc/pfc-sh7264.c +index 8070765311db..e1c34e19222e 100644 +--- a/drivers/pinctrl/sh-pfc/pfc-sh7264.c ++++ b/drivers/pinctrl/sh-pfc/pfc-sh7264.c +@@ -1716,6 +1716,9 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = { + }, + + { PINMUX_CFG_REG("PFCR3", 0xfffe38a8, 16, 4) { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + PF12MD_000, PF12MD_001, 0, PF12MD_011, + PF12MD_100, PF12MD_101, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 } +@@ -1759,8 +1762,10 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + PF1MD_000, PF1MD_001, PF1MD_010, PF1MD_011, + PF1MD_100, PF1MD_101, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0 +- } ++ 0, 0, 0, 0, 0, 0, 0, 0, ++ PF0MD_000, PF0MD_001, PF0MD_010, PF0MD_011, ++ PF0MD_100, PF0MD_101, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0 } + }, + + { PINMUX_CFG_REG("PFIOR0", 0xfffe38b2, 16, 1) { +diff --git a/drivers/pinctrl/sh-pfc/pfc-sh7734.c b/drivers/pinctrl/sh-pfc/pfc-sh7734.c +index 6502e676d368..33232041ee86 100644 +--- a/drivers/pinctrl/sh-pfc/pfc-sh7734.c ++++ b/drivers/pinctrl/sh-pfc/pfc-sh7734.c +@@ -2213,22 +2213,22 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = { + /* IP10_22 [1] */ + FN_CAN_CLK_A, FN_RX4_D, + /* IP10_21_19 [3] */ +- FN_AUDIO_CLKOUT, FN_TX1_E, FN_HRTS0_C, FN_FSE_B, +- FN_LCD_M_DISP_B, 0, 0, 0, ++ FN_AUDIO_CLKOUT, FN_TX1_E, 0, FN_HRTS0_C, FN_FSE_B, ++ FN_LCD_M_DISP_B, 0, 0, + /* IP10_18_16 [3] */ +- FN_AUDIO_CLKC, FN_SCK1_E, FN_HCTS0_C, FN_FRB_B, +- FN_LCD_VEPWC_B, 0, 0, 0, ++ FN_AUDIO_CLKC, FN_SCK1_E, 0, FN_HCTS0_C, FN_FRB_B, ++ FN_LCD_VEPWC_B, 0, 0, + /* IP10_15 [1] */ + FN_AUDIO_CLKB_A, FN_LCD_CLK_B, + /* IP10_14_12 [3] */ + FN_AUDIO_CLKA_A, FN_VI1_CLK_B, FN_SCK1_D, FN_IECLK_B, + FN_LCD_FLM_B, 0, 0, 0, + /* IP10_11_9 [3] */ +- FN_SSI_SDATA3, FN_VI1_7_B, FN_HTX0_C, FN_FWE_B, +- FN_LCD_CL2_B, 0, 0, 0, ++ FN_SSI_SDATA3, FN_VI1_7_B, 0, FN_HTX0_C, FN_FWE_B, ++ FN_LCD_CL2_B, 0, 0, + /* IP10_8_6 [3] */ +- FN_SSI_SDATA2, FN_VI1_6_B, FN_HRX0_C, FN_FRE_B, +- FN_LCD_CL1_B, 0, 0, 0, ++ FN_SSI_SDATA2, FN_VI1_6_B, 0, FN_HRX0_C, FN_FRE_B, ++ FN_LCD_CL1_B, 0, 0, + /* IP10_5_3 [3] */ + FN_SSI_WS23, FN_VI1_5_B, FN_TX1_D, FN_HSCK0_C, FN_FALE_B, + FN_LCD_DON_B, 0, 0, 0, +diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c +index 454cb2ee3cee..05dc16b477f0 100644 +--- a/drivers/platform/x86/hp-wmi.c ++++ b/drivers/platform/x86/hp-wmi.c +@@ -90,7 +90,7 @@ struct bios_args { + u32 command; + u32 commandtype; + u32 datasize; +- u32 data; ++ u8 data[128]; + }; + + struct bios_return { +@@ -198,7 +198,7 @@ static int hp_wmi_perform_query(int query, int write, void *buffer, + .command = write ? 0x2 : 0x1, + .commandtype = query, + .datasize = insize, +- .data = 0, ++ .data = { 0 }, + }; + struct acpi_buffer input = { sizeof(struct bios_args), &args }; + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; +@@ -206,7 +206,7 @@ static int hp_wmi_perform_query(int query, int write, void *buffer, + + if (WARN_ON(insize > sizeof(args.data))) + return -EINVAL; +- memcpy(&args.data, buffer, insize); ++ memcpy(&args.data[0], buffer, insize); + + wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output); + +diff --git a/drivers/power/avs/smartreflex.c b/drivers/power/avs/smartreflex.c +index fa0f19b975a6..bb7b817cca59 100644 +--- a/drivers/power/avs/smartreflex.c ++++ b/drivers/power/avs/smartreflex.c +@@ -994,8 +994,7 @@ static int omap_sr_remove(struct platform_device *pdev) + + if (sr_info->autocomp_active) + sr_stop_vddautocomp(sr_info); +- if (sr_info->dbg_dir) +- debugfs_remove_recursive(sr_info->dbg_dir); ++ debugfs_remove_recursive(sr_info->dbg_dir); + + pm_runtime_disable(&pdev->dev); + list_del(&sr_info->node); +diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c +index a19246455c13..cc12032ee60d 100644 +--- a/drivers/pwm/core.c ++++ b/drivers/pwm/core.c +@@ -858,6 +858,7 @@ void pwm_put(struct pwm_device *pwm) + if (pwm->chip->ops->free) + pwm->chip->ops->free(pwm->chip, pwm); + ++ pwm_set_chip_data(pwm, NULL); + pwm->label = NULL; + + module_put(pwm->chip->ops->owner); +diff --git a/drivers/pwm/pwm-bcm-iproc.c b/drivers/pwm/pwm-bcm-iproc.c +index d961a8207b1c..31b01035d0ab 100644 +--- a/drivers/pwm/pwm-bcm-iproc.c ++++ b/drivers/pwm/pwm-bcm-iproc.c +@@ -187,6 +187,7 @@ static int iproc_pwmc_apply(struct pwm_chip *chip, struct pwm_device *pwm, + static const struct pwm_ops iproc_pwm_ops = { + .apply = iproc_pwmc_apply, + .get_state = iproc_pwmc_get_state, ++ .owner = THIS_MODULE, + }; + + static int iproc_pwmc_probe(struct platform_device *pdev) +diff --git a/drivers/pwm/pwm-berlin.c b/drivers/pwm/pwm-berlin.c +index 01339c152ab0..64d9bb1ac272 100644 +--- a/drivers/pwm/pwm-berlin.c ++++ b/drivers/pwm/pwm-berlin.c +@@ -78,7 +78,6 @@ static void berlin_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) + { + struct berlin_pwm_channel *channel = pwm_get_chip_data(pwm); + +- pwm_set_chip_data(pwm, NULL); + kfree(channel); + } + +diff --git a/drivers/pwm/pwm-clps711x.c b/drivers/pwm/pwm-clps711x.c +index 26ec24e457b1..7e16b7def0dc 100644 +--- a/drivers/pwm/pwm-clps711x.c ++++ b/drivers/pwm/pwm-clps711x.c +@@ -48,7 +48,7 @@ static void clps711x_pwm_update_val(struct clps711x_chip *priv, u32 n, u32 v) + static unsigned int clps711x_get_duty(struct pwm_device *pwm, unsigned int v) + { + /* Duty cycle 0..15 max */ +- return DIV_ROUND_CLOSEST(v * 0xf, pwm_get_period(pwm)); ++ return DIV_ROUND_CLOSEST(v * 0xf, pwm->args.period); + } + + static int clps711x_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) +@@ -71,7 +71,7 @@ static int clps711x_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, + struct clps711x_chip *priv = to_clps711x_chip(chip); + unsigned int duty; + +- if (period_ns != pwm_get_period(pwm)) ++ if (period_ns != pwm->args.period) + return -EINVAL; + + duty = clps711x_get_duty(pwm, duty_ns); +diff --git a/drivers/pwm/pwm-samsung.c b/drivers/pwm/pwm-samsung.c +index f113cda47032..219757087995 100644 +--- a/drivers/pwm/pwm-samsung.c ++++ b/drivers/pwm/pwm-samsung.c +@@ -235,7 +235,6 @@ static int pwm_samsung_request(struct pwm_chip *chip, struct pwm_device *pwm) + static void pwm_samsung_free(struct pwm_chip *chip, struct pwm_device *pwm) + { + devm_kfree(chip->dev, pwm_get_chip_data(pwm)); +- pwm_set_chip_data(pwm, NULL); + } + + static int pwm_samsung_enable(struct pwm_chip *chip, struct pwm_device *pwm) +diff --git a/drivers/regulator/palmas-regulator.c b/drivers/regulator/palmas-regulator.c +index f11d41dad9c1..1eb605b6f049 100644 +--- a/drivers/regulator/palmas-regulator.c ++++ b/drivers/regulator/palmas-regulator.c +@@ -435,13 +435,16 @@ static int palmas_ldo_write(struct palmas *palmas, unsigned int reg, + static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode) + { + int id = rdev_get_id(dev); ++ int ret; + struct palmas_pmic *pmic = rdev_get_drvdata(dev); + struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata; + struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id]; + unsigned int reg; + bool rail_enable = true; + +- palmas_smps_read(pmic->palmas, rinfo->ctrl_addr, ®); ++ ret = palmas_smps_read(pmic->palmas, rinfo->ctrl_addr, ®); ++ if (ret) ++ return ret; + + reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; + +diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c +index 696116ebdf50..9cde7b075701 100644 +--- a/drivers/regulator/tps65910-regulator.c ++++ b/drivers/regulator/tps65910-regulator.c +@@ -1102,8 +1102,10 @@ static int tps65910_probe(struct platform_device *pdev) + platform_set_drvdata(pdev, pmic); + + /* Give control of all register to control port */ +- tps65910_reg_set_bits(pmic->mfd, TPS65910_DEVCTRL, ++ err = tps65910_reg_set_bits(pmic->mfd, TPS65910_DEVCTRL, + DEVCTRL_SR_CTL_I2C_SEL_MASK); ++ if (err < 0) ++ return err; + + switch (tps65910_chip_id(tps65910)) { + case TPS65910: +diff --git a/drivers/scsi/csiostor/csio_init.c b/drivers/scsi/csiostor/csio_init.c +index dbe416ff46c2..776b99278688 100644 +--- a/drivers/scsi/csiostor/csio_init.c ++++ b/drivers/scsi/csiostor/csio_init.c +@@ -648,7 +648,7 @@ csio_shost_init(struct csio_hw *hw, struct device *dev, + if (csio_lnode_init(ln, hw, pln)) + goto err_shost_put; + +- if (scsi_add_host(shost, dev)) ++ if (scsi_add_host_with_dma(shost, dev, &hw->pdev->dev)) + goto err_lnode_exit; + + return ln; +diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c +index d44f18f773c0..7e8274938a3e 100644 +--- a/drivers/scsi/libsas/sas_expander.c ++++ b/drivers/scsi/libsas/sas_expander.c +@@ -603,7 +603,14 @@ int sas_smp_phy_control(struct domain_device *dev, int phy_id, + } + + res = smp_execute_task(dev, pc_req, PC_REQ_SIZE, pc_resp,PC_RESP_SIZE); +- ++ if (res) { ++ pr_err("ex %016llx phy%02d PHY control failed: %d\n", ++ SAS_ADDR(dev->sas_addr), phy_id, res); ++ } else if (pc_resp[2] != SMP_RESP_FUNC_ACC) { ++ pr_err("ex %016llx phy%02d PHY control failed: function result 0x%x\n", ++ SAS_ADDR(dev->sas_addr), phy_id, pc_resp[2]); ++ res = pc_resp[2]; ++ } + kfree(pc_resp); + kfree(pc_req); + return res; +@@ -806,6 +813,26 @@ static struct domain_device *sas_ex_discover_end_dev( + + #ifdef CONFIG_SCSI_SAS_ATA + if ((phy->attached_tproto & SAS_PROTOCOL_STP) || phy->attached_sata_dev) { ++ if (child->linkrate > parent->min_linkrate) { ++ struct sas_phy_linkrates rates = { ++ .maximum_linkrate = parent->min_linkrate, ++ .minimum_linkrate = parent->min_linkrate, ++ }; ++ int ret; ++ ++ pr_notice("ex %016llx phy%02d SATA device linkrate > min pathway connection rate, attempting to lower device linkrate\n", ++ SAS_ADDR(child->sas_addr), phy_id); ++ ret = sas_smp_phy_control(parent, phy_id, ++ PHY_FUNC_LINK_RESET, &rates); ++ if (ret) { ++ pr_err("ex %016llx phy%02d SATA device could not set linkrate (%d)\n", ++ SAS_ADDR(child->sas_addr), phy_id, ret); ++ goto out_free; ++ } ++ pr_notice("ex %016llx phy%02d SATA device set linkrate successfully\n", ++ SAS_ADDR(child->sas_addr), phy_id); ++ child->linkrate = child->min_linkrate; ++ } + res = sas_get_ata_info(child, phy); + if (res) + goto out_free; +diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c +index d197aa176dee..d489cc1018b5 100644 +--- a/drivers/scsi/lpfc/lpfc_scsi.c ++++ b/drivers/scsi/lpfc/lpfc_scsi.c +@@ -2707,6 +2707,7 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, + int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction; + int prot_group_type = 0; + int fcpdl; ++ struct lpfc_vport *vport = phba->pport; + + /* + * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd +@@ -2812,6 +2813,14 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, + */ + iocb_cmd->un.fcpi.fcpi_parm = fcpdl; + ++ /* ++ * For First burst, we may need to adjust the initial transfer ++ * length for DIF ++ */ ++ if (iocb_cmd->un.fcpi.fcpi_XRdy && ++ (fcpdl < vport->cfg_first_burst_size)) ++ iocb_cmd->un.fcpi.fcpi_XRdy = fcpdl; ++ + return 0; + err: + if (lpfc_cmd->seg_cnt) +@@ -3364,6 +3373,7 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, + int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction; + int prot_group_type = 0; + int fcpdl; ++ struct lpfc_vport *vport = phba->pport; + + /* + * Start the lpfc command prep by bumping the sgl beyond fcp_cmnd +@@ -3479,6 +3489,14 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, + */ + iocb_cmd->un.fcpi.fcpi_parm = fcpdl; + ++ /* ++ * For First burst, we may need to adjust the initial transfer ++ * length for DIF ++ */ ++ if (iocb_cmd->un.fcpi.fcpi_XRdy && ++ (fcpdl < vport->cfg_first_burst_size)) ++ iocb_cmd->un.fcpi.fcpi_XRdy = fcpdl; ++ + /* + * If the OAS driver feature is enabled and the lun is enabled for + * OAS, set the oas iocb related flags. +diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c +index 0ad8ecef1e30..abdd6f93c8fe 100644 +--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c ++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c +@@ -821,38 +821,14 @@ static ssize_t tcm_qla2xxx_tpg_enable_show(struct config_item *item, + atomic_read(&tpg->lport_tpg_enabled)); + } + +-static void tcm_qla2xxx_depend_tpg(struct work_struct *work) +-{ +- struct tcm_qla2xxx_tpg *base_tpg = container_of(work, +- struct tcm_qla2xxx_tpg, tpg_base_work); +- struct se_portal_group *se_tpg = &base_tpg->se_tpg; +- struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha; +- +- if (!target_depend_item(&se_tpg->tpg_group.cg_item)) { +- atomic_set(&base_tpg->lport_tpg_enabled, 1); +- qlt_enable_vha(base_vha); +- } +- complete(&base_tpg->tpg_base_comp); +-} +- +-static void tcm_qla2xxx_undepend_tpg(struct work_struct *work) +-{ +- struct tcm_qla2xxx_tpg *base_tpg = container_of(work, +- struct tcm_qla2xxx_tpg, tpg_base_work); +- struct se_portal_group *se_tpg = &base_tpg->se_tpg; +- struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha; +- +- if (!qlt_stop_phase1(base_vha->vha_tgt.qla_tgt)) { +- atomic_set(&base_tpg->lport_tpg_enabled, 0); +- target_undepend_item(&se_tpg->tpg_group.cg_item); +- } +- complete(&base_tpg->tpg_base_comp); +-} +- + static ssize_t tcm_qla2xxx_tpg_enable_store(struct config_item *item, + const char *page, size_t count) + { + struct se_portal_group *se_tpg = to_tpg(item); ++ struct se_wwn *se_wwn = se_tpg->se_tpg_wwn; ++ struct tcm_qla2xxx_lport *lport = container_of(se_wwn, ++ struct tcm_qla2xxx_lport, lport_wwn); ++ struct scsi_qla_host *vha = lport->qla_vha; + struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg, + struct tcm_qla2xxx_tpg, se_tpg); + unsigned long op; +@@ -871,24 +847,16 @@ static ssize_t tcm_qla2xxx_tpg_enable_store(struct config_item *item, + if (atomic_read(&tpg->lport_tpg_enabled)) + return -EEXIST; + +- INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_depend_tpg); ++ atomic_set(&tpg->lport_tpg_enabled, 1); ++ qlt_enable_vha(vha); + } else { + if (!atomic_read(&tpg->lport_tpg_enabled)) + return count; + +- INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_undepend_tpg); ++ atomic_set(&tpg->lport_tpg_enabled, 0); ++ qlt_stop_phase1(vha->vha_tgt.qla_tgt); + } +- init_completion(&tpg->tpg_base_comp); +- schedule_work(&tpg->tpg_base_work); +- wait_for_completion(&tpg->tpg_base_comp); + +- if (op) { +- if (!atomic_read(&tpg->lport_tpg_enabled)) +- return -ENODEV; +- } else { +- if (atomic_read(&tpg->lport_tpg_enabled)) +- return -EPERM; +- } + return count; + } + +diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.h b/drivers/scsi/qla2xxx/tcm_qla2xxx.h +index 37e026a4823d..8b70fa3105bd 100644 +--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.h ++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.h +@@ -48,9 +48,6 @@ struct tcm_qla2xxx_tpg { + struct tcm_qla2xxx_tpg_attrib tpg_attrib; + /* Returned by tcm_qla2xxx_make_tpg() */ + struct se_portal_group se_tpg; +- /* Items for dealing with configfs_depend_item */ +- struct completion tpg_base_comp; +- struct work_struct tpg_base_work; + }; + + struct tcm_qla2xxx_fc_loopid { +diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c +index 4c30eea45f89..0d6fe039ac19 100644 +--- a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c ++++ b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c +@@ -1630,14 +1630,15 @@ static void _rtl92e_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, + memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev)); + skb_push(skb, priv->rtllib->tx_headroom); + ret = _rtl92e_tx(dev, skb); +- if (ret != 0) +- kfree_skb(skb); + + if (queue_index != MGNT_QUEUE) { + priv->rtllib->stats.tx_bytes += (skb->len - + priv->rtllib->tx_headroom); + priv->rtllib->stats.tx_packets++; + } ++ ++ if (ret != 0) ++ kfree_skb(skb); + } + + static int _rtl92e_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) +diff --git a/drivers/tty/serial/max310x.c b/drivers/tty/serial/max310x.c +index bacc7e284c0c..80ab672d61cc 100644 +--- a/drivers/tty/serial/max310x.c ++++ b/drivers/tty/serial/max310x.c +@@ -769,12 +769,9 @@ static void max310x_start_tx(struct uart_port *port) + + static unsigned int max310x_tx_empty(struct uart_port *port) + { +- unsigned int lvl, sts; ++ u8 lvl = max310x_port_read(port, MAX310X_TXFIFOLVL_REG); + +- lvl = max310x_port_read(port, MAX310X_TXFIFOLVL_REG); +- sts = max310x_port_read(port, MAX310X_IRQSTS_REG); +- +- return ((sts & MAX310X_IRQ_TXEMPTY_BIT) && !lvl) ? TIOCSER_TEMT : 0; ++ return lvl ? 0 : TIOCSER_TEMT; + } + + static unsigned int max310x_get_mctrl(struct uart_port *port) +diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c +index f94d11615b45..a7cb0968259e 100644 +--- a/drivers/usb/serial/ftdi_sio.c ++++ b/drivers/usb/serial/ftdi_sio.c +@@ -1028,6 +1028,9 @@ static const struct usb_device_id id_table_combined[] = { + /* Sienna devices */ + { USB_DEVICE(FTDI_VID, FTDI_SIENNA_PID) }, + { USB_DEVICE(ECHELON_VID, ECHELON_U20_PID) }, ++ /* U-Blox devices */ ++ { USB_DEVICE(UBLOX_VID, UBLOX_C099F9P_ZED_PID) }, ++ { USB_DEVICE(UBLOX_VID, UBLOX_C099F9P_ODIN_PID) }, + { } /* Terminating entry */ + }; + +diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h +index 2e8161f79b49..32a40ab9a385 100644 +--- a/drivers/usb/serial/ftdi_sio_ids.h ++++ b/drivers/usb/serial/ftdi_sio_ids.h +@@ -1557,3 +1557,10 @@ + */ + #define UNJO_VID 0x22B7 + #define UNJO_ISODEBUG_V1_PID 0x150D ++ ++/* ++ * U-Blox products (http://www.u-blox.com). ++ */ ++#define UBLOX_VID 0x1546 ++#define UBLOX_C099F9P_ZED_PID 0x0502 ++#define UBLOX_C099F9P_ODIN_PID 0x0503 +diff --git a/drivers/vfio/vfio_iommu_spapr_tce.c b/drivers/vfio/vfio_iommu_spapr_tce.c +index 70c748a5fbcc..a8e25f9409fa 100644 +--- a/drivers/vfio/vfio_iommu_spapr_tce.c ++++ b/drivers/vfio/vfio_iommu_spapr_tce.c +@@ -406,6 +406,7 @@ static void tce_iommu_release(void *iommu_data) + { + struct tce_container *container = iommu_data; + struct tce_iommu_group *tcegrp; ++ struct tce_iommu_prereg *tcemem, *tmtmp; + long i; + + while (tce_groups_attached(container)) { +@@ -428,13 +429,8 @@ static void tce_iommu_release(void *iommu_data) + tce_iommu_free_table(container, tbl); + } + +- while (!list_empty(&container->prereg_list)) { +- struct tce_iommu_prereg *tcemem; +- +- tcemem = list_first_entry(&container->prereg_list, +- struct tce_iommu_prereg, next); +- WARN_ON_ONCE(tce_iommu_prereg_free(container, tcemem)); +- } ++ list_for_each_entry_safe(tcemem, tmtmp, &container->prereg_list, next) ++ WARN_ON(tce_iommu_prereg_free(container, tcemem)); + + tce_iommu_disable(container); + if (container->mm) +diff --git a/drivers/watchdog/meson_gxbb_wdt.c b/drivers/watchdog/meson_gxbb_wdt.c +index 44d180a2c5e5..58e06f059e67 100644 +--- a/drivers/watchdog/meson_gxbb_wdt.c ++++ b/drivers/watchdog/meson_gxbb_wdt.c +@@ -137,8 +137,8 @@ static unsigned int meson_gxbb_wdt_get_timeleft(struct watchdog_device *wdt_dev) + + reg = readl(data->reg_base + GXBB_WDT_TCNT_REG); + +- return ((reg >> GXBB_WDT_TCNT_CNT_SHIFT) - +- (reg & GXBB_WDT_TCNT_SETUP_MASK)) / 1000; ++ return ((reg & GXBB_WDT_TCNT_SETUP_MASK) - ++ (reg >> GXBB_WDT_TCNT_CNT_SHIFT)) / 1000; + } + + static const struct watchdog_ops meson_gxbb_wdt_ops = { +diff --git a/drivers/xen/xen-pciback/pci_stub.c b/drivers/xen/xen-pciback/pci_stub.c +index 6331a95691a4..ee5ce9286d61 100644 +--- a/drivers/xen/xen-pciback/pci_stub.c ++++ b/drivers/xen/xen-pciback/pci_stub.c +@@ -106,7 +106,8 @@ static void pcistub_device_release(struct kref *kref) + * is called from "unbind" which takes a device_lock mutex. + */ + __pci_reset_function_locked(dev); +- if (pci_load_and_free_saved_state(dev, &dev_data->pci_saved_state)) ++ if (dev_data && ++ pci_load_and_free_saved_state(dev, &dev_data->pci_saved_state)) + dev_info(&dev->dev, "Could not reload PCI state\n"); + else + pci_restore_state(dev); +diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c +index 8d93854a4b4f..74c17db75201 100644 +--- a/fs/btrfs/delayed-ref.c ++++ b/fs/btrfs/delayed-ref.c +@@ -193,8 +193,6 @@ static inline void drop_delayed_ref(struct btrfs_trans_handle *trans, + ref->in_tree = 0; + btrfs_put_delayed_ref(ref); + atomic_dec(&delayed_refs->num_entries); +- if (trans->delayed_ref_updates) +- trans->delayed_ref_updates--; + } + + static bool merge_ref(struct btrfs_trans_handle *trans, +@@ -445,7 +443,6 @@ add_delayed_ref_tail_merge(struct btrfs_trans_handle *trans, + add_tail: + list_add_tail(&ref->list, &href->ref_list); + atomic_inc(&root->num_entries); +- trans->delayed_ref_updates++; + spin_unlock(&href->lock); + return ret; + } +diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c +index 39af17b407f0..d83e99fa98b3 100644 +--- a/fs/gfs2/bmap.c ++++ b/fs/gfs2/bmap.c +@@ -1236,6 +1236,8 @@ static int do_grow(struct inode *inode, u64 size) + } + + error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT + ++ (unstuff && ++ gfs2_is_jdata(ip) ? RES_JDATA : 0) + + (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ? + 0 : RES_QUOTA), 0); + if (error) +diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c +index a30f63623db7..13cf69aa4cae 100644 +--- a/fs/ocfs2/journal.c ++++ b/fs/ocfs2/journal.c +@@ -1018,7 +1018,8 @@ void ocfs2_journal_shutdown(struct ocfs2_super *osb) + mlog_errno(status); + } + +- if (status == 0) { ++ /* Shutdown the kernel journal system */ ++ if (!jbd2_journal_destroy(journal->j_journal) && !status) { + /* + * Do not toggle if flush was unsuccessful otherwise + * will leave dirty metadata in a "clean" journal +@@ -1027,9 +1028,6 @@ void ocfs2_journal_shutdown(struct ocfs2_super *osb) + if (status < 0) + mlog_errno(status); + } +- +- /* Shutdown the kernel journal system */ +- jbd2_journal_destroy(journal->j_journal); + journal->j_journal = NULL; + + OCFS2_I(inode)->ip_open_count--; +diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c +index 321f57721b92..6b7ed221726d 100644 +--- a/fs/xfs/xfs_ioctl32.c ++++ b/fs/xfs/xfs_ioctl32.c +@@ -251,6 +251,32 @@ xfs_compat_ioc_bulkstat( + int done; + int error; + ++ /* ++ * Output structure handling functions. Depending on the command, ++ * either the xfs_bstat and xfs_inogrp structures are written out ++ * to userpace memory via bulkreq.ubuffer. Normally the compat ++ * functions and structure size are the correct ones to use ... ++ */ ++ inumbers_fmt_pf inumbers_func = xfs_inumbers_fmt_compat; ++ bulkstat_one_pf bs_one_func = xfs_bulkstat_one_compat; ++ size_t bs_one_size = sizeof(struct compat_xfs_bstat); ++ ++#ifdef CONFIG_X86_X32 ++ if (in_x32_syscall()) { ++ /* ++ * ... but on x32 the input xfs_fsop_bulkreq has pointers ++ * which must be handled in the "compat" (32-bit) way, while ++ * the xfs_bstat and xfs_inogrp structures follow native 64- ++ * bit layout convention. So adjust accordingly, otherwise ++ * the data written out in compat layout will not match what ++ * x32 userspace expects. ++ */ ++ inumbers_func = xfs_inumbers_fmt; ++ bs_one_func = xfs_bulkstat_one; ++ bs_one_size = sizeof(struct xfs_bstat); ++ } ++#endif ++ + /* done = 1 if there are more stats to get and if bulkstat */ + /* should be called again (unused here, but used in dmapi) */ + +@@ -282,15 +308,15 @@ xfs_compat_ioc_bulkstat( + + if (cmd == XFS_IOC_FSINUMBERS_32) { + error = xfs_inumbers(mp, &inlast, &count, +- bulkreq.ubuffer, xfs_inumbers_fmt_compat); ++ bulkreq.ubuffer, inumbers_func); + } else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) { + int res; + +- error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer, +- sizeof(compat_xfs_bstat_t), NULL, &res); ++ error = bs_one_func(mp, inlast, bulkreq.ubuffer, ++ bs_one_size, NULL, &res); + } else if (cmd == XFS_IOC_FSBULKSTAT_32) { + error = xfs_bulkstat(mp, &inlast, &count, +- xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t), ++ bs_one_func, bs_one_size, + bulkreq.ubuffer, &done); + } else + error = -EINVAL; +@@ -346,6 +372,7 @@ xfs_compat_attrlist_by_handle( + { + int error; + attrlist_cursor_kern_t *cursor; ++ compat_xfs_fsop_attrlist_handlereq_t __user *p = arg; + compat_xfs_fsop_attrlist_handlereq_t al_hreq; + struct dentry *dentry; + char *kbuf; +@@ -380,6 +407,11 @@ xfs_compat_attrlist_by_handle( + if (error) + goto out_kfree; + ++ if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) { ++ error = -EFAULT; ++ goto out_kfree; ++ } ++ + if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen)) + error = -EFAULT; + +diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c +index 802bcc326d9f..0d93d3c10fcc 100644 +--- a/fs/xfs/xfs_rtalloc.c ++++ b/fs/xfs/xfs_rtalloc.c +@@ -1222,13 +1222,11 @@ xfs_rtmount_inodes( + xfs_sb_t *sbp; + + sbp = &mp->m_sb; +- if (sbp->sb_rbmino == NULLFSINO) +- return 0; + error = xfs_iget(mp, NULL, sbp->sb_rbmino, 0, 0, &mp->m_rbmip); + if (error) + return error; + ASSERT(mp->m_rbmip != NULL); +- ASSERT(sbp->sb_rsumino != NULLFSINO); ++ + error = xfs_iget(mp, NULL, sbp->sb_rsumino, 0, 0, &mp->m_rsumip); + if (error) { + IRELE(mp->m_rbmip); +diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h +index 206fe3bccccc..575f2dee8cf7 100644 +--- a/include/linux/genalloc.h ++++ b/include/linux/genalloc.h +@@ -50,7 +50,8 @@ typedef unsigned long (*genpool_algo_t)(unsigned long *map, + unsigned long size, + unsigned long start, + unsigned int nr, +- void *data, struct gen_pool *pool); ++ void *data, struct gen_pool *pool, ++ unsigned long start_addr); + + /* + * General purpose special memory pool descriptor. +@@ -130,24 +131,24 @@ extern void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo, + + extern unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool); ++ struct gen_pool *pool, unsigned long start_addr); + + extern unsigned long gen_pool_fixed_alloc(unsigned long *map, + unsigned long size, unsigned long start, unsigned int nr, +- void *data, struct gen_pool *pool); ++ void *data, struct gen_pool *pool, unsigned long start_addr); + + extern unsigned long gen_pool_first_fit_align(unsigned long *map, + unsigned long size, unsigned long start, unsigned int nr, +- void *data, struct gen_pool *pool); ++ void *data, struct gen_pool *pool, unsigned long start_addr); + + + extern unsigned long gen_pool_first_fit_order_align(unsigned long *map, + unsigned long size, unsigned long start, unsigned int nr, +- void *data, struct gen_pool *pool); ++ void *data, struct gen_pool *pool, unsigned long start_addr); + + extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool); ++ struct gen_pool *pool, unsigned long start_addr); + + + extern struct gen_pool *devm_gen_pool_create(struct device *dev, +diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h +index fb0fde686cb1..4a9838feb086 100644 +--- a/include/linux/gpio/consumer.h ++++ b/include/linux/gpio/consumer.h +@@ -398,7 +398,7 @@ static inline int gpiod_to_irq(const struct gpio_desc *desc) + + static inline struct gpio_desc *gpio_to_desc(unsigned gpio) + { +- return ERR_PTR(-EINVAL); ++ return NULL; + } + + static inline int desc_to_gpio(const struct gpio_desc *desc) +diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h +index 2ecf0f32444e..29ed5977ac04 100644 +--- a/include/linux/netdevice.h ++++ b/include/linux/netdevice.h +@@ -3565,7 +3565,7 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) + if (debug_value == 0) /* no output */ + return 0; + /* set low N bits */ +- return (1 << debug_value) - 1; ++ return (1U << debug_value) - 1; + } + + static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu) +diff --git a/include/linux/reset-controller.h b/include/linux/reset-controller.h +index db1fe6772ad5..b5542aff192c 100644 +--- a/include/linux/reset-controller.h ++++ b/include/linux/reset-controller.h +@@ -6,7 +6,7 @@ + struct reset_controller_dev; + + /** +- * struct reset_control_ops ++ * struct reset_control_ops - reset controller driver callbacks + * + * @reset: for self-deasserting resets, does all necessary + * things to reset the device +diff --git a/include/linux/swap.h b/include/linux/swap.h +index 2228907d08ff..d13617c7bcc4 100644 +--- a/include/linux/swap.h ++++ b/include/linux/swap.h +@@ -335,14 +335,8 @@ extern unsigned long vm_total_pages; + extern int node_reclaim_mode; + extern int sysctl_min_unmapped_ratio; + extern int sysctl_min_slab_ratio; +-extern int node_reclaim(struct pglist_data *, gfp_t, unsigned int); + #else + #define node_reclaim_mode 0 +-static inline int node_reclaim(struct pglist_data *pgdat, gfp_t mask, +- unsigned int order) +-{ +- return 0; +-} + #endif + + extern int page_evictable(struct page *page); +diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h +index 11c3bf262a85..b46133a41f55 100644 +--- a/include/net/sctp/structs.h ++++ b/include/net/sctp/structs.h +@@ -1202,6 +1202,9 @@ struct sctp_ep_common { + /* What socket does this endpoint belong to? */ + struct sock *sk; + ++ /* Cache netns and it won't change once set */ ++ struct net *net; ++ + /* This is where we receive inbound chunks. */ + struct sctp_inq inqueue; + +diff --git a/include/net/sock.h b/include/net/sock.h +index d8d14ae8892a..aed436567d70 100644 +--- a/include/net/sock.h ++++ b/include/net/sock.h +@@ -1201,7 +1201,7 @@ static inline void sk_sockets_allocated_inc(struct sock *sk) + percpu_counter_inc(sk->sk_prot->sockets_allocated); + } + +-static inline int ++static inline u64 + sk_sockets_allocated_read_positive(struct sock *sk) + { + return percpu_counter_read_positive(sk->sk_prot->sockets_allocated); +diff --git a/lib/genalloc.c b/lib/genalloc.c +index ca06adc4f445..7e85d1e37a6e 100644 +--- a/lib/genalloc.c ++++ b/lib/genalloc.c +@@ -35,6 +35,7 @@ + #include + #include + #include ++#include + + static inline size_t chunk_size(const struct gen_pool_chunk *chunk) + { +@@ -187,7 +188,7 @@ int gen_pool_add_virt(struct gen_pool *pool, unsigned long virt, phys_addr_t phy + int nbytes = sizeof(struct gen_pool_chunk) + + BITS_TO_LONGS(nbits) * sizeof(long); + +- chunk = kzalloc_node(nbytes, GFP_KERNEL, nid); ++ chunk = vzalloc_node(nbytes, nid); + if (unlikely(chunk == NULL)) + return -ENOMEM; + +@@ -251,7 +252,7 @@ void gen_pool_destroy(struct gen_pool *pool) + bit = find_next_bit(chunk->bits, end_bit, 0); + BUG_ON(bit < end_bit); + +- kfree(chunk); ++ vfree(chunk); + } + kfree_const(pool->name); + kfree(pool); +@@ -311,7 +312,7 @@ unsigned long gen_pool_alloc_algo(struct gen_pool *pool, size_t size, + end_bit = chunk_size(chunk) >> order; + retry: + start_bit = algo(chunk->bits, end_bit, start_bit, +- nbits, data, pool); ++ nbits, data, pool, chunk->start_addr); + if (start_bit >= end_bit) + continue; + remain = bitmap_set_ll(chunk->bits, start_bit, nbits); +@@ -525,7 +526,7 @@ EXPORT_SYMBOL(gen_pool_set_algo); + */ + unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool) ++ struct gen_pool *pool, unsigned long start_addr) + { + return bitmap_find_next_zero_area(map, size, start, nr, 0); + } +@@ -543,16 +544,19 @@ EXPORT_SYMBOL(gen_pool_first_fit); + */ + unsigned long gen_pool_first_fit_align(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool) ++ struct gen_pool *pool, unsigned long start_addr) + { + struct genpool_data_align *alignment; +- unsigned long align_mask; ++ unsigned long align_mask, align_off; + int order; + + alignment = data; + order = pool->min_alloc_order; + align_mask = ((alignment->align + (1UL << order) - 1) >> order) - 1; +- return bitmap_find_next_zero_area(map, size, start, nr, align_mask); ++ align_off = (start_addr & (alignment->align - 1)) >> order; ++ ++ return bitmap_find_next_zero_area_off(map, size, start, nr, ++ align_mask, align_off); + } + EXPORT_SYMBOL(gen_pool_first_fit_align); + +@@ -567,7 +571,7 @@ EXPORT_SYMBOL(gen_pool_first_fit_align); + */ + unsigned long gen_pool_fixed_alloc(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool) ++ struct gen_pool *pool, unsigned long start_addr) + { + struct genpool_data_fixed *fixed_data; + int order; +@@ -601,7 +605,8 @@ EXPORT_SYMBOL(gen_pool_fixed_alloc); + */ + unsigned long gen_pool_first_fit_order_align(unsigned long *map, + unsigned long size, unsigned long start, +- unsigned int nr, void *data, struct gen_pool *pool) ++ unsigned int nr, void *data, struct gen_pool *pool, ++ unsigned long start_addr) + { + unsigned long align_mask = roundup_pow_of_two(nr) - 1; + +@@ -624,7 +629,7 @@ EXPORT_SYMBOL(gen_pool_first_fit_order_align); + */ + unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size, + unsigned long start, unsigned int nr, void *data, +- struct gen_pool *pool) ++ struct gen_pool *pool, unsigned long start_addr) + { + unsigned long start_bit = size; + unsigned long len = size + 1; +diff --git a/mm/internal.h b/mm/internal.h +index 3e2d01694747..f6df7cb8cbc0 100644 +--- a/mm/internal.h ++++ b/mm/internal.h +@@ -442,6 +442,16 @@ static inline void mminit_validate_memmodel_limits(unsigned long *start_pfn, + #define NODE_RECLAIM_SOME 0 + #define NODE_RECLAIM_SUCCESS 1 + ++#ifdef CONFIG_NUMA ++extern int node_reclaim(struct pglist_data *, gfp_t, unsigned int); ++#else ++static inline int node_reclaim(struct pglist_data *pgdat, gfp_t mask, ++ unsigned int order) ++{ ++ return NODE_RECLAIM_NOSCAN; ++} ++#endif ++ + extern int hwpoison_filter(struct page *p); + + extern u32 hwpoison_filter_dev_major; +diff --git a/net/core/neighbour.c b/net/core/neighbour.c +index 6e964fec45cf..44a29be7bfff 100644 +--- a/net/core/neighbour.c ++++ b/net/core/neighbour.c +@@ -18,6 +18,7 @@ + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + + #include ++#include + #include + #include + #include +@@ -325,12 +326,14 @@ static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift) + ret = kmalloc(sizeof(*ret), GFP_ATOMIC); + if (!ret) + return NULL; +- if (size <= PAGE_SIZE) ++ if (size <= PAGE_SIZE) { + buckets = kzalloc(size, GFP_ATOMIC); +- else ++ } else { + buckets = (struct neighbour __rcu **) + __get_free_pages(GFP_ATOMIC | __GFP_ZERO, + get_order(size)); ++ kmemleak_alloc(buckets, size, 1, GFP_ATOMIC); ++ } + if (!buckets) { + kfree(ret); + return NULL; +@@ -350,10 +353,12 @@ static void neigh_hash_free_rcu(struct rcu_head *head) + size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *); + struct neighbour __rcu **buckets = nht->hash_buckets; + +- if (size <= PAGE_SIZE) ++ if (size <= PAGE_SIZE) { + kfree(buckets); +- else ++ } else { ++ kmemleak_free(buckets); + free_pages((unsigned long)buckets, get_order(size)); ++ } + kfree(nht); + } + +diff --git a/net/core/net_namespace.c b/net/core/net_namespace.c +index 4509dec7bd1c..7630fa80db92 100644 +--- a/net/core/net_namespace.c ++++ b/net/core/net_namespace.c +@@ -802,7 +802,8 @@ static int __init net_ns_init(void) + + mutex_unlock(&net_mutex); + +- register_pernet_subsys(&net_ns_ops); ++ if (register_pernet_subsys(&net_ns_ops)) ++ panic("Could not register network namespace subsystems"); + + rtnl_register(PF_UNSPEC, RTM_NEWNSID, rtnl_net_newid, NULL, NULL); + rtnl_register(PF_UNSPEC, RTM_GETNSID, rtnl_net_getid, rtnl_net_dumpid, +diff --git a/net/core/sock.c b/net/core/sock.c +index d22493351407..41794a698da6 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -2156,7 +2156,7 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind) + } + + if (sk_has_memory_pressure(sk)) { +- int alloc; ++ u64 alloc; + + if (!sk_under_memory_pressure(sk)) + return 1; +diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c +index b2c26b081134..80554e7e9a0f 100644 +--- a/net/decnet/dn_dev.c ++++ b/net/decnet/dn_dev.c +@@ -55,7 +55,7 @@ + #include + #include + +-#define DN_IFREQ_SIZE (sizeof(struct ifreq) - sizeof(struct sockaddr) + sizeof(struct sockaddr_dn)) ++#define DN_IFREQ_SIZE (offsetof(struct ifreq, ifr_ifru) + sizeof(struct sockaddr_dn)) + + static char dn_rt_all_end_mcast[ETH_ALEN] = {0xAB,0x00,0x00,0x04,0x00,0x00}; + static char dn_rt_all_rt_mcast[ETH_ALEN] = {0xAB,0x00,0x00,0x03,0x00,0x00}; +diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c +index e6ee6acac80c..a4db2d79b913 100644 +--- a/net/ipv4/ip_tunnel.c ++++ b/net/ipv4/ip_tunnel.c +@@ -653,13 +653,19 @@ void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev, + dst = tnl_params->daddr; + if (dst == 0) { + /* NBMA tunnel */ ++ struct ip_tunnel_info *tun_info; + + if (!skb_dst(skb)) { + dev->stats.tx_fifo_errors++; + goto tx_error; + } + +- if (skb->protocol == htons(ETH_P_IP)) { ++ tun_info = skb_tunnel_info(skb); ++ if (tun_info && (tun_info->mode & IP_TUNNEL_INFO_TX) && ++ ip_tunnel_info_af(tun_info) == AF_INET && ++ tun_info->key.u.ipv4.dst) ++ dst = tun_info->key.u.ipv4.dst; ++ else if (skb->protocol == htons(ETH_P_IP)) { + rt = skb_rtable(skb); + dst = rt_nexthop(rt, inner_iph->daddr); + } +diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c +index 892c392ff8fc..8e8a185dbb9b 100644 +--- a/net/mac80211/sta_info.c ++++ b/net/mac80211/sta_info.c +@@ -2305,7 +2305,8 @@ unsigned long ieee80211_sta_last_active(struct sta_info *sta) + { + struct ieee80211_sta_rx_stats *stats = sta_get_last_rx_stats(sta); + +- if (time_after(stats->last_rx, sta->status_stats.last_ack)) ++ if (!sta->status_stats.last_ack || ++ time_after(stats->last_rx, sta->status_stats.last_ack)) + return stats->last_rx; + return sta->status_stats.last_ack; + } +diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c +index 0ddcc63a0247..c28f0e2a7c3c 100644 +--- a/net/openvswitch/datapath.c ++++ b/net/openvswitch/datapath.c +@@ -738,9 +738,13 @@ static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions *acts, + { + size_t len = NLMSG_ALIGN(sizeof(struct ovs_header)); + +- /* OVS_FLOW_ATTR_UFID */ ++ /* OVS_FLOW_ATTR_UFID, or unmasked flow key as fallback ++ * see ovs_nla_put_identifier() ++ */ + if (sfid && ovs_identifier_is_ufid(sfid)) + len += nla_total_size(sfid->ufid_len); ++ else ++ len += nla_total_size(ovs_key_attr_size()); + + /* OVS_FLOW_ATTR_KEY */ + if (!sfid || should_fill_key(sfid, ufid_flags)) +@@ -916,7 +920,10 @@ static struct sk_buff *ovs_flow_cmd_build_info(const struct sw_flow *flow, + retval = ovs_flow_cmd_fill_info(flow, dp_ifindex, skb, + info->snd_portid, info->snd_seq, 0, + cmd, ufid_flags); +- BUG_ON(retval < 0); ++ if (WARN_ON_ONCE(retval < 0)) { ++ kfree_skb(skb); ++ skb = ERR_PTR(retval); ++ } + return skb; + } + +@@ -1343,7 +1350,10 @@ static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info) + OVS_FLOW_CMD_DEL, + ufid_flags); + rcu_read_unlock(); +- BUG_ON(err < 0); ++ if (WARN_ON_ONCE(err < 0)) { ++ kfree_skb(reply); ++ goto out_free; ++ } + + ovs_notify(&dp_flow_genl_family, reply, info); + } else { +@@ -1351,6 +1361,7 @@ static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info) + } + } + ++out_free: + ovs_flow_free(flow, true); + return 0; + unlock: +diff --git a/net/sched/sch_mq.c b/net/sched/sch_mq.c +index 20b7f1646f69..c3c4c09ab289 100644 +--- a/net/sched/sch_mq.c ++++ b/net/sched/sch_mq.c +@@ -195,7 +195,8 @@ static int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl, + struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + + sch = dev_queue->qdisc_sleeping; +- if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || ++ if (gnet_stats_copy_basic(&sch->running, d, sch->cpu_bstats, ++ &sch->bstats) < 0 || + gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + return -1; + return 0; +diff --git a/net/sched/sch_mqprio.c b/net/sched/sch_mqprio.c +index 922683418e53..1451fa180e6c 100644 +--- a/net/sched/sch_mqprio.c ++++ b/net/sched/sch_mqprio.c +@@ -362,8 +362,8 @@ static int mqprio_dump_class_stats(struct Qdisc *sch, unsigned long cl, + struct netdev_queue *dev_queue = mqprio_queue_get(sch, cl); + + sch = dev_queue->qdisc_sleeping; +- if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), +- d, NULL, &sch->bstats) < 0 || ++ if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), d, ++ sch->cpu_bstats, &sch->bstats) < 0 || + gnet_stats_copy_queue(d, NULL, + &sch->qstats, sch->q.qlen) < 0) + return -1; +diff --git a/net/sched/sch_multiq.c b/net/sched/sch_multiq.c +index 66b6e807b4ec..4a8680b1f861 100644 +--- a/net/sched/sch_multiq.c ++++ b/net/sched/sch_multiq.c +@@ -332,7 +332,7 @@ static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl, + + cl_q = q->queues[cl - 1]; + if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), +- d, NULL, &cl_q->bstats) < 0 || ++ d, cl_q->cpu_bstats, &cl_q->bstats) < 0 || + gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0) + return -1; + +diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c +index 8f575899adfa..2cca1ead96b5 100644 +--- a/net/sched/sch_prio.c ++++ b/net/sched/sch_prio.c +@@ -286,7 +286,7 @@ static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl, + + cl_q = q->queues[cl - 1]; + if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), +- d, NULL, &cl_q->bstats) < 0 || ++ d, cl_q->cpu_bstats, &cl_q->bstats) < 0 || + gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0) + return -1; + +diff --git a/net/sctp/associola.c b/net/sctp/associola.c +index 7e127cde1ccc..16e120b84118 100644 +--- a/net/sctp/associola.c ++++ b/net/sctp/associola.c +@@ -81,6 +81,7 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a + /* Discarding const is appropriate here. */ + asoc->ep = (struct sctp_endpoint *)ep; + asoc->base.sk = (struct sock *)sk; ++ asoc->base.net = sock_net(sk); + + sctp_endpoint_hold(asoc->ep); + sock_hold(asoc->base.sk); +diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c +index beae42bfa68f..8164d0275137 100644 +--- a/net/sctp/endpointola.c ++++ b/net/sctp/endpointola.c +@@ -163,6 +163,7 @@ static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep, + + /* Remember who we are attached to. */ + ep->base.sk = sk; ++ ep->base.net = sock_net(sk); + sock_hold(ep->base.sk); + + return ep; +diff --git a/net/sctp/input.c b/net/sctp/input.c +index 68b84d3a7cac..969fb1623e4e 100644 +--- a/net/sctp/input.c ++++ b/net/sctp/input.c +@@ -812,7 +812,7 @@ static inline int sctp_hash_cmp(struct rhashtable_compare_arg *arg, + return err; + + asoc = t->asoc; +- if (!net_eq(sock_net(asoc->base.sk), x->net)) ++ if (!net_eq(asoc->base.net, x->net)) + goto out; + if (x->ep) { + if (x->ep != asoc->ep) +@@ -835,7 +835,7 @@ static inline u32 sctp_hash_obj(const void *data, u32 len, u32 seed) + { + const struct sctp_transport *t = data; + const union sctp_addr *paddr = &t->ipaddr; +- const struct net *net = sock_net(t->asoc->base.sk); ++ const struct net *net = t->asoc->base.net; + u16 lport = htons(t->asoc->base.bind_addr.port); + u32 addr; + +diff --git a/net/sctp/transport.c b/net/sctp/transport.c +index 03d71cd97ec0..5c78942550e9 100644 +--- a/net/sctp/transport.c ++++ b/net/sctp/transport.c +@@ -205,7 +205,8 @@ void sctp_transport_reset_hb_timer(struct sctp_transport *transport) + + /* When a data chunk is sent, reset the heartbeat interval. */ + expires = jiffies + sctp_transport_timeout(transport); +- if (time_before(transport->hb_timer.expires, expires) && ++ if ((time_before(transport->hb_timer.expires, expires) || ++ !timer_pending(&transport->hb_timer)) && + !mod_timer(&transport->hb_timer, + expires + prandom_u32_max(transport->rto))) + sctp_transport_hold(transport); +diff --git a/net/tipc/link.c b/net/tipc/link.c +index 4e8647aef01c..c7406c1fdc14 100644 +--- a/net/tipc/link.c ++++ b/net/tipc/link.c +@@ -1063,7 +1063,7 @@ static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb, + default: + pr_warn("Dropping received illegal msg type\n"); + kfree_skb(skb); +- return false; ++ return true; + }; + } + +diff --git a/net/tipc/netlink_compat.c b/net/tipc/netlink_compat.c +index 63a913b23873..cdc49e680be4 100644 +--- a/net/tipc/netlink_compat.c ++++ b/net/tipc/netlink_compat.c +@@ -539,7 +539,7 @@ static int tipc_nl_compat_link_stat_dump(struct tipc_nl_compat_msg *msg, + if (len <= 0) + return -EINVAL; + +- len = min_t(int, len, TIPC_MAX_BEARER_NAME); ++ len = min_t(int, len, TIPC_MAX_LINK_NAME); + if (!string_is_valid(name, len)) + return -EINVAL; + +@@ -821,7 +821,7 @@ static int tipc_nl_compat_link_reset_stats(struct tipc_nl_compat_cmd_doit *cmd, + if (len <= 0) + return -EINVAL; + +- len = min_t(int, len, TIPC_MAX_BEARER_NAME); ++ len = min_t(int, len, TIPC_MAX_LINK_NAME); + if (!string_is_valid(name, len)) + return -EINVAL; + +@@ -974,6 +974,10 @@ static int tipc_nl_compat_publ_dump(struct tipc_nl_compat_msg *msg, u32 sock) + + hdr = genlmsg_put(args, 0, 0, &tipc_genl_family, NLM_F_MULTI, + TIPC_NL_PUBL_GET); ++ if (!hdr) { ++ kfree_skb(args); ++ return -EMSGSIZE; ++ } + + nest = nla_nest_start(args, TIPC_NLA_SOCK); + if (!nest) { +diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c +index 7566395e526d..18f377306884 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -97,6 +97,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -501,9 +502,13 @@ out: + static int __vsock_bind_stream(struct vsock_sock *vsk, + struct sockaddr_vm *addr) + { +- static u32 port = LAST_RESERVED_PORT + 1; ++ static u32 port = 0; + struct sockaddr_vm new_addr; + ++ if (!port) ++ port = LAST_RESERVED_PORT + 1 + ++ prandom_u32_max(U32_MAX - LAST_RESERVED_PORT); ++ + vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port); + + if (addr->svm_port == VMADDR_PORT_ANY) { +diff --git a/scripts/gdb/linux/symbols.py b/scripts/gdb/linux/symbols.py +index 004b0ac7fa72..4644f1a83b57 100644 +--- a/scripts/gdb/linux/symbols.py ++++ b/scripts/gdb/linux/symbols.py +@@ -99,7 +99,8 @@ lx-symbols command.""" + attrs[n]['name'].string(): attrs[n]['address'] + for n in range(int(sect_attrs['nsections']))} + args = [] +- for section_name in [".data", ".data..read_mostly", ".rodata", ".bss"]: ++ for section_name in [".data", ".data..read_mostly", ".rodata", ".bss", ++ ".text", ".text.hot", ".text.unlikely"]: + address = section_name_to_address.get(section_name) + if address: + args.append(" -s {name} {addr}".format( +diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c +index 2e2d18468491..7ae8e24dc1e6 100644 +--- a/sound/core/compress_offload.c ++++ b/sound/core/compress_offload.c +@@ -529,7 +529,7 @@ static int snd_compress_check_input(struct snd_compr_params *params) + { + /* first let's check the buffer parameter's */ + if (params->buffer.fragment_size == 0 || +- params->buffer.fragments > INT_MAX / params->buffer.fragment_size || ++ params->buffer.fragments > U32_MAX / params->buffer.fragment_size || + params->buffer.fragments == 0) + return -EINVAL; + +diff --git a/sound/soc/kirkwood/kirkwood-i2s.c b/sound/soc/kirkwood/kirkwood-i2s.c +index 3a36d60e1785..0a5d9fb6fc84 100644 +--- a/sound/soc/kirkwood/kirkwood-i2s.c ++++ b/sound/soc/kirkwood/kirkwood-i2s.c +@@ -570,10 +570,6 @@ static int kirkwood_i2s_dev_probe(struct platform_device *pdev) + return PTR_ERR(priv->clk); + } + +- err = clk_prepare_enable(priv->clk); +- if (err < 0) +- return err; +- + priv->extclk = devm_clk_get(&pdev->dev, "extclk"); + if (IS_ERR(priv->extclk)) { + if (PTR_ERR(priv->extclk) == -EPROBE_DEFER) +@@ -589,6 +585,10 @@ static int kirkwood_i2s_dev_probe(struct platform_device *pdev) + } + } + ++ err = clk_prepare_enable(priv->clk); ++ if (err < 0) ++ return err; ++ + /* Some sensible defaults - this reflects the powerup values */ + priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24; + priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;