commit: d9a7b48394c11e665ecac4ddb28dfae1fb8a2a42 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Thu Dec 5 14:45:17 2019 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Thu Dec 5 14:45:17 2019 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=d9a7b483
Linux patch 4.4.206 Signed-off-by: Alice Ferrazzi <alicef <AT> gentoo.org> 0000_README | 8 + 1205_linux-4.4.206.patch | 2291 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2299 insertions(+) diff --git a/0000_README b/0000_README index 72fc76b..56d20ec 100644 --- a/0000_README +++ b/0000_README @@ -859,6 +859,14 @@ Patch: 1203_linux-4.4.204.patch From: http://www.kernel.org Desc: Linux 4.4.204 +Patch: 1204_linux-4.4.205.patch +From: http://www.kernel.org +Desc: Linux 4.4.204 + +Patch: 1205_linux-4.4.206.patch +From: http://www.kernel.org +Desc: Linux 4.4.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.4.206.patch b/1205_linux-4.4.206.patch new file mode 100644 index 0000000..a97fee2 --- /dev/null +++ b/1205_linux-4.4.206.patch @@ -0,0 +1,2291 @@ +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 9f97365b4bc6..eb4f5b889a1c 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 4 +-SUBLEVEL = 205 ++SUBLEVEL = 206 + EXTRAVERSION = + NAME = Blurry Fish Butt + +diff --git a/arch/arm/Kconfig.debug b/arch/arm/Kconfig.debug +index ddbb361267d8..9c3042da4440 100644 +--- a/arch/arm/Kconfig.debug ++++ b/arch/arm/Kconfig.debug +@@ -1260,21 +1260,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 9f9c0441a917..e372609c48dd 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/smp.c b/arch/arm64/kernel/smp.c +index 03c0946b79d2..7e90f429f7e5 100644 +--- a/arch/arm64/kernel/smp.c ++++ b/arch/arm64/kernel/smp.c +@@ -115,6 +115,7 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle) + } + } 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.<dt> - ELF image with $(arch)/boot/dts/<dt>.dts linked in' +- echo ' - stripped elf with fdt blob' +- echo ' simpleImage.<dt>.unstrip - full ELF image with fdt blob' +- echo ' *_defconfig - Select default config from arch/microblaze/configs' +- echo '' ++ echo ' simpleImage.<dt> - Create the following images with <dt>.dtb linked in' ++ echo ' simpleImage.<dt> : raw image' ++ echo ' simpleImage.<dt>.ub : raw image with U-Boot header' ++ echo ' simpleImage.<dt>.unstrip: ELF (identical to vmlinux)' ++ echo ' simpleImage.<dt>.strip : stripped ELF' + echo ' Targets with <dt> 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 <dt> 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/kernel/prom.c b/arch/powerpc/kernel/prom.c +index a15fe1d4e84a..04a27307a2c4 100644 +--- a/arch/powerpc/kernel/prom.c ++++ b/arch/powerpc/kernel/prom.c +@@ -125,7 +125,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"); +@@ -647,7 +647,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)) +@@ -707,7 +707,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 d154e333f76b..d1f860ca03ad 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 6b2f3e457171..ae0f157d201c 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_mapped_by_bats(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_mapped_by_bats(unsigned long va) + unsigned long p_mapped_by_bats(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/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c +index a8efed3b4691..551ba5b35df9 100644 +--- a/arch/powerpc/platforms/pseries/dlpar.c ++++ b/arch/powerpc/platforms/pseries/dlpar.c +@@ -55,6 +55,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/xmon/xmon.c b/arch/powerpc/xmon/xmon.c +index 83619ebede93..dc2ebc20a96f 100644 +--- a/arch/powerpc/xmon/xmon.c ++++ b/arch/powerpc/xmon/xmon.c +@@ -2840,7 +2840,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 3e46f62d32ad..b4032d625d22 100644 +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -185,17 +185,28 @@ void kvm_arch_hardware_unsetup(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; + } + + /* 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/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/crypto/crypto_user.c b/crypto/crypto_user.c +index b93c6db18ed3..f18dc2d045c2 100644 +--- a/crypto/crypto_user.c ++++ b/crypto/crypto_user.c +@@ -257,30 +257,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) +@@ -498,7 +501,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; +@@ -506,16 +509,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 572755e557d6..e54e6170981b 100644 +--- a/drivers/acpi/acpi_lpss.c ++++ b/drivers/acpi/acpi_lpss.c +@@ -405,12 +405,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); +diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c +index bb81cd05f0bc..d532aa87eef1 100644 +--- a/drivers/acpi/apei/ghes.c ++++ b/drivers/acpi/apei/ghes.c +@@ -198,40 +198,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/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c +index 1d58854c4a9f..385ec4ae3394 100644 +--- a/drivers/block/drbd/drbd_main.c ++++ b/drivers/block/drbd/drbd_main.c +@@ -792,7 +792,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 27e1abcf5710..4adbf4c8d532 100644 +--- a/drivers/block/drbd/drbd_nl.c ++++ b/drivers/block/drbd/drbd_nl.c +@@ -1685,9 +1685,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 b1ee358edd3b..afd8f315d29b 100644 +--- a/drivers/block/drbd/drbd_receiver.c ++++ b/drivers/block/drbd/drbd_receiver.c +@@ -4116,6 +4116,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 7f53c40823cd..75219cd2534a 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_stat + 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 530aacca3eb8..7c4a721952ef 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/samsung/clk-exynos5420.c b/drivers/clk/samsung/clk-exynos5420.c +index bde71b07f15e..c94de13ce362 100644 +--- a/drivers/clk/samsung/clk-exynos5420.c ++++ b/drivers/clk/samsung/clk-exynos5420.c +@@ -166,12 +166,18 @@ static unsigned long exynos5x_clk_regs[] __initdata = { + 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/hid/hid-core.c b/drivers/hid/hid-core.c +index 8c61a35c160d..c60bb6f8eceb 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/infiniband/hw/qib/qib_sdma.c b/drivers/infiniband/hw/qib/qib_sdma.c +index c6d6a54d2e19..1c9a3e875201 100644 +--- a/drivers/infiniband/hw/qib/qib_sdma.c ++++ b/drivers/infiniband/hw/qib/qib_sdma.c +@@ -597,8 +597,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 3dbc3ed263c2..3b4188efc283 100644 +--- a/drivers/infiniband/ulp/srp/ib_srp.c ++++ b/drivers/infiniband/ulp/srp/ib_srp.c +@@ -2135,6 +2135,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/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c +index 3140ffbb1e67..9932b276f11a 100644 +--- a/drivers/media/v4l2-core/v4l2-ctrls.c ++++ b/drivers/media/v4l2-core/v4l2-ctrls.c +@@ -991,6 +991,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 be74a25708b2..864c2dc728a9 100644 +--- a/drivers/misc/mei/bus.c ++++ b/drivers/misc/mei/bus.c +@@ -761,15 +761,16 @@ static struct device_type mei_cl_device_type = { + + /** + * mei_cl_bus_set_name - set device name for me client device ++ * <controller>-<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 7b0353399a10..b837f4471682 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 f8ba153f63bf..59772510452a 100644 +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -610,10 +610,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); +@@ -658,28 +669,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/ubi/build.c b/drivers/mtd/ubi/build.c +index c9f5ae424af7..ae8e55b4f6f9 100644 +--- a/drivers/mtd/ubi/build.c ++++ b/drivers/mtd/ubi/build.c +@@ -1141,10 +1141,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 e844887732fb..1db375caef71 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/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c +index 59a03a193e83..4384b2b4d238 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 085f77f273ba..75bdb6aad352 100644 +--- a/drivers/net/ethernet/cadence/macb.c ++++ b/drivers/net/ethernet/cadence/macb.c +@@ -2275,14 +2275,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; + } + +@@ -2292,19 +2292,19 @@ 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; + } + +@@ -2704,7 +2704,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/sfc/ef10.c b/drivers/net/ethernet/sfc/ef10.c +index 063aca17e698..6dcd436e6e32 100644 +--- a/drivers/net/ethernet/sfc/ef10.c ++++ b/drivers/net/ethernet/sfc/ef10.c +@@ -4433,22 +4433,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; + } +@@ -4461,6 +4464,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); +@@ -4489,6 +4499,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; +@@ -4517,11 +4528,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 adff46375a32..6e56c4e5ecec 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 9897cabec371..4002bd90201f 100644 +--- a/drivers/net/macvlan.c ++++ b/drivers/net/macvlan.c +@@ -326,10 +326,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 d34bdd2f7ac7..ef6b25ec75a1 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/wireless/ath/ath6kl/cfg80211.c b/drivers/net/wireless/ath/ath6kl/cfg80211.c +index 81ac8c59f0ec..7653fa47508b 100644 +--- a/drivers/net/wireless/ath/ath6kl/cfg80211.c ++++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c +@@ -932,7 +932,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; + } + +@@ -1083,7 +1083,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/mwifiex/debugfs.c b/drivers/net/wireless/mwifiex/debugfs.c +index 45d97b64ef84..f72c4f885311 100644 +--- a/drivers/net/wireless/mwifiex/debugfs.c ++++ b/drivers/net/wireless/mwifiex/debugfs.c +@@ -295,15 +295,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"); + } +@@ -332,7 +330,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/mwifiex/scan.c b/drivers/net/wireless/mwifiex/scan.c +index b3fa3e4bed05..39b78dc1bd92 100644 +--- a/drivers/net/wireless/mwifiex/scan.c ++++ b/drivers/net/wireless/mwifiex/scan.c +@@ -1873,15 +1873,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 b3691712df61..60e77eaa4ce9 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/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 9842bb106796..c691b2e34374 100644 +--- a/drivers/pinctrl/sh-pfc/pfc-sh7734.c ++++ b/drivers/pinctrl/sh-pfc/pfc-sh7734.c +@@ -2218,22 +2218,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 847f75601591..530d8d9bbdbb 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 { +@@ -199,7 +199,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 }; +@@ -207,7 +207,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 db9973bb53f1..ecc59798fd0a 100644 +--- a/drivers/power/avs/smartreflex.c ++++ b/drivers/power/avs/smartreflex.c +@@ -1001,8 +1001,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 6911f9662300..5e582099ebaa 100644 +--- a/drivers/pwm/core.c ++++ b/drivers/pwm/core.c +@@ -781,6 +781,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-samsung.c b/drivers/pwm/pwm-samsung.c +index ada2d326dc3e..42f270ef2f7b 100644 +--- a/drivers/pwm/pwm-samsung.c ++++ b/drivers/pwm/pwm-samsung.c +@@ -226,7 +226,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 8217613807d3..4a4766c43e61 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 bae36cc3740b..ab6bff60478f 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) +@@ -3361,6 +3370,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 +@@ -3476,6 +3486,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 81af294f15a7..b1233ce6cb47 100644 +--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c ++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c +@@ -793,38 +793,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; +@@ -843,24 +819,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 3bbf4cb6fd97..344f4eab5403 100644 +--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.h ++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.h +@@ -47,9 +47,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 8f989a95a019..fa7a89357d64 100644 +--- a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c ++++ b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c +@@ -1631,14 +1631,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 a66fb7afecc7..e13e95733fa3 100644 +--- a/drivers/tty/serial/max310x.c ++++ b/drivers/tty/serial/max310x.c +@@ -763,12 +763,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 2998da6bd901..8388f88ce635 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/xen/xen-pciback/pci_stub.c b/drivers/xen/xen-pciback/pci_stub.c +index 258b7c325649..47c6df53cabf 100644 +--- a/drivers/xen/xen-pciback/pci_stub.c ++++ b/drivers/xen/xen-pciback/pci_stub.c +@@ -104,7 +104,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 e06dd75ad13f..a2f165029ee6 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, +@@ -444,7 +442,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 09476bb8f6cd..f0302e09eff9 100644 +--- a/fs/gfs2/bmap.c ++++ b/fs/gfs2/bmap.c +@@ -1235,6 +1235,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 722eb5bc9b8f..2301011428a1 100644 +--- a/fs/ocfs2/journal.c ++++ b/fs/ocfs2/journal.c +@@ -1017,7 +1017,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 +@@ -1026,9 +1027,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 1a05d8ae327d..e7372cef5ac3 100644 +--- a/fs/xfs/xfs_ioctl32.c ++++ b/fs/xfs/xfs_ioctl32.c +@@ -346,6 +346,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 +381,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 ab1bac6a3a1c..919b6544b61a 100644 +--- a/fs/xfs/xfs_rtalloc.c ++++ b/fs/xfs/xfs_rtalloc.c +@@ -1225,13 +1225,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/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 0b211d482c96..861b71377e5e 100644 +--- a/include/linux/netdevice.h ++++ b/include/linux/netdevice.h +@@ -3298,7 +3298,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 ce6b962ffed4..842f70fcfc48 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/net/sock.h b/include/net/sock.h +index 5ed4786a2058..de4434284a34 100644 +--- a/include/net/sock.h ++++ b/include/net/sock.h +@@ -1282,7 +1282,7 @@ static inline void sk_sockets_allocated_inc(struct sock *sk) + percpu_counter_inc(prot->sockets_allocated); + } + +-static inline int ++static inline u64 + sk_sockets_allocated_read_positive(struct sock *sk) + { + struct proto *prot = sk->sk_prot; +diff --git a/lib/genalloc.c b/lib/genalloc.c +index e4303fb2a7b2..e3a475b14e26 100644 +--- a/lib/genalloc.c ++++ b/lib/genalloc.c +@@ -35,6 +35,7 @@ + #include <linux/interrupt.h> + #include <linux/genalloc.h> + #include <linux/of_device.h> ++#include <linux/vmalloc.h> + + 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); +diff --git a/net/core/neighbour.c b/net/core/neighbour.c +index b3b242f7ecfd..8aef689b8f32 100644 +--- a/net/core/neighbour.c ++++ b/net/core/neighbour.c +@@ -18,6 +18,7 @@ + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + + #include <linux/slab.h> ++#include <linux/kmemleak.h> + #include <linux/types.h> + #include <linux/kernel.h> + #include <linux/module.h> +@@ -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 087ce1598b74..01bfe28b20a1 100644 +--- a/net/core/net_namespace.c ++++ b/net/core/net_namespace.c +@@ -778,7 +778,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 8aa4a5f89572..0f4c15fcd87d 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -2122,7 +2122,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 <net/dn_neigh.h> + #include <net/dn_fib.h> + +-#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/openvswitch/datapath.c b/net/openvswitch/datapath.c +index caa23ee913f0..82ca7fe7a163 100644 +--- a/net/openvswitch/datapath.c ++++ b/net/openvswitch/datapath.c +@@ -725,9 +725,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)) +@@ -900,7 +904,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; + } + +@@ -1318,7 +1325,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 { +@@ -1326,6 +1336,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 d9c84328e7eb..b34992808879 100644 +--- a/net/sched/sch_mq.c ++++ b/net/sched/sch_mq.c +@@ -195,7 +195,7 @@ 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(d, NULL, &sch->bstats) < 0 || ++ if (gnet_stats_copy_basic(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 66bccc5ff4ea..03c19adb2e61 100644 +--- a/net/sched/sch_mqprio.c ++++ b/net/sched/sch_mqprio.c +@@ -355,7 +355,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(d, NULL, &sch->bstats) < 0 || ++ if (gnet_stats_copy_basic(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 cef36ad691dd..be3d78357fbb 100644 +--- a/net/sched/sch_multiq.c ++++ b/net/sched/sch_multiq.c +@@ -351,7 +351,7 @@ static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl, + struct Qdisc *cl_q; + + cl_q = q->queues[cl - 1]; +- if (gnet_stats_copy_basic(d, NULL, &cl_q->bstats) < 0 || ++ if (gnet_stats_copy_basic(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 fee1b15506b2..ca9fb2b0c14a 100644 +--- a/net/sched/sch_prio.c ++++ b/net/sched/sch_prio.c +@@ -319,7 +319,7 @@ static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl, + struct Qdisc *cl_q; + + cl_q = q->queues[cl - 1]; +- if (gnet_stats_copy_basic(d, NULL, &cl_q->bstats) < 0 || ++ if (gnet_stats_copy_basic(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/tipc/link.c b/net/tipc/link.c +index 736fffb28ab6..0080699b7cd1 100644 +--- a/net/tipc/link.c ++++ b/net/tipc/link.c +@@ -883,7 +883,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 d2bf92e71150..8d2e54c4bda6 100644 +--- a/net/tipc/netlink_compat.c ++++ b/net/tipc/netlink_compat.c +@@ -516,7 +516,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; + +@@ -791,7 +791,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; + +@@ -926,6 +926,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 7f1d166ce612..412d56614fd5 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -89,6 +89,7 @@ + #include <linux/mutex.h> + #include <linux/net.h> + #include <linux/poll.h> ++#include <linux/random.h> + #include <linux/skbuff.h> + #include <linux/smp.h> + #include <linux/socket.h> +@@ -483,9 +484,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 627750cb420d..9b71c65504a3 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 771d7b334ad8..07f5017cbea2 100644 +--- a/sound/core/compress_offload.c ++++ b/sound/core/compress_offload.c +@@ -501,7 +501,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;
