diff options
author | Mike Pagano <mpagano@gentoo.org> | 2020-05-02 15:23:44 -0400 |
---|---|---|
committer | Mike Pagano <mpagano@gentoo.org> | 2020-05-02 15:23:44 -0400 |
commit | d2975282a07e1079c8befdd23086852956fe4493 (patch) | |
tree | 38878af64ca60ead8390ce13663c9b8b44f4f6bf | |
parent | Linux patch 4.19.119 (diff) | |
download | linux-patches-d2975282.tar.gz linux-patches-d2975282.tar.bz2 linux-patches-d2975282.zip |
Linux patch 4.19.1204.19-119
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
-rw-r--r-- | 0000_README | 4 | ||||
-rw-r--r-- | 1119_linux-4.19.120.patch | 1834 |
2 files changed, 1838 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 36e1c220..88502985 100644 --- a/0000_README +++ b/0000_README @@ -515,6 +515,10 @@ Patch: 1118_linux-4.19.119.patch From: https://www.kernel.org Desc: Linux 4.19.119 +Patch: 1119_linux-4.19.120.patch +From: https://www.kernel.org +Desc: Linux 4.19.120 + 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/1119_linux-4.19.120.patch b/1119_linux-4.19.120.patch new file mode 100644 index 00000000..6f1d7616 --- /dev/null +++ b/1119_linux-4.19.120.patch @@ -0,0 +1,1834 @@ +diff --git a/Makefile b/Makefile +index 69c95fe6fba5..74b60bf2ff79 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 119 ++SUBLEVEL = 120 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/arm/boot/dts/bcm283x.dtsi b/arch/arm/boot/dts/bcm283x.dtsi +index c9322a56300d..f9add515301f 100644 +--- a/arch/arm/boot/dts/bcm283x.dtsi ++++ b/arch/arm/boot/dts/bcm283x.dtsi +@@ -476,6 +476,7 @@ + "dsi0_ddr2", + "dsi0_ddr"; + ++ status = "disabled"; + }; + + thermal: thermal@7e212000 { +diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sysreg.h +index 3091ae5975a3..ed99d941c462 100644 +--- a/arch/arm64/include/asm/sysreg.h ++++ b/arch/arm64/include/asm/sysreg.h +@@ -60,7 +60,9 @@ + #ifndef CONFIG_BROKEN_GAS_INST + + #ifdef __ASSEMBLY__ +-#define __emit_inst(x) .inst (x) ++// The space separator is omitted so that __emit_inst(x) can be parsed as ++// either an assembler directive or an assembler macro argument. ++#define __emit_inst(x) .inst(x) + #else + #define __emit_inst(x) ".inst " __stringify((x)) "\n\t" + #endif +diff --git a/arch/x86/kernel/cpu/mshyperv.c b/arch/x86/kernel/cpu/mshyperv.c +index fc93ae325515..f8b0fa2dbe37 100644 +--- a/arch/x86/kernel/cpu/mshyperv.c ++++ b/arch/x86/kernel/cpu/mshyperv.c +@@ -214,8 +214,8 @@ static void __init ms_hyperv_init_platform(void) + ms_hyperv.misc_features = cpuid_edx(HYPERV_CPUID_FEATURES); + ms_hyperv.hints = cpuid_eax(HYPERV_CPUID_ENLIGHTMENT_INFO); + +- pr_info("Hyper-V: features 0x%x, hints 0x%x\n", +- ms_hyperv.features, ms_hyperv.hints); ++ pr_info("Hyper-V: features 0x%x, hints 0x%x, misc 0x%x\n", ++ ms_hyperv.features, ms_hyperv.hints, ms_hyperv.misc_features); + + ms_hyperv.max_vp_index = cpuid_eax(HYPERV_CPUID_IMPLEMENT_LIMITS); + ms_hyperv.max_lp_index = cpuid_ebx(HYPERV_CPUID_IMPLEMENT_LIMITS); +diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c +index a32fc3d99407..46ab92831251 100644 +--- a/arch/x86/net/bpf_jit_comp.c ++++ b/arch/x86/net/bpf_jit_comp.c +@@ -142,6 +142,19 @@ static bool is_ereg(u32 reg) + BIT(BPF_REG_AX)); + } + ++/* ++ * is_ereg_8l() == true if BPF register 'reg' is mapped to access x86-64 ++ * lower 8-bit registers dil,sil,bpl,spl,r8b..r15b, which need extra byte ++ * of encoding. al,cl,dl,bl have simpler encoding. ++ */ ++static bool is_ereg_8l(u32 reg) ++{ ++ return is_ereg(reg) || ++ (1 << reg) & (BIT(BPF_REG_1) | ++ BIT(BPF_REG_2) | ++ BIT(BPF_REG_FP)); ++} ++ + static bool is_axreg(u32 reg) + { + return reg == BPF_REG_0; +@@ -751,9 +764,8 @@ st: if (is_imm8(insn->off)) + /* STX: *(u8*)(dst_reg + off) = src_reg */ + case BPF_STX | BPF_MEM | BPF_B: + /* Emit 'mov byte ptr [rax + off], al' */ +- if (is_ereg(dst_reg) || is_ereg(src_reg) || +- /* We have to add extra byte for x86 SIL, DIL regs */ +- src_reg == BPF_REG_1 || src_reg == BPF_REG_2) ++ if (is_ereg(dst_reg) || is_ereg_8l(src_reg)) ++ /* Add extra byte for eregs or SIL,DIL,BPL in src_reg */ + EMIT2(add_2mod(0x40, dst_reg, src_reg), 0x88); + else + EMIT1(0x88); +diff --git a/arch/x86/net/bpf_jit_comp32.c b/arch/x86/net/bpf_jit_comp32.c +index 24d573bc550d..2eaf1900ba67 100644 +--- a/arch/x86/net/bpf_jit_comp32.c ++++ b/arch/x86/net/bpf_jit_comp32.c +@@ -1830,7 +1830,9 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, + STACK_VAR(dst_hi)); + EMIT(0x0, 4); + } else { +- EMIT3(0xC7, add_1reg(0xC0, dst_hi), 0); ++ /* xor dst_hi,dst_hi */ ++ EMIT2(0x33, ++ add_2reg(0xC0, dst_hi, dst_hi)); + } + break; + case BPF_DW: +@@ -1968,8 +1970,8 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, + goto emit_cond_jmp_signed; + } + case BPF_JMP | BPF_JSET | BPF_X: { +- u8 dreg_lo = dstk ? IA32_EAX : dst_lo; +- u8 dreg_hi = dstk ? IA32_EDX : dst_hi; ++ u8 dreg_lo = IA32_EAX; ++ u8 dreg_hi = IA32_EDX; + u8 sreg_lo = sstk ? IA32_ECX : src_lo; + u8 sreg_hi = sstk ? IA32_EBX : src_hi; + +@@ -1978,6 +1980,12 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, + STACK_VAR(dst_lo)); + EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EDX), + STACK_VAR(dst_hi)); ++ } else { ++ /* mov dreg_lo,dst_lo */ ++ EMIT2(0x89, add_2reg(0xC0, dreg_lo, dst_lo)); ++ /* mov dreg_hi,dst_hi */ ++ EMIT2(0x89, ++ add_2reg(0xC0, dreg_hi, dst_hi)); + } + + if (sstk) { +@@ -1996,8 +2004,8 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, + } + case BPF_JMP | BPF_JSET | BPF_K: { + u32 hi; +- u8 dreg_lo = dstk ? IA32_EAX : dst_lo; +- u8 dreg_hi = dstk ? IA32_EDX : dst_hi; ++ u8 dreg_lo = IA32_EAX; ++ u8 dreg_hi = IA32_EDX; + u8 sreg_lo = IA32_ECX; + u8 sreg_hi = IA32_EBX; + +@@ -2006,6 +2014,12 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, + STACK_VAR(dst_lo)); + EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EDX), + STACK_VAR(dst_hi)); ++ } else { ++ /* mov dreg_lo,dst_lo */ ++ EMIT2(0x89, add_2reg(0xC0, dreg_lo, dst_lo)); ++ /* mov dreg_hi,dst_hi */ ++ EMIT2(0x89, ++ add_2reg(0xC0, dreg_hi, dst_hi)); + } + hi = imm32 & (1<<31) ? (u32)~0 : 0; + +diff --git a/drivers/android/binder_alloc.c b/drivers/android/binder_alloc.c +index c3fdd79c4082..6e5e6fb7e4c9 100644 +--- a/drivers/android/binder_alloc.c ++++ b/drivers/android/binder_alloc.c +@@ -970,8 +970,8 @@ enum lru_status binder_alloc_free_page(struct list_head *item, + mm = alloc->vma_vm_mm; + if (!mmget_not_zero(mm)) + goto err_mmget; +- if (!down_write_trylock(&mm->mmap_sem)) +- goto err_down_write_mmap_sem_failed; ++ if (!down_read_trylock(&mm->mmap_sem)) ++ goto err_down_read_mmap_sem_failed; + vma = binder_alloc_get_vma(alloc); + + list_lru_isolate(lru, item); +@@ -986,7 +986,7 @@ enum lru_status binder_alloc_free_page(struct list_head *item, + + trace_binder_unmap_user_end(alloc, index); + } +- up_write(&mm->mmap_sem); ++ up_read(&mm->mmap_sem); + mmput(mm); + + trace_binder_unmap_kernel_start(alloc, index); +@@ -1001,7 +1001,7 @@ enum lru_status binder_alloc_free_page(struct list_head *item, + mutex_unlock(&alloc->mutex); + return LRU_REMOVED_RETRY; + +-err_down_write_mmap_sem_failed: ++err_down_read_mmap_sem_failed: + mmput_async(mm); + err_mmget: + err_page_already_freed: +diff --git a/drivers/hwmon/jc42.c b/drivers/hwmon/jc42.c +index e5234f953a6d..b6e5aaa54963 100644 +--- a/drivers/hwmon/jc42.c ++++ b/drivers/hwmon/jc42.c +@@ -527,7 +527,7 @@ static int jc42_probe(struct i2c_client *client, const struct i2c_device_id *id) + } + data->config = config; + +- hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, ++ hwmon_dev = devm_hwmon_device_register_with_info(dev, "jc42", + data, &jc42_chip_info, + NULL); + return PTR_ERR_OR_ZERO(hwmon_dev); +diff --git a/drivers/i2c/busses/i2c-altera.c b/drivers/i2c/busses/i2c-altera.c +index a1cdcfc74acf..8915ee30a5b4 100644 +--- a/drivers/i2c/busses/i2c-altera.c ++++ b/drivers/i2c/busses/i2c-altera.c +@@ -395,7 +395,6 @@ static int altr_i2c_probe(struct platform_device *pdev) + struct altr_i2c_dev *idev = NULL; + struct resource *res; + int irq, ret; +- u32 val; + + idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL); + if (!idev) +@@ -422,17 +421,17 @@ static int altr_i2c_probe(struct platform_device *pdev) + init_completion(&idev->msg_complete); + spin_lock_init(&idev->lock); + +- val = device_property_read_u32(idev->dev, "fifo-size", ++ ret = device_property_read_u32(idev->dev, "fifo-size", + &idev->fifo_size); +- if (val) { ++ if (ret) { + dev_err(&pdev->dev, "FIFO size set to default of %d\n", + ALTR_I2C_DFLT_FIFO_SZ); + idev->fifo_size = ALTR_I2C_DFLT_FIFO_SZ; + } + +- val = device_property_read_u32(idev->dev, "clock-frequency", ++ ret = device_property_read_u32(idev->dev, "clock-frequency", + &idev->bus_clk_rate); +- if (val) { ++ if (ret) { + dev_err(&pdev->dev, "Default to 100kHz\n"); + idev->bus_clk_rate = 100000; /* default clock rate */ + } +diff --git a/drivers/iio/adc/ad7793.c b/drivers/iio/adc/ad7793.c +index d4bbe5b53318..23a6e7baa396 100644 +--- a/drivers/iio/adc/ad7793.c ++++ b/drivers/iio/adc/ad7793.c +@@ -542,7 +542,7 @@ static const struct iio_info ad7797_info = { + .read_raw = &ad7793_read_raw, + .write_raw = &ad7793_write_raw, + .write_raw_get_fmt = &ad7793_write_raw_get_fmt, +- .attrs = &ad7793_attribute_group, ++ .attrs = &ad7797_attribute_group, + .validate_trigger = ad_sd_validate_trigger, + }; + +diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c +index ba44ea6d497e..1dbc9554a078 100644 +--- a/drivers/mtd/chips/cfi_cmdset_0002.c ++++ b/drivers/mtd/chips/cfi_cmdset_0002.c +@@ -1882,7 +1882,11 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip, + continue; + } + +- if (time_after(jiffies, timeo) && !chip_ready(map, adr)) ++ /* ++ * We check "time_after" and "!chip_good" before checking "chip_good" to avoid ++ * the failure due to scheduling. ++ */ ++ if (time_after(jiffies, timeo) && !chip_good(map, adr, datum)) + break; + + if (chip_good(map, adr, datum)) { +diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c +index 8350c0c9b89d..5934ec9b6a31 100644 +--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c ++++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c +@@ -3748,7 +3748,7 @@ int t4_phy_fw_ver(struct adapter *adap, int *phy_fw_ver) + FW_PARAMS_PARAM_Z_V(FW_PARAMS_PARAM_DEV_PHYFW_VERSION)); + ret = t4_query_params(adap, adap->mbox, adap->pf, 0, 1, + ¶m, &val); +- if (ret < 0) ++ if (ret) + return ret; + *phy_fw_ver = val; + return 0; +diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h +index bf80855dd0dd..d06a89e99872 100644 +--- a/drivers/net/ethernet/freescale/fec.h ++++ b/drivers/net/ethernet/freescale/fec.h +@@ -488,6 +488,12 @@ struct fec_enet_priv_rx_q { + struct sk_buff *rx_skbuff[RX_RING_SIZE]; + }; + ++struct fec_stop_mode_gpr { ++ struct regmap *gpr; ++ u8 reg; ++ u8 bit; ++}; ++ + /* The FEC buffer descriptors track the ring buffers. The rx_bd_base and + * tx_bd_base always point to the base of the buffer descriptors. The + * cur_rx and cur_tx point to the currently available buffer. +@@ -563,6 +569,7 @@ struct fec_enet_private { + int hwts_tx_en; + struct delayed_work time_keep; + struct regulator *reg_phy; ++ struct fec_stop_mode_gpr stop_gpr; + + unsigned int tx_align; + unsigned int rx_align; +diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c +index 9142992ccd5a..48c58f93b124 100644 +--- a/drivers/net/ethernet/freescale/fec_main.c ++++ b/drivers/net/ethernet/freescale/fec_main.c +@@ -62,6 +62,8 @@ + #include <linux/if_vlan.h> + #include <linux/pinctrl/consumer.h> + #include <linux/prefetch.h> ++#include <linux/mfd/syscon.h> ++#include <linux/regmap.h> + #include <soc/imx/cpuidle.h> + + #include <asm/cacheflush.h> +@@ -84,6 +86,56 @@ static void fec_enet_itr_coal_init(struct net_device *ndev); + #define FEC_ENET_OPD_V 0xFFF0 + #define FEC_MDIO_PM_TIMEOUT 100 /* ms */ + ++struct fec_devinfo { ++ u32 quirks; ++ u8 stop_gpr_reg; ++ u8 stop_gpr_bit; ++}; ++ ++static const struct fec_devinfo fec_imx25_info = { ++ .quirks = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR | ++ FEC_QUIRK_HAS_FRREG, ++}; ++ ++static const struct fec_devinfo fec_imx27_info = { ++ .quirks = FEC_QUIRK_MIB_CLEAR | FEC_QUIRK_HAS_FRREG, ++}; ++ ++static const struct fec_devinfo fec_imx28_info = { ++ .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME | ++ FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC | ++ FEC_QUIRK_HAS_FRREG, ++}; ++ ++static const struct fec_devinfo fec_imx6q_info = { ++ .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | ++ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | ++ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 | ++ FEC_QUIRK_HAS_RACC, ++ .stop_gpr_reg = 0x34, ++ .stop_gpr_bit = 27, ++}; ++ ++static const struct fec_devinfo fec_mvf600_info = { ++ .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_RACC, ++}; ++ ++static const struct fec_devinfo fec_imx6x_info = { ++ .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | ++ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | ++ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB | ++ FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE | ++ FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE, ++}; ++ ++static const struct fec_devinfo fec_imx6ul_info = { ++ .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | ++ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | ++ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR007885 | ++ FEC_QUIRK_BUG_CAPTURE | FEC_QUIRK_HAS_RACC | ++ FEC_QUIRK_HAS_COALESCE, ++}; ++ + static struct platform_device_id fec_devtype[] = { + { + /* keep it for coldfire */ +@@ -91,39 +143,25 @@ static struct platform_device_id fec_devtype[] = { + .driver_data = 0, + }, { + .name = "imx25-fec", +- .driver_data = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR | +- FEC_QUIRK_HAS_FRREG, ++ .driver_data = (kernel_ulong_t)&fec_imx25_info, + }, { + .name = "imx27-fec", +- .driver_data = FEC_QUIRK_MIB_CLEAR | FEC_QUIRK_HAS_FRREG, ++ .driver_data = (kernel_ulong_t)&fec_imx27_info, + }, { + .name = "imx28-fec", +- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME | +- FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC | +- FEC_QUIRK_HAS_FRREG, ++ .driver_data = (kernel_ulong_t)&fec_imx28_info, + }, { + .name = "imx6q-fec", +- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | +- FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | +- FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 | +- FEC_QUIRK_HAS_RACC, ++ .driver_data = (kernel_ulong_t)&fec_imx6q_info, + }, { + .name = "mvf600-fec", +- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_RACC, ++ .driver_data = (kernel_ulong_t)&fec_mvf600_info, + }, { + .name = "imx6sx-fec", +- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | +- FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | +- FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB | +- FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE | +- FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE, ++ .driver_data = (kernel_ulong_t)&fec_imx6x_info, + }, { + .name = "imx6ul-fec", +- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT | +- FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM | +- FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR007885 | +- FEC_QUIRK_BUG_CAPTURE | FEC_QUIRK_HAS_RACC | +- FEC_QUIRK_HAS_COALESCE, ++ .driver_data = (kernel_ulong_t)&fec_imx6ul_info, + }, { + /* sentinel */ + } +@@ -1089,11 +1127,28 @@ fec_restart(struct net_device *ndev) + + } + ++static void fec_enet_stop_mode(struct fec_enet_private *fep, bool enabled) ++{ ++ struct fec_platform_data *pdata = fep->pdev->dev.platform_data; ++ struct fec_stop_mode_gpr *stop_gpr = &fep->stop_gpr; ++ ++ if (stop_gpr->gpr) { ++ if (enabled) ++ regmap_update_bits(stop_gpr->gpr, stop_gpr->reg, ++ BIT(stop_gpr->bit), ++ BIT(stop_gpr->bit)); ++ else ++ regmap_update_bits(stop_gpr->gpr, stop_gpr->reg, ++ BIT(stop_gpr->bit), 0); ++ } else if (pdata && pdata->sleep_mode_enable) { ++ pdata->sleep_mode_enable(enabled); ++ } ++} ++ + static void + fec_stop(struct net_device *ndev) + { + struct fec_enet_private *fep = netdev_priv(ndev); +- struct fec_platform_data *pdata = fep->pdev->dev.platform_data; + u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8); + u32 val; + +@@ -1122,9 +1177,7 @@ fec_stop(struct net_device *ndev) + val = readl(fep->hwp + FEC_ECNTRL); + val |= (FEC_ECR_MAGICEN | FEC_ECR_SLEEP); + writel(val, fep->hwp + FEC_ECNTRL); +- +- if (pdata && pdata->sleep_mode_enable) +- pdata->sleep_mode_enable(true); ++ fec_enet_stop_mode(fep, true); + } + writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED); + +@@ -3347,6 +3400,37 @@ static int fec_enet_get_irq_cnt(struct platform_device *pdev) + return irq_cnt; + } + ++static int fec_enet_init_stop_mode(struct fec_enet_private *fep, ++ struct fec_devinfo *dev_info, ++ struct device_node *np) ++{ ++ struct device_node *gpr_np; ++ int ret = 0; ++ ++ if (!dev_info) ++ return 0; ++ ++ gpr_np = of_parse_phandle(np, "gpr", 0); ++ if (!gpr_np) ++ return 0; ++ ++ fep->stop_gpr.gpr = syscon_node_to_regmap(gpr_np); ++ if (IS_ERR(fep->stop_gpr.gpr)) { ++ dev_err(&fep->pdev->dev, "could not find gpr regmap\n"); ++ ret = PTR_ERR(fep->stop_gpr.gpr); ++ fep->stop_gpr.gpr = NULL; ++ goto out; ++ } ++ ++ fep->stop_gpr.reg = dev_info->stop_gpr_reg; ++ fep->stop_gpr.bit = dev_info->stop_gpr_bit; ++ ++out: ++ of_node_put(gpr_np); ++ ++ return ret; ++} ++ + static int + fec_probe(struct platform_device *pdev) + { +@@ -3362,6 +3446,7 @@ fec_probe(struct platform_device *pdev) + int num_rx_qs; + char irq_name[8]; + int irq_cnt; ++ struct fec_devinfo *dev_info; + + fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs); + +@@ -3379,7 +3464,9 @@ fec_probe(struct platform_device *pdev) + of_id = of_match_device(fec_dt_ids, &pdev->dev); + if (of_id) + pdev->id_entry = of_id->data; +- fep->quirks = pdev->id_entry->driver_data; ++ dev_info = (struct fec_devinfo *)pdev->id_entry->driver_data; ++ if (dev_info) ++ fep->quirks = dev_info->quirks; + + fep->netdev = ndev; + fep->num_rx_queues = num_rx_qs; +@@ -3414,6 +3501,10 @@ fec_probe(struct platform_device *pdev) + if (of_get_property(np, "fsl,magic-packet", NULL)) + fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET; + ++ ret = fec_enet_init_stop_mode(fep, dev_info, np); ++ if (ret) ++ goto failed_stop_mode; ++ + phy_node = of_parse_phandle(np, "phy-handle", 0); + if (!phy_node && of_phy_is_fixed_link(np)) { + ret = of_phy_register_fixed_link(np); +@@ -3583,6 +3674,7 @@ failed_clk: + if (of_phy_is_fixed_link(np)) + of_phy_deregister_fixed_link(np); + of_node_put(phy_node); ++failed_stop_mode: + failed_phy: + dev_id--; + failed_ioremap: +@@ -3660,7 +3752,6 @@ static int __maybe_unused fec_resume(struct device *dev) + { + struct net_device *ndev = dev_get_drvdata(dev); + struct fec_enet_private *fep = netdev_priv(ndev); +- struct fec_platform_data *pdata = fep->pdev->dev.platform_data; + int ret; + int val; + +@@ -3678,8 +3769,8 @@ static int __maybe_unused fec_resume(struct device *dev) + goto failed_clk; + } + if (fep->wol_flag & FEC_WOL_FLAG_ENABLE) { +- if (pdata && pdata->sleep_mode_enable) +- pdata->sleep_mode_enable(false); ++ fec_enet_stop_mode(fep, false); ++ + val = readl(fep->hwp + FEC_ECNTRL); + val &= ~(FEC_ECR_MAGICEN | FEC_ECR_SLEEP); + writel(val, fep->hwp + FEC_ECNTRL); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c b/drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c +index d4ec93bde4de..2266c09b741a 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c +@@ -796,7 +796,7 @@ struct mlx5_fw_tracer *mlx5_fw_tracer_create(struct mlx5_core_dev *dev) + return NULL; + } + +- tracer = kzalloc(sizeof(*tracer), GFP_KERNEL); ++ tracer = kvzalloc(sizeof(*tracer), GFP_KERNEL); + if (!tracer) + return ERR_PTR(-ENOMEM); + +@@ -842,7 +842,7 @@ destroy_workqueue: + tracer->dev = NULL; + destroy_workqueue(tracer->work_queue); + free_tracer: +- kfree(tracer); ++ kvfree(tracer); + return ERR_PTR(err); + } + +@@ -919,7 +919,7 @@ void mlx5_fw_tracer_destroy(struct mlx5_fw_tracer *tracer) + mlx5_fw_tracer_destroy_log_buf(tracer); + flush_workqueue(tracer->work_queue); + destroy_workqueue(tracer->work_queue); +- kfree(tracer); ++ kvfree(tracer); + } + + void mlx5_fw_tracer_event(struct mlx5_core_dev *dev, struct mlx5_eqe *eqe) +diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev.c b/drivers/net/ethernet/qlogic/qed/qed_dev.c +index a6a9688db307..e50fc8f714dc 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_dev.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_dev.c +@@ -3316,26 +3316,20 @@ static void qed_chain_free_single(struct qed_dev *cdev, + + static void qed_chain_free_pbl(struct qed_dev *cdev, struct qed_chain *p_chain) + { +- void **pp_virt_addr_tbl = p_chain->pbl.pp_virt_addr_tbl; ++ struct addr_tbl_entry *pp_addr_tbl = p_chain->pbl.pp_addr_tbl; + u32 page_cnt = p_chain->page_cnt, i, pbl_size; +- u8 *p_pbl_virt = p_chain->pbl_sp.p_virt_table; + +- if (!pp_virt_addr_tbl) ++ if (!pp_addr_tbl) + return; + +- if (!p_pbl_virt) +- goto out; +- + for (i = 0; i < page_cnt; i++) { +- if (!pp_virt_addr_tbl[i]) ++ if (!pp_addr_tbl[i].virt_addr || !pp_addr_tbl[i].dma_map) + break; + + dma_free_coherent(&cdev->pdev->dev, + QED_CHAIN_PAGE_SIZE, +- pp_virt_addr_tbl[i], +- *(dma_addr_t *)p_pbl_virt); +- +- p_pbl_virt += QED_CHAIN_PBL_ENTRY_SIZE; ++ pp_addr_tbl[i].virt_addr, ++ pp_addr_tbl[i].dma_map); + } + + pbl_size = page_cnt * QED_CHAIN_PBL_ENTRY_SIZE; +@@ -3345,9 +3339,9 @@ static void qed_chain_free_pbl(struct qed_dev *cdev, struct qed_chain *p_chain) + pbl_size, + p_chain->pbl_sp.p_virt_table, + p_chain->pbl_sp.p_phys_table); +-out: +- vfree(p_chain->pbl.pp_virt_addr_tbl); +- p_chain->pbl.pp_virt_addr_tbl = NULL; ++ ++ vfree(p_chain->pbl.pp_addr_tbl); ++ p_chain->pbl.pp_addr_tbl = NULL; + } + + void qed_chain_free(struct qed_dev *cdev, struct qed_chain *p_chain) +@@ -3448,19 +3442,19 @@ qed_chain_alloc_pbl(struct qed_dev *cdev, + { + u32 page_cnt = p_chain->page_cnt, size, i; + dma_addr_t p_phys = 0, p_pbl_phys = 0; +- void **pp_virt_addr_tbl = NULL; ++ struct addr_tbl_entry *pp_addr_tbl; + u8 *p_pbl_virt = NULL; + void *p_virt = NULL; + +- size = page_cnt * sizeof(*pp_virt_addr_tbl); +- pp_virt_addr_tbl = vzalloc(size); +- if (!pp_virt_addr_tbl) ++ size = page_cnt * sizeof(*pp_addr_tbl); ++ pp_addr_tbl = vzalloc(size); ++ if (!pp_addr_tbl) + return -ENOMEM; + + /* The allocation of the PBL table is done with its full size, since it + * is expected to be successive. + * qed_chain_init_pbl_mem() is called even in a case of an allocation +- * failure, since pp_virt_addr_tbl was previously allocated, and it ++ * failure, since tbl was previously allocated, and it + * should be saved to allow its freeing during the error flow. + */ + size = page_cnt * QED_CHAIN_PBL_ENTRY_SIZE; +@@ -3474,8 +3468,7 @@ qed_chain_alloc_pbl(struct qed_dev *cdev, + p_chain->b_external_pbl = true; + } + +- qed_chain_init_pbl_mem(p_chain, p_pbl_virt, p_pbl_phys, +- pp_virt_addr_tbl); ++ qed_chain_init_pbl_mem(p_chain, p_pbl_virt, p_pbl_phys, pp_addr_tbl); + if (!p_pbl_virt) + return -ENOMEM; + +@@ -3494,7 +3487,8 @@ qed_chain_alloc_pbl(struct qed_dev *cdev, + /* Fill the PBL table with the physical address of the page */ + *(dma_addr_t *)p_pbl_virt = p_phys; + /* Keep the virtual address of the page */ +- p_chain->pbl.pp_virt_addr_tbl[i] = p_virt; ++ p_chain->pbl.pp_addr_tbl[i].virt_addr = p_virt; ++ p_chain->pbl.pp_addr_tbl[i].dma_map = p_phys; + + p_pbl_virt += QED_CHAIN_PBL_ENTRY_SIZE; + } +diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c +index 9e20ace30b62..ca41cff2e68c 100644 +--- a/drivers/pci/quirks.c ++++ b/drivers/pci/quirks.c +@@ -5282,3 +5282,21 @@ out_disable: + DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, 0x13b1, + PCI_CLASS_DISPLAY_VGA, 8, + quirk_reset_lenovo_thinkpad_p50_nvgpu); ++ ++/* ++ * Device [1b21:2142] ++ * When in D0, PME# doesn't get asserted when plugging USB 3.0 device. ++ */ ++static void pci_fixup_no_d0_pme(struct pci_dev *dev) ++{ ++ pci_info(dev, "PME# does not work under D0, disabling it\n"); ++ dev->pme_support &= ~(PCI_PM_CAP_PME_D0 >> PCI_PM_CAP_PME_SHIFT); ++} ++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ASMEDIA, 0x2142, pci_fixup_no_d0_pme); ++ ++static void apex_pci_fixup_class(struct pci_dev *pdev) ++{ ++ pdev->class = (PCI_CLASS_SYSTEM_OTHER << 8) | pdev->class; ++} ++DECLARE_PCI_FIXUP_CLASS_HEADER(0x1ac1, 0x089a, ++ PCI_CLASS_NOT_DEFINED, 8, apex_pci_fixup_class); +diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c +index abbef17c97ee..d5ff272fde34 100644 +--- a/drivers/remoteproc/remoteproc_core.c ++++ b/drivers/remoteproc/remoteproc_core.c +@@ -289,7 +289,7 @@ void rproc_free_vring(struct rproc_vring *rvring) + { + int size = PAGE_ALIGN(vring_size(rvring->len, rvring->align)); + struct rproc *rproc = rvring->rvdev->rproc; +- int idx = rvring->rvdev->vring - rvring; ++ int idx = rvring - rvring->rvdev->vring; + struct fw_rsc_vdev *rsc; + + dma_free_coherent(rproc->dev.parent, size, rvring->va, rvring->dma); +diff --git a/drivers/staging/gasket/apex_driver.c b/drivers/staging/gasket/apex_driver.c +index 0cef1d6d2e2b..99da735bdf6d 100644 +--- a/drivers/staging/gasket/apex_driver.c ++++ b/drivers/staging/gasket/apex_driver.c +@@ -578,13 +578,6 @@ static const struct pci_device_id apex_pci_ids[] = { + { PCI_DEVICE(APEX_PCI_VENDOR_ID, APEX_PCI_DEVICE_ID) }, { 0 } + }; + +-static void apex_pci_fixup_class(struct pci_dev *pdev) +-{ +- pdev->class = (PCI_CLASS_SYSTEM_OTHER << 8) | pdev->class; +-} +-DECLARE_PCI_FIXUP_CLASS_HEADER(APEX_PCI_VENDOR_ID, APEX_PCI_DEVICE_ID, +- PCI_CLASS_NOT_DEFINED, 8, apex_pci_fixup_class); +- + static int apex_pci_probe(struct pci_dev *pci_dev, + const struct pci_device_id *id) + { +diff --git a/drivers/target/target_core_fabric_lib.c b/drivers/target/target_core_fabric_lib.c +index 10fae26b44ad..939c6212d2ac 100644 +--- a/drivers/target/target_core_fabric_lib.c ++++ b/drivers/target/target_core_fabric_lib.c +@@ -76,7 +76,7 @@ static int fc_get_pr_transport_id( + * encoded TransportID. + */ + ptr = &se_nacl->initiatorname[0]; +- for (i = 0; i < 24; ) { ++ for (i = 0; i < 23; ) { + if (!strncmp(&ptr[i], ":", 1)) { + i++; + continue; +diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c +index 7ee0a75ce452..eff1e36ca03c 100644 +--- a/drivers/target/target_core_user.c ++++ b/drivers/target/target_core_user.c +@@ -2067,6 +2067,7 @@ static void tcmu_reset_ring(struct tcmu_dev *udev, u8 err_level) + mb->cmd_tail = 0; + mb->cmd_head = 0; + tcmu_flush_dcache_range(mb, sizeof(*mb)); ++ clear_bit(TCMU_DEV_BIT_BROKEN, &udev->flags); + + del_timer(&udev->cmd_timer); + +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 8222e674c777..1a6c973da487 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -1577,7 +1577,6 @@ static int __dwc3_gadget_wakeup(struct dwc3 *dwc) + u32 reg; + + u8 link_state; +- u8 speed; + + /* + * According to the Databook Remote wakeup request should +@@ -1587,16 +1586,13 @@ static int __dwc3_gadget_wakeup(struct dwc3 *dwc) + */ + reg = dwc3_readl(dwc->regs, DWC3_DSTS); + +- speed = reg & DWC3_DSTS_CONNECTSPD; +- if ((speed == DWC3_DSTS_SUPERSPEED) || +- (speed == DWC3_DSTS_SUPERSPEED_PLUS)) +- return 0; +- + link_state = DWC3_DSTS_USBLNKST(reg); + + switch (link_state) { ++ case DWC3_LINK_STATE_RESET: + case DWC3_LINK_STATE_RX_DET: /* in HS, means Early Suspend */ + case DWC3_LINK_STATE_U3: /* in HS, means SUSPEND */ ++ case DWC3_LINK_STATE_RESUME: + break; + default: + return -EINVAL; +diff --git a/drivers/usb/gadget/udc/bdc/bdc_ep.c b/drivers/usb/gadget/udc/bdc/bdc_ep.c +index a4d9b5e1e50e..d49c6dc1082d 100644 +--- a/drivers/usb/gadget/udc/bdc/bdc_ep.c ++++ b/drivers/usb/gadget/udc/bdc/bdc_ep.c +@@ -540,7 +540,7 @@ static void bdc_req_complete(struct bdc_ep *ep, struct bdc_req *req, + { + struct bdc *bdc = ep->bdc; + +- if (req == NULL || &req->queue == NULL || &req->usb_req == NULL) ++ if (req == NULL) + return; + + dev_dbg(bdc->dev, "%s ep:%s status:%d\n", __func__, ep->name, status); +diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c +index a1c17000129b..e94a61eaeceb 100644 +--- a/drivers/xen/xenbus/xenbus_client.c ++++ b/drivers/xen/xenbus/xenbus_client.c +@@ -450,7 +450,14 @@ EXPORT_SYMBOL_GPL(xenbus_free_evtchn); + int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs, + unsigned int nr_grefs, void **vaddr) + { +- return ring_ops->map(dev, gnt_refs, nr_grefs, vaddr); ++ int err; ++ ++ err = ring_ops->map(dev, gnt_refs, nr_grefs, vaddr); ++ /* Some hypervisors are buggy and can return 1. */ ++ if (err > 0) ++ err = GNTST_general_error; ++ ++ return err; + } + EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc); + +diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c +index dafa7e4aaecb..8876eaad10f6 100644 +--- a/fs/ext4/ialloc.c ++++ b/fs/ext4/ialloc.c +@@ -665,7 +665,7 @@ static int find_group_other(struct super_block *sb, struct inode *parent, + * block has been written back to disk. (Yes, these values are + * somewhat arbitrary...) + */ +-#define RECENTCY_MIN 5 ++#define RECENTCY_MIN 60 + #define RECENTCY_DIRTY 300 + + static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino) +diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c +index 000fa0e39278..3b1a7597af15 100644 +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -2128,7 +2128,7 @@ static int ext4_writepage(struct page *page, + bool keep_towrite = false; + + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) { +- ext4_invalidatepage(page, 0, PAGE_SIZE); ++ inode->i_mapping->a_ops->invalidatepage(page, 0, PAGE_SIZE); + unlock_page(page); + return -EIO; + } +diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c +index 71121fcf9e8c..8dd54a8a0361 100644 +--- a/fs/ext4/mballoc.c ++++ b/fs/ext4/mballoc.c +@@ -1936,7 +1936,8 @@ void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac, + int free; + + free = e4b->bd_info->bb_free; +- BUG_ON(free <= 0); ++ if (WARN_ON(free <= 0)) ++ return; + + i = e4b->bd_info->bb_first_free; + +@@ -1959,7 +1960,8 @@ void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac, + } + + mb_find_extent(e4b, i, ac->ac_g_ex.fe_len, &ex); +- BUG_ON(ex.fe_len <= 0); ++ if (WARN_ON(ex.fe_len <= 0)) ++ break; + if (free < ex.fe_len) { + ext4_grp_locked_error(sb, e4b->bd_group, 0, 0, + "%d free clusters as per " +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index bf949fcc970a..93c14ecac831 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -3524,7 +3524,8 @@ int ext4_calculate_overhead(struct super_block *sb) + */ + if (sbi->s_journal && !sbi->journal_bdev) + overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_maxlen); +- else if (ext4_has_feature_journal(sb) && !sbi->s_journal) { ++ else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) { ++ /* j_inum for internal journal is non-zero */ + j_inode = ext4_get_journal_inode(sb, j_inum); + if (j_inode) { + j_blocks = j_inode->i_size >> sb->s_blocksize_bits; +diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c +index ed73e86194fa..c24306af9758 100644 +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -252,6 +252,8 @@ find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh, + if (!nbl) { + nbl= kmalloc(sizeof(*nbl), GFP_KERNEL); + if (nbl) { ++ INIT_LIST_HEAD(&nbl->nbl_list); ++ INIT_LIST_HEAD(&nbl->nbl_lru); + fh_copy_shallow(&nbl->nbl_fh, fh); + locks_init_lock(&nbl->nbl_lock); + nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client, +diff --git a/fs/pnode.c b/fs/pnode.c +index 53d411a371ce..7910ae91f17e 100644 +--- a/fs/pnode.c ++++ b/fs/pnode.c +@@ -266,14 +266,13 @@ static int propagate_one(struct mount *m) + if (IS_ERR(child)) + return PTR_ERR(child); + child->mnt.mnt_flags &= ~MNT_LOCKED; ++ read_seqlock_excl(&mount_lock); + mnt_set_mountpoint(m, mp, child); ++ if (m->mnt_master != dest_master) ++ SET_MNT_MARK(m->mnt_master); ++ read_sequnlock_excl(&mount_lock); + last_dest = m; + last_source = child; +- if (m->mnt_master != dest_master) { +- read_seqlock_excl(&mount_lock); +- SET_MNT_MARK(m->mnt_master); +- read_sequnlock_excl(&mount_lock); +- } + hlist_add_head(&child->mnt_hash, list); + return count_mounts(m->mnt_ns, child); + } +diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c +index 245483cc282b..901f27ac94ab 100644 +--- a/fs/xfs/xfs_icache.c ++++ b/fs/xfs/xfs_icache.c +@@ -902,7 +902,12 @@ xfs_eofblocks_worker( + { + struct xfs_mount *mp = container_of(to_delayed_work(work), + struct xfs_mount, m_eofblocks_work); ++ ++ if (!sb_start_write_trylock(mp->m_super)) ++ return; + xfs_icache_free_eofblocks(mp, NULL); ++ sb_end_write(mp->m_super); ++ + xfs_queue_eofblocks(mp); + } + +@@ -929,7 +934,12 @@ xfs_cowblocks_worker( + { + struct xfs_mount *mp = container_of(to_delayed_work(work), + struct xfs_mount, m_cowblocks_work); ++ ++ if (!sb_start_write_trylock(mp->m_super)) ++ return; + xfs_icache_free_cowblocks(mp, NULL); ++ sb_end_write(mp->m_super); ++ + xfs_queue_cowblocks(mp); + } + +diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c +index bad90479ade2..6ffb53edf1b4 100644 +--- a/fs/xfs/xfs_ioctl.c ++++ b/fs/xfs/xfs_ioctl.c +@@ -2182,7 +2182,10 @@ xfs_file_ioctl( + if (error) + return error; + +- return xfs_icache_free_eofblocks(mp, &keofb); ++ sb_start_write(mp->m_super); ++ error = xfs_icache_free_eofblocks(mp, &keofb); ++ sb_end_write(mp->m_super); ++ return error; + } + + default: +diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c +index f3c393f309e1..6622652a85a8 100644 +--- a/fs/xfs/xfs_reflink.c ++++ b/fs/xfs/xfs_reflink.c +@@ -1058,6 +1058,7 @@ xfs_reflink_remap_extent( + uirec.br_startblock = irec->br_startblock + rlen; + uirec.br_startoff = irec->br_startoff + rlen; + uirec.br_blockcount = unmap_len - rlen; ++ uirec.br_state = irec->br_state; + unmap_len = rlen; + + /* If this isn't a real mapping, we're done. */ +diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c +index d3a4e89bf4a0..66f167aefd94 100644 +--- a/fs/xfs/xfs_trans_ail.c ++++ b/fs/xfs/xfs_trans_ail.c +@@ -520,8 +520,9 @@ xfsaild( + { + struct xfs_ail *ailp = data; + long tout = 0; /* milliseconds */ ++ unsigned int noreclaim_flag; + +- current->flags |= PF_MEMALLOC; ++ noreclaim_flag = memalloc_noreclaim_save(); + set_freezable(); + + while (1) { +@@ -592,6 +593,7 @@ xfsaild( + tout = xfsaild_push(ailp); + } + ++ memalloc_noreclaim_restore(noreclaim_flag); + return 0; + } + +diff --git a/include/linux/qed/qed_chain.h b/include/linux/qed/qed_chain.h +index 2dd0a9ed5b36..733fad7dfbed 100644 +--- a/include/linux/qed/qed_chain.h ++++ b/include/linux/qed/qed_chain.h +@@ -97,6 +97,11 @@ struct qed_chain_u32 { + u32 cons_idx; + }; + ++struct addr_tbl_entry { ++ void *virt_addr; ++ dma_addr_t dma_map; ++}; ++ + struct qed_chain { + /* fastpath portion of the chain - required for commands such + * as produce / consume. +@@ -107,10 +112,11 @@ struct qed_chain { + + /* Fastpath portions of the PBL [if exists] */ + struct { +- /* Table for keeping the virtual addresses of the chain pages, +- * respectively to the physical addresses in the pbl table. ++ /* Table for keeping the virtual and physical addresses of the ++ * chain pages, respectively to the physical addresses ++ * in the pbl table. + */ +- void **pp_virt_addr_tbl; ++ struct addr_tbl_entry *pp_addr_tbl; + + union { + struct qed_chain_pbl_u16 u16; +@@ -287,7 +293,7 @@ qed_chain_advance_page(struct qed_chain *p_chain, + *(u32 *)page_to_inc = 0; + page_index = *(u32 *)page_to_inc; + } +- *p_next_elem = p_chain->pbl.pp_virt_addr_tbl[page_index]; ++ *p_next_elem = p_chain->pbl.pp_addr_tbl[page_index].virt_addr; + } + } + +@@ -537,7 +543,7 @@ static inline void qed_chain_init_params(struct qed_chain *p_chain, + + p_chain->pbl_sp.p_phys_table = 0; + p_chain->pbl_sp.p_virt_table = NULL; +- p_chain->pbl.pp_virt_addr_tbl = NULL; ++ p_chain->pbl.pp_addr_tbl = NULL; + } + + /** +@@ -575,11 +581,11 @@ static inline void qed_chain_init_mem(struct qed_chain *p_chain, + static inline void qed_chain_init_pbl_mem(struct qed_chain *p_chain, + void *p_virt_pbl, + dma_addr_t p_phys_pbl, +- void **pp_virt_addr_tbl) ++ struct addr_tbl_entry *pp_addr_tbl) + { + p_chain->pbl_sp.p_phys_table = p_phys_pbl; + p_chain->pbl_sp.p_virt_table = p_virt_pbl; +- p_chain->pbl.pp_virt_addr_tbl = pp_virt_addr_tbl; ++ p_chain->pbl.pp_addr_tbl = pp_addr_tbl; + } + + /** +@@ -644,7 +650,7 @@ static inline void *qed_chain_get_last_elem(struct qed_chain *p_chain) + break; + case QED_CHAIN_MODE_PBL: + last_page_idx = p_chain->page_cnt - 1; +- p_virt_addr = p_chain->pbl.pp_virt_addr_tbl[last_page_idx]; ++ p_virt_addr = p_chain->pbl.pp_addr_tbl[last_page_idx].virt_addr; + break; + } + /* p_virt_addr points at this stage to the last page of the chain */ +@@ -716,7 +722,7 @@ static inline void qed_chain_pbl_zero_mem(struct qed_chain *p_chain) + page_cnt = qed_chain_get_page_cnt(p_chain); + + for (i = 0; i < page_cnt; i++) +- memset(p_chain->pbl.pp_virt_addr_tbl[i], 0, ++ memset(p_chain->pbl.pp_addr_tbl[i].virt_addr, 0, + QED_CHAIN_PAGE_SIZE); + } + +diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h +index fd78f78df5c6..3e3214cca447 100644 +--- a/include/linux/sunrpc/svc_rdma.h ++++ b/include/linux/sunrpc/svc_rdma.h +@@ -159,6 +159,7 @@ extern bool svc_rdma_post_recvs(struct svcxprt_rdma *rdma); + extern void svc_rdma_recv_ctxt_put(struct svcxprt_rdma *rdma, + struct svc_rdma_recv_ctxt *ctxt); + extern void svc_rdma_flush_recv_queues(struct svcxprt_rdma *rdma); ++extern void svc_rdma_release_rqst(struct svc_rqst *rqstp); + extern int svc_rdma_recvfrom(struct svc_rqst *); + + /* svc_rdma_rw.c */ +diff --git a/include/trace/events/rpcrdma.h b/include/trace/events/rpcrdma.h +index 4c91cadd1871..4a0b18921e06 100644 +--- a/include/trace/events/rpcrdma.h ++++ b/include/trace/events/rpcrdma.h +@@ -1322,17 +1322,15 @@ DECLARE_EVENT_CLASS(svcrdma_sendcomp_event, + + TRACE_EVENT(svcrdma_post_send, + TP_PROTO( +- const struct ib_send_wr *wr, +- int status ++ const struct ib_send_wr *wr + ), + +- TP_ARGS(wr, status), ++ TP_ARGS(wr), + + TP_STRUCT__entry( + __field(const void *, cqe) + __field(unsigned int, num_sge) + __field(u32, inv_rkey) +- __field(int, status) + ), + + TP_fast_assign( +@@ -1340,12 +1338,11 @@ TRACE_EVENT(svcrdma_post_send, + __entry->num_sge = wr->num_sge; + __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ? + wr->ex.invalidate_rkey : 0; +- __entry->status = status; + ), + +- TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d", ++ TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x", + __entry->cqe, __entry->num_sge, +- __entry->inv_rkey, __entry->status ++ __entry->inv_rkey + ) + ); + +@@ -1410,26 +1407,23 @@ TRACE_EVENT(svcrdma_wc_receive, + TRACE_EVENT(svcrdma_post_rw, + TP_PROTO( + const void *cqe, +- int sqecount, +- int status ++ int sqecount + ), + +- TP_ARGS(cqe, sqecount, status), ++ TP_ARGS(cqe, sqecount), + + TP_STRUCT__entry( + __field(const void *, cqe) + __field(int, sqecount) +- __field(int, status) + ), + + TP_fast_assign( + __entry->cqe = cqe; + __entry->sqecount = sqecount; +- __entry->status = status; + ), + +- TP_printk("cqe=%p sqecount=%d status=%d", +- __entry->cqe, __entry->sqecount, __entry->status ++ TP_printk("cqe=%p sqecount=%d", ++ __entry->cqe, __entry->sqecount + ) + ); + +@@ -1525,6 +1519,34 @@ DECLARE_EVENT_CLASS(svcrdma_sendqueue_event, + DEFINE_SQ_EVENT(full); + DEFINE_SQ_EVENT(retry); + ++TRACE_EVENT(svcrdma_sq_post_err, ++ TP_PROTO( ++ const struct svcxprt_rdma *rdma, ++ int status ++ ), ++ ++ TP_ARGS(rdma, status), ++ ++ TP_STRUCT__entry( ++ __field(int, avail) ++ __field(int, depth) ++ __field(int, status) ++ __string(addr, rdma->sc_xprt.xpt_remotebuf) ++ ), ++ ++ TP_fast_assign( ++ __entry->avail = atomic_read(&rdma->sc_sq_avail); ++ __entry->depth = rdma->sc_sq_depth; ++ __entry->status = status; ++ __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); ++ ), ++ ++ TP_printk("addr=%s sc_sq_avail=%d/%d status=%d", ++ __get_str(addr), __entry->avail, __entry->depth, ++ __entry->status ++ ) ++); ++ + #endif /* _TRACE_RPCRDMA_H */ + + #include <trace/define_trace.h> +diff --git a/include/uapi/linux/swab.h b/include/uapi/linux/swab.h +index fa7f97da5b76..7272f85d6d6a 100644 +--- a/include/uapi/linux/swab.h ++++ b/include/uapi/linux/swab.h +@@ -135,9 +135,9 @@ static inline __attribute_const__ __u32 __fswahb32(__u32 val) + + static __always_inline unsigned long __swab(const unsigned long y) + { +-#if BITS_PER_LONG == 64 ++#if __BITS_PER_LONG == 64 + return __swab64(y); +-#else /* BITS_PER_LONG == 32 */ ++#else /* __BITS_PER_LONG == 32 */ + return __swab32(y); + #endif + } +diff --git a/kernel/bpf/cpumap.c b/kernel/bpf/cpumap.c +index 3c18260403dd..61fbcae82f0a 100644 +--- a/kernel/bpf/cpumap.c ++++ b/kernel/bpf/cpumap.c +@@ -455,7 +455,7 @@ static int cpu_map_update_elem(struct bpf_map *map, void *key, void *value, + return -EOVERFLOW; + + /* Make sure CPU is a valid possible cpu */ +- if (!cpu_possible(key_cpu)) ++ if (key_cpu >= nr_cpumask_bits || !cpu_possible(key_cpu)) + return -ENODEV; + + if (qsize == 0) { +diff --git a/kernel/events/core.c b/kernel/events/core.c +index 00fb2fe92c4d..21e3c65abc76 100644 +--- a/kernel/events/core.c ++++ b/kernel/events/core.c +@@ -6923,10 +6923,17 @@ static void perf_event_task_output(struct perf_event *event, + goto out; + + task_event->event_id.pid = perf_event_pid(event, task); +- task_event->event_id.ppid = perf_event_pid(event, current); +- + task_event->event_id.tid = perf_event_tid(event, task); +- task_event->event_id.ptid = perf_event_tid(event, current); ++ ++ if (task_event->event_id.header.type == PERF_RECORD_EXIT) { ++ task_event->event_id.ppid = perf_event_pid(event, ++ task->real_parent); ++ task_event->event_id.ptid = perf_event_pid(event, ++ task->real_parent); ++ } else { /* PERF_RECORD_FORK */ ++ task_event->event_id.ppid = perf_event_pid(event, current); ++ task_event->event_id.ptid = perf_event_tid(event, current); ++ } + + task_event->event_id.time = perf_event_clock(event); + +diff --git a/mm/shmem.c b/mm/shmem.c +index a6fc82a1ab6b..0a2e1e7801d6 100644 +--- a/mm/shmem.c ++++ b/mm/shmem.c +@@ -2350,11 +2350,11 @@ static int shmem_mfill_atomic_pte(struct mm_struct *dst_mm, + + lru_cache_add_anon(page); + +- spin_lock(&info->lock); ++ spin_lock_irq(&info->lock); + info->alloced++; + inode->i_blocks += BLOCKS_PER_PAGE; + shmem_recalc_inode(inode); +- spin_unlock(&info->lock); ++ spin_unlock_irq(&info->lock); + + inc_mm_counter(dst_mm, mm_counter_file(page)); + page_add_file_rmap(page, false); +diff --git a/net/rxrpc/local_object.c b/net/rxrpc/local_object.c +index 4c0087a48e87..fe190a691872 100644 +--- a/net/rxrpc/local_object.c ++++ b/net/rxrpc/local_object.c +@@ -169,15 +169,6 @@ static int rxrpc_open_socket(struct rxrpc_local *local, struct net *net) + goto error; + } + +- /* we want to set the don't fragment bit */ +- opt = IPV6_PMTUDISC_DO; +- ret = kernel_setsockopt(local->socket, SOL_IPV6, IPV6_MTU_DISCOVER, +- (char *) &opt, sizeof(opt)); +- if (ret < 0) { +- _debug("setsockopt failed"); +- goto error; +- } +- + /* Fall through and set IPv4 options too otherwise we don't get + * errors from IPv4 packets sent through the IPv6 socket. + */ +diff --git a/net/rxrpc/output.c b/net/rxrpc/output.c +index b0aa08e3796d..da8a555ec3f6 100644 +--- a/net/rxrpc/output.c ++++ b/net/rxrpc/output.c +@@ -480,41 +480,21 @@ send_fragmentable: + skb->tstamp = ktime_get_real(); + + switch (conn->params.local->srx.transport.family) { ++ case AF_INET6: + case AF_INET: + opt = IP_PMTUDISC_DONT; +- ret = kernel_setsockopt(conn->params.local->socket, +- SOL_IP, IP_MTU_DISCOVER, +- (char *)&opt, sizeof(opt)); +- if (ret == 0) { +- ret = kernel_sendmsg(conn->params.local->socket, &msg, +- iov, 2, len); +- conn->params.peer->last_tx_at = ktime_get_seconds(); +- +- opt = IP_PMTUDISC_DO; +- kernel_setsockopt(conn->params.local->socket, SOL_IP, +- IP_MTU_DISCOVER, +- (char *)&opt, sizeof(opt)); +- } +- break; +- +-#ifdef CONFIG_AF_RXRPC_IPV6 +- case AF_INET6: +- opt = IPV6_PMTUDISC_DONT; +- ret = kernel_setsockopt(conn->params.local->socket, +- SOL_IPV6, IPV6_MTU_DISCOVER, +- (char *)&opt, sizeof(opt)); +- if (ret == 0) { +- ret = kernel_sendmsg(conn->params.local->socket, &msg, +- iov, 2, len); +- conn->params.peer->last_tx_at = ktime_get_seconds(); +- +- opt = IPV6_PMTUDISC_DO; +- kernel_setsockopt(conn->params.local->socket, +- SOL_IPV6, IPV6_MTU_DISCOVER, +- (char *)&opt, sizeof(opt)); +- } ++ kernel_setsockopt(conn->params.local->socket, ++ SOL_IP, IP_MTU_DISCOVER, ++ (char *)&opt, sizeof(opt)); ++ ret = kernel_sendmsg(conn->params.local->socket, &msg, ++ iov, 2, len); ++ conn->params.peer->last_tx_at = ktime_get_seconds(); ++ ++ opt = IP_PMTUDISC_DO; ++ kernel_setsockopt(conn->params.local->socket, ++ SOL_IP, IP_MTU_DISCOVER, ++ (char *)&opt, sizeof(opt)); + break; +-#endif + + default: + BUG(); +diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c +index 6cf0fd37cbf0..c8ee8e801edb 100644 +--- a/net/sunrpc/svc_xprt.c ++++ b/net/sunrpc/svc_xprt.c +@@ -878,9 +878,6 @@ int svc_send(struct svc_rqst *rqstp) + if (!xprt) + goto out; + +- /* release the receive skb before sending the reply */ +- xprt->xpt_ops->xpo_release_rqst(rqstp); +- + /* calculate over-all length */ + xb = &rqstp->rq_res; + xb->len = xb->head[0].iov_len + +diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c +index 8566531c2f10..d0b5a1c47a32 100644 +--- a/net/sunrpc/svcsock.c ++++ b/net/sunrpc/svcsock.c +@@ -636,6 +636,8 @@ svc_udp_sendto(struct svc_rqst *rqstp) + { + int error; + ++ svc_release_udp_skb(rqstp); ++ + error = svc_sendto(rqstp, &rqstp->rq_res); + if (error == -ECONNREFUSED) + /* ICMP error on earlier request. */ +@@ -1173,6 +1175,8 @@ static int svc_tcp_sendto(struct svc_rqst *rqstp) + int sent; + __be32 reclen; + ++ svc_release_skb(rqstp); ++ + /* Set up the first element of the reply kvec. + * Any other kvecs that may be in use have been taken + * care of by the server implementation itself. +diff --git a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c +index b24d5b8f2fee..16c8174658fd 100644 +--- a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c ++++ b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c +@@ -226,6 +226,26 @@ void svc_rdma_recv_ctxt_put(struct svcxprt_rdma *rdma, + svc_rdma_recv_ctxt_destroy(rdma, ctxt); + } + ++/** ++ * svc_rdma_release_rqst - Release transport-specific per-rqst resources ++ * @rqstp: svc_rqst being released ++ * ++ * Ensure that the recv_ctxt is released whether or not a Reply ++ * was sent. For example, the client could close the connection, ++ * or svc_process could drop an RPC, before the Reply is sent. ++ */ ++void svc_rdma_release_rqst(struct svc_rqst *rqstp) ++{ ++ struct svc_rdma_recv_ctxt *ctxt = rqstp->rq_xprt_ctxt; ++ struct svc_xprt *xprt = rqstp->rq_xprt; ++ struct svcxprt_rdma *rdma = ++ container_of(xprt, struct svcxprt_rdma, sc_xprt); ++ ++ rqstp->rq_xprt_ctxt = NULL; ++ if (ctxt) ++ svc_rdma_recv_ctxt_put(rdma, ctxt); ++} ++ + static int __svc_rdma_post_recv(struct svcxprt_rdma *rdma, + struct svc_rdma_recv_ctxt *ctxt) + { +@@ -704,6 +724,8 @@ int svc_rdma_recvfrom(struct svc_rqst *rqstp) + __be32 *p; + int ret; + ++ rqstp->rq_xprt_ctxt = NULL; ++ + spin_lock(&rdma_xprt->sc_rq_dto_lock); + ctxt = svc_rdma_next_recv_ctxt(&rdma_xprt->sc_read_complete_q); + if (ctxt) { +diff --git a/net/sunrpc/xprtrdma/svc_rdma_rw.c b/net/sunrpc/xprtrdma/svc_rdma_rw.c +index dc1951759a8e..4fc0ce127089 100644 +--- a/net/sunrpc/xprtrdma/svc_rdma_rw.c ++++ b/net/sunrpc/xprtrdma/svc_rdma_rw.c +@@ -331,8 +331,6 @@ static int svc_rdma_post_chunk_ctxt(struct svc_rdma_chunk_ctxt *cc) + if (atomic_sub_return(cc->cc_sqecount, + &rdma->sc_sq_avail) > 0) { + ret = ib_post_send(rdma->sc_qp, first_wr, &bad_wr); +- trace_svcrdma_post_rw(&cc->cc_cqe, +- cc->cc_sqecount, ret); + if (ret) + break; + return 0; +@@ -345,6 +343,7 @@ static int svc_rdma_post_chunk_ctxt(struct svc_rdma_chunk_ctxt *cc) + trace_svcrdma_sq_retry(rdma); + } while (1); + ++ trace_svcrdma_sq_post_err(rdma, ret); + set_bit(XPT_CLOSE, &xprt->xpt_flags); + + /* If even one was posted, there will be a completion. */ +diff --git a/net/sunrpc/xprtrdma/svc_rdma_sendto.c b/net/sunrpc/xprtrdma/svc_rdma_sendto.c +index e8ad7ddf347a..aa4d19a780d7 100644 +--- a/net/sunrpc/xprtrdma/svc_rdma_sendto.c ++++ b/net/sunrpc/xprtrdma/svc_rdma_sendto.c +@@ -310,15 +310,17 @@ int svc_rdma_send(struct svcxprt_rdma *rdma, struct ib_send_wr *wr) + } + + svc_xprt_get(&rdma->sc_xprt); ++ trace_svcrdma_post_send(wr); + ret = ib_post_send(rdma->sc_qp, wr, NULL); +- trace_svcrdma_post_send(wr, ret); +- if (ret) { +- set_bit(XPT_CLOSE, &rdma->sc_xprt.xpt_flags); +- svc_xprt_put(&rdma->sc_xprt); +- wake_up(&rdma->sc_send_wait); +- } +- break; ++ if (ret) ++ break; ++ return 0; + } ++ ++ trace_svcrdma_sq_post_err(rdma, ret); ++ set_bit(XPT_CLOSE, &rdma->sc_xprt.xpt_flags); ++ svc_xprt_put(&rdma->sc_xprt); ++ wake_up(&rdma->sc_send_wait); + return ret; + } + +@@ -906,12 +908,7 @@ int svc_rdma_sendto(struct svc_rqst *rqstp) + wr_lst, rp_ch); + if (ret < 0) + goto err1; +- ret = 0; +- +-out: +- rqstp->rq_xprt_ctxt = NULL; +- svc_rdma_recv_ctxt_put(rdma, rctxt); +- return ret; ++ return 0; + + err2: + if (ret != -E2BIG && ret != -EINVAL) +@@ -920,14 +917,12 @@ out: + ret = svc_rdma_send_error_msg(rdma, sctxt, rqstp); + if (ret < 0) + goto err1; +- ret = 0; +- goto out; ++ return 0; + + err1: + svc_rdma_send_ctxt_put(rdma, sctxt); + err0: + trace_svcrdma_send_failed(rqstp, ret); + set_bit(XPT_CLOSE, &xprt->xpt_flags); +- ret = -ENOTCONN; +- goto out; ++ return -ENOTCONN; + } +diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c +index 7308992b7a18..f1824303e076 100644 +--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c ++++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c +@@ -71,7 +71,6 @@ static struct svc_xprt *svc_rdma_create(struct svc_serv *serv, + struct sockaddr *sa, int salen, + int flags); + static struct svc_xprt *svc_rdma_accept(struct svc_xprt *xprt); +-static void svc_rdma_release_rqst(struct svc_rqst *); + static void svc_rdma_detach(struct svc_xprt *xprt); + static void svc_rdma_free(struct svc_xprt *xprt); + static int svc_rdma_has_wspace(struct svc_xprt *xprt); +@@ -616,10 +615,6 @@ static struct svc_xprt *svc_rdma_accept(struct svc_xprt *xprt) + return NULL; + } + +-static void svc_rdma_release_rqst(struct svc_rqst *rqstp) +-{ +-} +- + /* + * When connected, an svc_xprt has at least two references: + * +diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c +index 0502042c1616..0d7981eda2c4 100644 +--- a/sound/pci/hda/hda_intel.c ++++ b/sound/pci/hda/hda_intel.c +@@ -2054,7 +2054,7 @@ static int azx_first_init(struct azx *chip) + /* codec detection */ + if (!azx_bus(chip)->codec_mask) { + dev_err(card->dev, "no codecs found!\n"); +- return -ENODEV; ++ /* keep running the rest for the runtime PM */ + } + + if (azx_acquire_irq(chip, 0) < 0) +@@ -2440,9 +2440,11 @@ static int azx_probe_continue(struct azx *chip) + #endif + + /* create codec instances */ +- err = azx_probe_codecs(chip, azx_max_codecs[chip->driver_type]); +- if (err < 0) +- goto out_free; ++ if (bus->codec_mask) { ++ err = azx_probe_codecs(chip, azx_max_codecs[chip->driver_type]); ++ if (err < 0) ++ goto out_free; ++ } + + #ifdef CONFIG_SND_HDA_PATCH_LOADER + if (chip->fw) { +@@ -2456,7 +2458,7 @@ static int azx_probe_continue(struct azx *chip) + #endif + } + #endif +- if ((probe_only[dev] & 1) == 0) { ++ if (bus->codec_mask && !(probe_only[dev] & 1)) { + err = azx_codec_configure(chip); + if (err < 0) + goto out_free; +@@ -2473,8 +2475,11 @@ static int azx_probe_continue(struct azx *chip) + + set_default_power_save(chip); + +- if (azx_has_pm_runtime(chip)) ++ if (azx_has_pm_runtime(chip)) { ++ pm_runtime_use_autosuspend(&pci->dev); ++ pm_runtime_allow(&pci->dev); + pm_runtime_put_autosuspend(&pci->dev); ++ } + + out_free: + if ((chip->driver_caps & AZX_DCAPS_I915_POWERWELL) +diff --git a/sound/soc/codecs/tas571x.c b/sound/soc/codecs/tas571x.c +index ca2dfe12344e..354f17a2fa5c 100644 +--- a/sound/soc/codecs/tas571x.c ++++ b/sound/soc/codecs/tas571x.c +@@ -824,8 +824,10 @@ static int tas571x_i2c_probe(struct i2c_client *client, + + priv->regmap = devm_regmap_init(dev, NULL, client, + priv->chip->regmap_config); +- if (IS_ERR(priv->regmap)) +- return PTR_ERR(priv->regmap); ++ if (IS_ERR(priv->regmap)) { ++ ret = PTR_ERR(priv->regmap); ++ goto disable_regs; ++ } + + priv->pdn_gpio = devm_gpiod_get_optional(dev, "pdn", GPIOD_OUT_LOW); + if (IS_ERR(priv->pdn_gpio)) { +@@ -849,7 +851,7 @@ static int tas571x_i2c_probe(struct i2c_client *client, + + ret = regmap_write(priv->regmap, TAS571X_OSC_TRIM_REG, 0); + if (ret) +- return ret; ++ goto disable_regs; + + usleep_range(50000, 60000); + +@@ -865,12 +867,20 @@ static int tas571x_i2c_probe(struct i2c_client *client, + */ + ret = regmap_update_bits(priv->regmap, TAS571X_MVOL_REG, 1, 0); + if (ret) +- return ret; ++ goto disable_regs; + } + +- return devm_snd_soc_register_component(&client->dev, ++ ret = devm_snd_soc_register_component(&client->dev, + &priv->component_driver, + &tas571x_dai, 1); ++ if (ret) ++ goto disable_regs; ++ ++ return ret; ++ ++disable_regs: ++ regulator_bulk_disable(priv->chip->num_supply_names, priv->supplies); ++ return ret; + } + + static int tas571x_i2c_remove(struct i2c_client *client) +diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c +index 8dc1f3d6a988..c4c00297ada6 100644 +--- a/sound/soc/codecs/wm8960.c ++++ b/sound/soc/codecs/wm8960.c +@@ -863,8 +863,7 @@ static int wm8960_hw_params(struct snd_pcm_substream *substream, + + wm8960->is_stream_in_use[tx] = true; + +- if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_ON && +- !wm8960->is_stream_in_use[!tx]) ++ if (!wm8960->is_stream_in_use[!tx]) + return wm8960_configure_clocking(component); + + return 0; +diff --git a/sound/soc/qcom/qdsp6/q6afe-dai.c b/sound/soc/qcom/qdsp6/q6afe-dai.c +index 8f6c8fc073a9..1fc1939b90c2 100644 +--- a/sound/soc/qcom/qdsp6/q6afe-dai.c ++++ b/sound/soc/qcom/qdsp6/q6afe-dai.c +@@ -899,6 +899,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | + SNDRV_PCM_FMTBIT_S24_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -914,6 +916,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | + SNDRV_PCM_FMTBIT_S24_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -928,6 +932,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_8000 | + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -943,6 +949,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | + SNDRV_PCM_FMTBIT_S24_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -957,6 +965,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_8000 | + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -972,6 +982,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | + SNDRV_PCM_FMTBIT_S24_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -986,6 +998,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_8000 | + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +@@ -1001,6 +1015,8 @@ static struct snd_soc_dai_driver q6afe_dais[] = { + SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | + SNDRV_PCM_FMTBIT_S24_LE, ++ .channels_min = 1, ++ .channels_max = 8, + .rate_min = 8000, + .rate_max = 48000, + }, +diff --git a/tools/objtool/check.c b/tools/objtool/check.c +index 9479c74af9ba..4613d796492a 100644 +--- a/tools/objtool/check.c ++++ b/tools/objtool/check.c +@@ -2086,14 +2086,27 @@ static bool ignore_unreachable_insn(struct instruction *insn) + !strcmp(insn->sec->name, ".altinstr_aux")) + return true; + ++ if (!insn->func) ++ return false; ++ ++ /* ++ * CONFIG_UBSAN_TRAP inserts a UD2 when it sees ++ * __builtin_unreachable(). The BUG() macro has an unreachable() after ++ * the UD2, which causes GCC's undefined trap logic to emit another UD2 ++ * (or occasionally a JMP to UD2). ++ */ ++ if (list_prev_entry(insn, list)->dead_end && ++ (insn->type == INSN_BUG || ++ (insn->type == INSN_JUMP_UNCONDITIONAL && ++ insn->jump_dest && insn->jump_dest->type == INSN_BUG))) ++ return true; ++ + /* + * Check if this (or a subsequent) instruction is related to + * CONFIG_UBSAN or CONFIG_KASAN. + * + * End the search at 5 instructions to avoid going into the weeds. + */ +- if (!insn->func) +- return false; + for (i = 0; i < 5; i++) { + + if (is_kasan_insn(insn) || is_ubsan_insn(insn)) +diff --git a/tools/objtool/orc_dump.c b/tools/objtool/orc_dump.c +index faa444270ee3..1a3e774941f8 100644 +--- a/tools/objtool/orc_dump.c ++++ b/tools/objtool/orc_dump.c +@@ -78,7 +78,7 @@ int orc_dump(const char *_objname) + char *name; + size_t nr_sections; + Elf64_Addr orc_ip_addr = 0; +- size_t shstrtab_idx; ++ size_t shstrtab_idx, strtab_idx = 0; + Elf *elf; + Elf_Scn *scn; + GElf_Shdr sh; +@@ -139,6 +139,8 @@ int orc_dump(const char *_objname) + + if (!strcmp(name, ".symtab")) { + symtab = data; ++ } else if (!strcmp(name, ".strtab")) { ++ strtab_idx = i; + } else if (!strcmp(name, ".orc_unwind")) { + orc = data->d_buf; + orc_size = sh.sh_size; +@@ -150,7 +152,7 @@ int orc_dump(const char *_objname) + } + } + +- if (!symtab || !orc || !orc_ip) ++ if (!symtab || !strtab_idx || !orc || !orc_ip) + return 0; + + if (orc_size % sizeof(*orc) != 0) { +@@ -171,21 +173,29 @@ int orc_dump(const char *_objname) + return -1; + } + +- scn = elf_getscn(elf, sym.st_shndx); +- if (!scn) { +- WARN_ELF("elf_getscn"); +- return -1; +- } +- +- if (!gelf_getshdr(scn, &sh)) { +- WARN_ELF("gelf_getshdr"); +- return -1; +- } +- +- name = elf_strptr(elf, shstrtab_idx, sh.sh_name); +- if (!name || !*name) { +- WARN_ELF("elf_strptr"); +- return -1; ++ if (GELF_ST_TYPE(sym.st_info) == STT_SECTION) { ++ scn = elf_getscn(elf, sym.st_shndx); ++ if (!scn) { ++ WARN_ELF("elf_getscn"); ++ return -1; ++ } ++ ++ if (!gelf_getshdr(scn, &sh)) { ++ WARN_ELF("gelf_getshdr"); ++ return -1; ++ } ++ ++ name = elf_strptr(elf, shstrtab_idx, sh.sh_name); ++ if (!name) { ++ WARN_ELF("elf_strptr"); ++ return -1; ++ } ++ } else { ++ name = elf_strptr(elf, strtab_idx, sym.st_name); ++ if (!name) { ++ WARN_ELF("elf_strptr"); ++ return -1; ++ } + } + + printf("%s+%llx:", name, (unsigned long long)rela.r_addend); |