commit: ca149b605a796e49d6fa6b4c264c93712590bfd5 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Mon May 11 22:46:12 2020 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Mon May 11 22:46:12 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=ca149b60
Linux patch 5.6.12 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1011_linux-5.6.12.patch | 1575 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1579 insertions(+) diff --git a/0000_README b/0000_README index 9c9c8b5..dcfb651 100644 --- a/0000_README +++ b/0000_README @@ -87,6 +87,10 @@ Patch: 1010_linux-5.6.11.patch From: http://www.kernel.org Desc: Linux 5.6.11 +Patch: 1011_linux-5.6.12.patch +From: http://www.kernel.org +Desc: Linux 5.6.12 + 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/1011_linux-5.6.12.patch b/1011_linux-5.6.12.patch new file mode 100644 index 0000000..d32b884 --- /dev/null +++ b/1011_linux-5.6.12.patch @@ -0,0 +1,1575 @@ +diff --git a/Makefile b/Makefile +index 5dedd6f9ad75..97e4c4d9ac95 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 6 +-SUBLEVEL = 11 ++SUBLEVEL = 12 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/x86/kvm/vmx/ops.h b/arch/x86/kvm/vmx/ops.h +index 09b0937d56b1..19717d0a1100 100644 +--- a/arch/x86/kvm/vmx/ops.h ++++ b/arch/x86/kvm/vmx/ops.h +@@ -12,6 +12,7 @@ + + #define __ex(x) __kvm_handle_fault_on_reboot(x) + ++asmlinkage void vmread_error(unsigned long field, bool fault); + __attribute__((regparm(0))) void vmread_error_trampoline(unsigned long field, + bool fault); + void vmwrite_error(unsigned long field, unsigned long value); +diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c +index f4dbdfafafe3..4edc8a3ce40f 100644 +--- a/drivers/acpi/sleep.c ++++ b/drivers/acpi/sleep.c +@@ -982,10 +982,7 @@ static int acpi_s2idle_prepare_late(void) + + static void acpi_s2idle_sync(void) + { +- /* +- * The EC driver uses the system workqueue and an additional special +- * one, so those need to be flushed too. +- */ ++ /* The EC driver uses special workqueues that need to be flushed. */ + acpi_ec_flush_work(); + acpi_os_wait_events_complete(); /* synchronize Notify handling */ + } +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +index b03b1eb7ba04..1ae174c3d160 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +@@ -91,7 +91,8 @@ void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev) + adev->pm.ac_power = true; + else + adev->pm.ac_power = false; +- if (adev->powerplay.pp_funcs->enable_bapm) ++ if (adev->powerplay.pp_funcs && ++ adev->powerplay.pp_funcs->enable_bapm) + amdgpu_dpm_enable_bapm(adev, adev->pm.ac_power); + mutex_unlock(&adev->pm.mutex); + } +diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/processpptables.c b/drivers/gpu/drm/amd/powerplay/hwmgr/processpptables.c +index 77c14671866c..719597c5d27d 100644 +--- a/drivers/gpu/drm/amd/powerplay/hwmgr/processpptables.c ++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/processpptables.c +@@ -984,6 +984,32 @@ static int init_thermal_controller( + struct pp_hwmgr *hwmgr, + const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table) + { ++ hwmgr->thermal_controller.ucType = ++ powerplay_table->sThermalController.ucType; ++ hwmgr->thermal_controller.ucI2cLine = ++ powerplay_table->sThermalController.ucI2cLine; ++ hwmgr->thermal_controller.ucI2cAddress = ++ powerplay_table->sThermalController.ucI2cAddress; ++ ++ hwmgr->thermal_controller.fanInfo.bNoFan = ++ (0 != (powerplay_table->sThermalController.ucFanParameters & ++ ATOM_PP_FANPARAMETERS_NOFAN)); ++ ++ hwmgr->thermal_controller.fanInfo.ucTachometerPulsesPerRevolution = ++ powerplay_table->sThermalController.ucFanParameters & ++ ATOM_PP_FANPARAMETERS_TACHOMETER_PULSES_PER_REVOLUTION_MASK; ++ ++ hwmgr->thermal_controller.fanInfo.ulMinRPM ++ = powerplay_table->sThermalController.ucFanMinRPM * 100UL; ++ hwmgr->thermal_controller.fanInfo.ulMaxRPM ++ = powerplay_table->sThermalController.ucFanMaxRPM * 100UL; ++ ++ set_hw_cap(hwmgr, ++ ATOM_PP_THERMALCONTROLLER_NONE != hwmgr->thermal_controller.ucType, ++ PHM_PlatformCaps_ThermalController); ++ ++ hwmgr->thermal_controller.use_hw_fan_control = 1; ++ + return 0; + } + +diff --git a/drivers/gpu/drm/amd/powerplay/renoir_ppt.c b/drivers/gpu/drm/amd/powerplay/renoir_ppt.c +index f7a1ce37227c..4a52c310058d 100644 +--- a/drivers/gpu/drm/amd/powerplay/renoir_ppt.c ++++ b/drivers/gpu/drm/amd/powerplay/renoir_ppt.c +@@ -889,12 +889,17 @@ static int renoir_read_sensor(struct smu_context *smu, + + static bool renoir_is_dpm_running(struct smu_context *smu) + { ++ struct amdgpu_device *adev = smu->adev; ++ + /* + * Util now, the pmfw hasn't exported the interface of SMU + * feature mask to APU SKU so just force on all the feature + * at early initial stage. + */ +- return true; ++ if (adev->in_suspend) ++ return false; ++ else ++ return true; + + } + +diff --git a/drivers/gpu/drm/bridge/analogix/analogix-anx6345.c b/drivers/gpu/drm/bridge/analogix/analogix-anx6345.c +index 526507102c1e..8d32fea84c75 100644 +--- a/drivers/gpu/drm/bridge/analogix/analogix-anx6345.c ++++ b/drivers/gpu/drm/bridge/analogix/analogix-anx6345.c +@@ -485,6 +485,9 @@ static int anx6345_get_modes(struct drm_connector *connector) + + num_modes += drm_add_edid_modes(connector, anx6345->edid); + ++ /* Driver currently supports only 6bpc */ ++ connector->display_info.bpc = 6; ++ + unlock: + if (power_off) + anx6345_poweroff(anx6345); +diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c +index 6effe532f820..461eff94d276 100644 +--- a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c ++++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c +@@ -1636,8 +1636,7 @@ static ssize_t analogix_dpaux_transfer(struct drm_dp_aux *aux, + } + + struct analogix_dp_device * +-analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, +- struct analogix_dp_plat_data *plat_data) ++analogix_dp_probe(struct device *dev, struct analogix_dp_plat_data *plat_data) + { + struct platform_device *pdev = to_platform_device(dev); + struct analogix_dp_device *dp; +@@ -1740,22 +1739,30 @@ analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, + irq_flags, "analogix-dp", dp); + if (ret) { + dev_err(&pdev->dev, "failed to request irq\n"); +- goto err_disable_pm_runtime; ++ return ERR_PTR(ret); + } + disable_irq(dp->irq); + ++ return dp; ++} ++EXPORT_SYMBOL_GPL(analogix_dp_probe); ++ ++int analogix_dp_bind(struct analogix_dp_device *dp, struct drm_device *drm_dev) ++{ ++ int ret; ++ + dp->drm_dev = drm_dev; + dp->encoder = dp->plat_data->encoder; + + dp->aux.name = "DP-AUX"; + dp->aux.transfer = analogix_dpaux_transfer; +- dp->aux.dev = &pdev->dev; ++ dp->aux.dev = dp->dev; + + ret = drm_dp_aux_register(&dp->aux); + if (ret) +- return ERR_PTR(ret); ++ return ret; + +- pm_runtime_enable(dev); ++ pm_runtime_enable(dp->dev); + + ret = analogix_dp_create_bridge(drm_dev, dp); + if (ret) { +@@ -1763,13 +1770,12 @@ analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, + goto err_disable_pm_runtime; + } + +- return dp; ++ return 0; + + err_disable_pm_runtime: ++ pm_runtime_disable(dp->dev); + +- pm_runtime_disable(dev); +- +- return ERR_PTR(ret); ++ return ret; + } + EXPORT_SYMBOL_GPL(analogix_dp_bind); + +@@ -1786,10 +1792,15 @@ void analogix_dp_unbind(struct analogix_dp_device *dp) + + drm_dp_aux_unregister(&dp->aux); + pm_runtime_disable(dp->dev); +- clk_disable_unprepare(dp->clock); + } + EXPORT_SYMBOL_GPL(analogix_dp_unbind); + ++void analogix_dp_remove(struct analogix_dp_device *dp) ++{ ++ clk_disable_unprepare(dp->clock); ++} ++EXPORT_SYMBOL_GPL(analogix_dp_remove); ++ + #ifdef CONFIG_PM + int analogix_dp_suspend(struct analogix_dp_device *dp) + { +diff --git a/drivers/gpu/drm/exynos/exynos_dp.c b/drivers/gpu/drm/exynos/exynos_dp.c +index 4785885c0f4f..065a1cb2a544 100644 +--- a/drivers/gpu/drm/exynos/exynos_dp.c ++++ b/drivers/gpu/drm/exynos/exynos_dp.c +@@ -158,15 +158,8 @@ static int exynos_dp_bind(struct device *dev, struct device *master, void *data) + struct drm_device *drm_dev = data; + int ret; + +- dp->dev = dev; + dp->drm_dev = drm_dev; + +- dp->plat_data.dev_type = EXYNOS_DP; +- dp->plat_data.power_on_start = exynos_dp_poweron; +- dp->plat_data.power_off = exynos_dp_poweroff; +- dp->plat_data.attach = exynos_dp_bridge_attach; +- dp->plat_data.get_modes = exynos_dp_get_modes; +- + if (!dp->plat_data.panel && !dp->ptn_bridge) { + ret = exynos_dp_dt_parse_panel(dp); + if (ret) +@@ -184,13 +177,11 @@ static int exynos_dp_bind(struct device *dev, struct device *master, void *data) + + dp->plat_data.encoder = encoder; + +- dp->adp = analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data); +- if (IS_ERR(dp->adp)) { ++ ret = analogix_dp_bind(dp->adp, dp->drm_dev); ++ if (ret) + dp->encoder.funcs->destroy(&dp->encoder); +- return PTR_ERR(dp->adp); +- } + +- return 0; ++ return ret; + } + + static void exynos_dp_unbind(struct device *dev, struct device *master, +@@ -221,6 +212,7 @@ static int exynos_dp_probe(struct platform_device *pdev) + if (!dp) + return -ENOMEM; + ++ dp->dev = dev; + /* + * We just use the drvdata until driver run into component + * add function, and then we would set drvdata to null, so +@@ -246,16 +238,29 @@ static int exynos_dp_probe(struct platform_device *pdev) + + /* The remote port can be either a panel or a bridge */ + dp->plat_data.panel = panel; ++ dp->plat_data.dev_type = EXYNOS_DP; ++ dp->plat_data.power_on_start = exynos_dp_poweron; ++ dp->plat_data.power_off = exynos_dp_poweroff; ++ dp->plat_data.attach = exynos_dp_bridge_attach; ++ dp->plat_data.get_modes = exynos_dp_get_modes; + dp->plat_data.skip_connector = !!bridge; ++ + dp->ptn_bridge = bridge; + + out: ++ dp->adp = analogix_dp_probe(dev, &dp->plat_data); ++ if (IS_ERR(dp->adp)) ++ return PTR_ERR(dp->adp); ++ + return component_add(&pdev->dev, &exynos_dp_ops); + } + + static int exynos_dp_remove(struct platform_device *pdev) + { ++ struct exynos_dp_device *dp = platform_get_drvdata(pdev); ++ + component_del(&pdev->dev, &exynos_dp_ops); ++ analogix_dp_remove(dp->adp); + + return 0; + } +diff --git a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c +index f38f5e113c6b..ce98c08aa8b4 100644 +--- a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c ++++ b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c +@@ -325,15 +325,9 @@ static int rockchip_dp_bind(struct device *dev, struct device *master, + void *data) + { + struct rockchip_dp_device *dp = dev_get_drvdata(dev); +- const struct rockchip_dp_chip_data *dp_data; + struct drm_device *drm_dev = data; + int ret; + +- dp_data = of_device_get_match_data(dev); +- if (!dp_data) +- return -ENODEV; +- +- dp->data = dp_data; + dp->drm_dev = drm_dev; + + ret = rockchip_dp_drm_create_encoder(dp); +@@ -344,16 +338,9 @@ static int rockchip_dp_bind(struct device *dev, struct device *master, + + dp->plat_data.encoder = &dp->encoder; + +- dp->plat_data.dev_type = dp->data->chip_type; +- dp->plat_data.power_on_start = rockchip_dp_poweron_start; +- dp->plat_data.power_off = rockchip_dp_powerdown; +- dp->plat_data.get_modes = rockchip_dp_get_modes; +- +- dp->adp = analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data); +- if (IS_ERR(dp->adp)) { +- ret = PTR_ERR(dp->adp); ++ ret = analogix_dp_bind(dp->adp, drm_dev); ++ if (ret) + goto err_cleanup_encoder; +- } + + return 0; + err_cleanup_encoder: +@@ -368,8 +355,6 @@ static void rockchip_dp_unbind(struct device *dev, struct device *master, + + analogix_dp_unbind(dp->adp); + dp->encoder.funcs->destroy(&dp->encoder); +- +- dp->adp = ERR_PTR(-ENODEV); + } + + static const struct component_ops rockchip_dp_component_ops = { +@@ -380,10 +365,15 @@ static const struct component_ops rockchip_dp_component_ops = { + static int rockchip_dp_probe(struct platform_device *pdev) + { + struct device *dev = &pdev->dev; ++ const struct rockchip_dp_chip_data *dp_data; + struct drm_panel *panel = NULL; + struct rockchip_dp_device *dp; + int ret; + ++ dp_data = of_device_get_match_data(dev); ++ if (!dp_data) ++ return -ENODEV; ++ + ret = drm_of_find_panel_or_bridge(dev->of_node, 1, 0, &panel, NULL); + if (ret < 0) + return ret; +@@ -394,7 +384,12 @@ static int rockchip_dp_probe(struct platform_device *pdev) + + dp->dev = dev; + dp->adp = ERR_PTR(-ENODEV); ++ dp->data = dp_data; + dp->plat_data.panel = panel; ++ dp->plat_data.dev_type = dp->data->chip_type; ++ dp->plat_data.power_on_start = rockchip_dp_poweron_start; ++ dp->plat_data.power_off = rockchip_dp_powerdown; ++ dp->plat_data.get_modes = rockchip_dp_get_modes; + + ret = rockchip_dp_of_probe(dp); + if (ret < 0) +@@ -402,12 +397,19 @@ static int rockchip_dp_probe(struct platform_device *pdev) + + platform_set_drvdata(pdev, dp); + ++ dp->adp = analogix_dp_probe(dev, &dp->plat_data); ++ if (IS_ERR(dp->adp)) ++ return PTR_ERR(dp->adp); ++ + return component_add(dev, &rockchip_dp_component_ops); + } + + static int rockchip_dp_remove(struct platform_device *pdev) + { ++ struct rockchip_dp_device *dp = platform_get_drvdata(pdev); ++ + component_del(&pdev->dev, &rockchip_dp_component_ops); ++ analogix_dp_remove(dp->adp); + + return 0; + } +diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c +index 15b31cddc054..2e4b4188659a 100644 +--- a/drivers/net/ethernet/broadcom/bcmsysport.c ++++ b/drivers/net/ethernet/broadcom/bcmsysport.c +@@ -666,7 +666,8 @@ static struct sk_buff *bcm_sysport_rx_refill(struct bcm_sysport_priv *priv, + dma_addr_t mapping; + + /* Allocate a new SKB for a new packet */ +- skb = netdev_alloc_skb(priv->netdev, RX_BUF_LENGTH); ++ skb = __netdev_alloc_skb(priv->netdev, RX_BUF_LENGTH, ++ GFP_ATOMIC | __GFP_NOWARN); + if (!skb) { + priv->mib.alloc_rx_buff_failed++; + netif_err(priv, rx_err, ndev, "SKB alloc failed\n"); +diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +index b7c0c20e1325..5fd1a9dfcfff 100644 +--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c ++++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +@@ -1625,7 +1625,8 @@ static struct sk_buff *bcmgenet_rx_refill(struct bcmgenet_priv *priv, + dma_addr_t mapping; + + /* Allocate a new Rx skb */ +- skb = netdev_alloc_skb(priv->dev, priv->rx_buf_len + SKB_ALIGNMENT); ++ skb = __netdev_alloc_skb(priv->dev, priv->rx_buf_len + SKB_ALIGNMENT, ++ GFP_ATOMIC | __GFP_NOWARN); + if (!skb) { + priv->mib.alloc_rx_buff_failed++; + netif_err(priv, rx_err, priv->dev, +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c +index fa32cd5b418e..70d41783329d 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c +@@ -291,16 +291,19 @@ static int socfpga_gen5_set_phy_mode(struct socfpga_dwmac *dwmac) + phymode == PHY_INTERFACE_MODE_MII || + phymode == PHY_INTERFACE_MODE_GMII || + phymode == PHY_INTERFACE_MODE_SGMII) { +- ctrl |= SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << (reg_shift / 2); + regmap_read(sys_mgr_base_addr, SYSMGR_FPGAGRP_MODULE_REG, + &module); + module |= (SYSMGR_FPGAGRP_MODULE_EMAC << (reg_shift / 2)); + regmap_write(sys_mgr_base_addr, SYSMGR_FPGAGRP_MODULE_REG, + module); +- } else { +- ctrl &= ~(SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << (reg_shift / 2)); + } + ++ if (dwmac->f2h_ptp_ref_clk) ++ ctrl |= SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << (reg_shift / 2); ++ else ++ ctrl &= ~(SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << ++ (reg_shift / 2)); ++ + regmap_write(sys_mgr_base_addr, reg_offset, ctrl); + + /* Deassert reset for the phy configuration to be sampled by +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_hwtstamp.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_hwtstamp.c +index 020159622559..e5d9007c8090 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_hwtstamp.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_hwtstamp.c +@@ -26,12 +26,16 @@ static void config_sub_second_increment(void __iomem *ioaddr, + unsigned long data; + u32 reg_value; + +- /* For GMAC3.x, 4.x versions, convert the ptp_clock to nano second +- * formula = (1/ptp_clock) * 1000000000 +- * where ptp_clock is 50MHz if fine method is used to update system ++ /* For GMAC3.x, 4.x versions, in "fine adjustement mode" set sub-second ++ * increment to twice the number of nanoseconds of a clock cycle. ++ * The calculation of the default_addend value by the caller will set it ++ * to mid-range = 2^31 when the remainder of this division is zero, ++ * which will make the accumulator overflow once every 2 ptp_clock ++ * cycles, adding twice the number of nanoseconds of a clock cycle : ++ * 2000000000ULL / ptp_clock. + */ + if (value & PTP_TCR_TSCFUPDT) +- data = (1000000000ULL / 50000000); ++ data = (2000000000ULL / ptp_clock); + else + data = (1000000000ULL / ptp_clock); + +diff --git a/drivers/net/phy/bcm84881.c b/drivers/net/phy/bcm84881.c +index 14d55a77eb28..126011582928 100644 +--- a/drivers/net/phy/bcm84881.c ++++ b/drivers/net/phy/bcm84881.c +@@ -174,9 +174,6 @@ static int bcm84881_read_status(struct phy_device *phydev) + if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete) + phydev->link = false; + +- if (!phydev->link) +- return 0; +- + linkmode_zero(phydev->lp_advertising); + phydev->speed = SPEED_UNKNOWN; + phydev->duplex = DUPLEX_UNKNOWN; +@@ -184,6 +181,9 @@ static int bcm84881_read_status(struct phy_device *phydev) + phydev->asym_pause = 0; + phydev->mdix = 0; + ++ if (!phydev->link) ++ return 0; ++ + if (phydev->autoneg_complete) { + val = genphy_c45_read_lpa(phydev); + if (val < 0) +diff --git a/drivers/net/wimax/i2400m/usb-fw.c b/drivers/net/wimax/i2400m/usb-fw.c +index 529ebca1e9e1..1f7709d24f35 100644 +--- a/drivers/net/wimax/i2400m/usb-fw.c ++++ b/drivers/net/wimax/i2400m/usb-fw.c +@@ -354,6 +354,7 @@ out: + usb_autopm_put_interface(i2400mu->usb_iface); + d_fnend(8, dev, "(i2400m %p ack %p size %zu) = %ld\n", + i2400m, ack, ack_size, (long) result); ++ usb_put_urb(¬if_urb); + return result; + + error_exceeded: +diff --git a/drivers/platform/x86/gpd-pocket-fan.c b/drivers/platform/x86/gpd-pocket-fan.c +index b471b86c28fe..5b516e4c2bfb 100644 +--- a/drivers/platform/x86/gpd-pocket-fan.c ++++ b/drivers/platform/x86/gpd-pocket-fan.c +@@ -128,7 +128,7 @@ static int gpd_pocket_fan_probe(struct platform_device *pdev) + + for (i = 0; i < ARRAY_SIZE(temp_limits); i++) { + if (temp_limits[i] < 20000 || temp_limits[i] > 90000) { +- dev_err(&pdev->dev, "Invalid temp-limit %d (must be between 40000 and 70000)\n", ++ dev_err(&pdev->dev, "Invalid temp-limit %d (must be between 20000 and 90000)\n", + temp_limits[i]); + temp_limits[0] = TEMP_LIMIT0_DEFAULT; + temp_limits[1] = TEMP_LIMIT1_DEFAULT; +diff --git a/drivers/remoteproc/qcom_q6v5_mss.c b/drivers/remoteproc/qcom_q6v5_mss.c +index 0b1d737b0e97..8844fc56c5f6 100644 +--- a/drivers/remoteproc/qcom_q6v5_mss.c ++++ b/drivers/remoteproc/qcom_q6v5_mss.c +@@ -1607,7 +1607,7 @@ static int q6v5_probe(struct platform_device *pdev) + ret = of_property_read_string_index(pdev->dev.of_node, "firmware-name", + 1, &qproc->hexagon_mdt_image); + if (ret < 0 && ret != -EINVAL) +- return ret; ++ goto free_rproc; + + platform_set_drvdata(pdev, qproc); + +diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c +index 9c0ee192f0f9..20472aaaf630 100644 +--- a/drivers/scsi/sg.c ++++ b/drivers/scsi/sg.c +@@ -685,8 +685,10 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) + hp->flags = input_size; /* structure abuse ... */ + hp->pack_id = old_hdr.pack_id; + hp->usr_ptr = NULL; +- if (copy_from_user(cmnd, buf, cmd_size)) ++ if (copy_from_user(cmnd, buf, cmd_size)) { ++ sg_remove_request(sfp, srp); + return -EFAULT; ++ } + /* + * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV, + * but is is possible that the app intended SG_DXFER_TO_DEV, because there +diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h +index 3ecc69c5b150..ce4acbf7fef9 100644 +--- a/drivers/usb/dwc3/core.h ++++ b/drivers/usb/dwc3/core.h +@@ -310,6 +310,10 @@ + #define DWC3_GTXFIFOSIZ_TXFDEF(n) ((n) & 0xffff) + #define DWC3_GTXFIFOSIZ_TXFSTADDR(n) ((n) & 0xffff0000) + ++/* Global RX Fifo Size Register */ ++#define DWC31_GRXFIFOSIZ_RXFDEP(n) ((n) & 0x7fff) /* DWC_usb31 only */ ++#define DWC3_GRXFIFOSIZ_RXFDEP(n) ((n) & 0xffff) ++ + /* Global Event Size Registers */ + #define DWC3_GEVNTSIZ_INTMASK BIT(31) + #define DWC3_GEVNTSIZ_SIZE(n) ((n) & 0xffff) +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index c4be4631937a..bc1cf6d0412a 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -2223,7 +2223,6 @@ static int dwc3_gadget_init_in_endpoint(struct dwc3_ep *dep) + { + struct dwc3 *dwc = dep->dwc; + int mdwidth; +- int kbytes; + int size; + + mdwidth = DWC3_MDWIDTH(dwc->hwparams.hwparams0); +@@ -2239,17 +2238,17 @@ static int dwc3_gadget_init_in_endpoint(struct dwc3_ep *dep) + /* FIFO Depth is in MDWDITH bytes. Multiply */ + size *= mdwidth; + +- kbytes = size / 1024; +- if (kbytes == 0) +- kbytes = 1; +- + /* +- * FIFO sizes account an extra MDWIDTH * (kbytes + 1) bytes for +- * internal overhead. We don't really know how these are used, +- * but documentation say it exists. ++ * To meet performance requirement, a minimum TxFIFO size of 3x ++ * MaxPacketSize is recommended for endpoints that support burst and a ++ * minimum TxFIFO size of 2x MaxPacketSize for endpoints that don't ++ * support burst. Use those numbers and we can calculate the max packet ++ * limit as below. + */ +- size -= mdwidth * (kbytes + 1); +- size /= kbytes; ++ if (dwc->maximum_speed >= USB_SPEED_SUPER) ++ size /= 3; ++ else ++ size /= 2; + + usb_ep_set_maxpacket_limit(&dep->endpoint, size); + +@@ -2267,8 +2266,39 @@ static int dwc3_gadget_init_in_endpoint(struct dwc3_ep *dep) + static int dwc3_gadget_init_out_endpoint(struct dwc3_ep *dep) + { + struct dwc3 *dwc = dep->dwc; ++ int mdwidth; ++ int size; ++ ++ mdwidth = DWC3_MDWIDTH(dwc->hwparams.hwparams0); ++ ++ /* MDWIDTH is represented in bits, convert to bytes */ ++ mdwidth /= 8; + +- usb_ep_set_maxpacket_limit(&dep->endpoint, 1024); ++ /* All OUT endpoints share a single RxFIFO space */ ++ size = dwc3_readl(dwc->regs, DWC3_GRXFIFOSIZ(0)); ++ if (dwc3_is_usb31(dwc)) ++ size = DWC31_GRXFIFOSIZ_RXFDEP(size); ++ else ++ size = DWC3_GRXFIFOSIZ_RXFDEP(size); ++ ++ /* FIFO depth is in MDWDITH bytes */ ++ size *= mdwidth; ++ ++ /* ++ * To meet performance requirement, a minimum recommended RxFIFO size ++ * is defined as follow: ++ * RxFIFO size >= (3 x MaxPacketSize) + ++ * (3 x 8 bytes setup packets size) + (16 bytes clock crossing margin) ++ * ++ * Then calculate the max packet limit as below. ++ */ ++ size -= (3 * 8) + 16; ++ if (size < 0) ++ size = 0; ++ else ++ size /= 3; ++ ++ usb_ep_set_maxpacket_limit(&dep->endpoint, size); + dep->endpoint.max_streams = 15; + dep->endpoint.ops = &dwc3_gadget_ep_ops; + list_add_tail(&dep->endpoint.ep_list, +diff --git a/drivers/vhost/vsock.c b/drivers/vhost/vsock.c +index c2d7d57e98cf..bb3f63386b47 100644 +--- a/drivers/vhost/vsock.c ++++ b/drivers/vhost/vsock.c +@@ -543,6 +543,11 @@ static int vhost_vsock_start(struct vhost_vsock *vsock) + mutex_unlock(&vq->mutex); + } + ++ /* Some packets may have been queued before the device was started, ++ * let's kick the send worker to send them. ++ */ ++ vhost_work_queue(&vsock->dev, &vsock->send_pkt_work); ++ + mutex_unlock(&vsock->dev.mutex); + return 0; + +diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c +index 4804d1df8c1c..9c614d6916c2 100644 +--- a/fs/cifs/connect.c ++++ b/fs/cifs/connect.c +@@ -375,8 +375,10 @@ static int reconn_set_ipaddr(struct TCP_Server_Info *server) + return rc; + } + ++ spin_lock(&cifs_tcp_ses_lock); + rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr, + strlen(ipaddr)); ++ spin_unlock(&cifs_tcp_ses_lock); + kfree(ipaddr); + + return !rc ? -1 : 0; +@@ -3417,6 +3419,10 @@ cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info) + spin_lock(&cifs_tcp_ses_lock); + list_for_each(tmp, &ses->tcon_list) { + tcon = list_entry(tmp, struct cifs_tcon, tcon_list); ++#ifdef CONFIG_CIFS_DFS_UPCALL ++ if (tcon->dfs_path) ++ continue; ++#endif + if (!match_tcon(tcon, volume_info)) + continue; + ++tcon->tc_count; +diff --git a/include/drm/bridge/analogix_dp.h b/include/drm/bridge/analogix_dp.h +index 7aa2f93da49c..b0dcc07334a1 100644 +--- a/include/drm/bridge/analogix_dp.h ++++ b/include/drm/bridge/analogix_dp.h +@@ -42,9 +42,10 @@ int analogix_dp_resume(struct analogix_dp_device *dp); + int analogix_dp_suspend(struct analogix_dp_device *dp); + + struct analogix_dp_device * +-analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, +- struct analogix_dp_plat_data *plat_data); ++analogix_dp_probe(struct device *dev, struct analogix_dp_plat_data *plat_data); ++int analogix_dp_bind(struct analogix_dp_device *dp, struct drm_device *drm_dev); + void analogix_dp_unbind(struct analogix_dp_device *dp); ++void analogix_dp_remove(struct analogix_dp_device *dp); + + int analogix_dp_start_crc(struct drm_connector *connector); + int analogix_dp_stop_crc(struct drm_connector *connector); +diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h +index 73c66a3a33ae..7f3486e32e5d 100644 +--- a/include/linux/ieee80211.h ++++ b/include/linux/ieee80211.h +@@ -619,6 +619,15 @@ static inline bool ieee80211_is_qos_nullfunc(__le16 fc) + cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_NULLFUNC); + } + ++/** ++ * ieee80211_is_any_nullfunc - check if frame is regular or QoS nullfunc frame ++ * @fc: frame control bytes in little-endian byteorder ++ */ ++static inline bool ieee80211_is_any_nullfunc(__le16 fc) ++{ ++ return (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)); ++} ++ + /** + * ieee80211_is_bufferable_mmpdu - check if frame is bufferable MMPDU + * @fc: frame control field in little-endian byteorder +diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c +index fd81c7de77a7..63089c70adbb 100644 +--- a/kernel/trace/ftrace.c ++++ b/kernel/trace/ftrace.c +@@ -5155,6 +5155,7 @@ int unregister_ftrace_direct(unsigned long ip, unsigned long addr) + list_del_rcu(&direct->next); + synchronize_rcu_tasks(); + kfree(direct); ++ kfree(entry); + ftrace_direct_func_count--; + } + } +diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c +index 5f6834a2bf41..fcab11cc6833 100644 +--- a/kernel/trace/trace_events_hist.c ++++ b/kernel/trace/trace_events_hist.c +@@ -3320,6 +3320,9 @@ static void __destroy_hist_field(struct hist_field *hist_field) + kfree(hist_field->name); + kfree(hist_field->type); + ++ kfree(hist_field->system); ++ kfree(hist_field->event_name); ++ + kfree(hist_field); + } + +@@ -4382,6 +4385,7 @@ static struct hist_field *create_var(struct hist_trigger_data *hist_data, + goto out; + } + ++ var->ref = 1; + var->flags = HIST_FIELD_FL_VAR; + var->var.idx = idx; + var->var.hist_data = var->hist_data = hist_data; +@@ -5011,6 +5015,9 @@ static void destroy_field_vars(struct hist_trigger_data *hist_data) + + for (i = 0; i < hist_data->n_field_vars; i++) + destroy_field_var(hist_data->field_vars[i]); ++ ++ for (i = 0; i < hist_data->n_save_vars; i++) ++ destroy_field_var(hist_data->save_vars[i]); + } + + static void save_field_var(struct hist_trigger_data *hist_data, +diff --git a/lib/mpi/longlong.h b/lib/mpi/longlong.h +index 2dceaca27489..891e1c3549c4 100644 +--- a/lib/mpi/longlong.h ++++ b/lib/mpi/longlong.h +@@ -722,22 +722,22 @@ do { \ + do { \ + if (__builtin_constant_p(bh) && (bh) == 0) \ + __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "%r" ((USItype)(ah)), \ + "%r" ((USItype)(al)), \ + "rI" ((USItype)(bl))); \ + else if (__builtin_constant_p(bh) && (bh) == ~(USItype) 0) \ + __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "%r" ((USItype)(ah)), \ + "%r" ((USItype)(al)), \ + "rI" ((USItype)(bl))); \ + else \ + __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "%r" ((USItype)(ah)), \ + "r" ((USItype)(bh)), \ + "%r" ((USItype)(al)), \ +@@ -747,36 +747,36 @@ do { \ + do { \ + if (__builtin_constant_p(ah) && (ah) == 0) \ + __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "r" ((USItype)(bh)), \ + "rI" ((USItype)(al)), \ + "r" ((USItype)(bl))); \ + else if (__builtin_constant_p(ah) && (ah) == ~(USItype) 0) \ + __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "r" ((USItype)(bh)), \ + "rI" ((USItype)(al)), \ + "r" ((USItype)(bl))); \ + else if (__builtin_constant_p(bh) && (bh) == 0) \ + __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "r" ((USItype)(ah)), \ + "rI" ((USItype)(al)), \ + "r" ((USItype)(bl))); \ + else if (__builtin_constant_p(bh) && (bh) == ~(USItype) 0) \ + __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "r" ((USItype)(ah)), \ + "rI" ((USItype)(al)), \ + "r" ((USItype)(bl))); \ + else \ + __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2" \ +- : "=r" ((USItype)(sh)), \ +- "=&r" ((USItype)(sl)) \ ++ : "=r" (sh), \ ++ "=&r" (sl) \ + : "r" ((USItype)(ah)), \ + "r" ((USItype)(bh)), \ + "rI" ((USItype)(al)), \ +@@ -787,7 +787,7 @@ do { \ + do { \ + USItype __m0 = (m0), __m1 = (m1); \ + __asm__ ("mulhwu %0,%1,%2" \ +- : "=r" ((USItype) ph) \ ++ : "=r" (ph) \ + : "%r" (__m0), \ + "r" (__m1)); \ + (pl) = __m0 * __m1; \ +diff --git a/mm/mremap.c b/mm/mremap.c +index af363063ea23..d28f08a36b96 100644 +--- a/mm/mremap.c ++++ b/mm/mremap.c +@@ -606,6 +606,16 @@ SYSCALL_DEFINE5(mremap, unsigned long, addr, unsigned long, old_len, + LIST_HEAD(uf_unmap_early); + LIST_HEAD(uf_unmap); + ++ /* ++ * There is a deliberate asymmetry here: we strip the pointer tag ++ * from the old address but leave the new address alone. This is ++ * for consistency with mmap(), where we prevent the creation of ++ * aliasing mappings in userspace by leaving the tag bits of the ++ * mapping address intact. A non-zero tag will cause the subsequent ++ * range checks to reject the address as invalid. ++ * ++ * See Documentation/arm64/tagged-address-abi.rst for more information. ++ */ + addr = untagged_addr(addr); + + if (flags & ~(MREMAP_FIXED | MREMAP_MAYMOVE)) +diff --git a/net/core/netclassid_cgroup.c b/net/core/netclassid_cgroup.c +index b4c87fe31be2..41b24cd31562 100644 +--- a/net/core/netclassid_cgroup.c ++++ b/net/core/netclassid_cgroup.c +@@ -127,10 +127,8 @@ static int write_classid(struct cgroup_subsys_state *css, struct cftype *cft, + cs->classid = (u32)value; + + css_task_iter_start(css, 0, &it); +- while ((p = css_task_iter_next(&it))) { ++ while ((p = css_task_iter_next(&it))) + update_classid_task(p, cs->classid); +- cond_resched(); +- } + css_task_iter_end(&it); + + return 0; +diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c +index 88d7a692a965..c21fbc6cc991 100644 +--- a/net/mac80211/mlme.c ++++ b/net/mac80211/mlme.c +@@ -2460,7 +2460,7 @@ void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata, + if (!ieee80211_is_data(hdr->frame_control)) + return; + +- if (ieee80211_is_nullfunc(hdr->frame_control) && ++ if (ieee80211_is_any_nullfunc(hdr->frame_control) && + sdata->u.mgd.probe_send_count > 0) { + if (ack) + ieee80211_sta_reset_conn_monitor(sdata); +diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c +index 0ba98ad9bc85..69429c8df7b3 100644 +--- a/net/mac80211/rx.c ++++ b/net/mac80211/rx.c +@@ -1450,8 +1450,7 @@ ieee80211_rx_h_check_dup(struct ieee80211_rx_data *rx) + return RX_CONTINUE; + + if (ieee80211_is_ctl(hdr->frame_control) || +- ieee80211_is_nullfunc(hdr->frame_control) || +- ieee80211_is_qos_nullfunc(hdr->frame_control) || ++ ieee80211_is_any_nullfunc(hdr->frame_control) || + is_multicast_ether_addr(hdr->addr1)) + return RX_CONTINUE; + +@@ -1838,8 +1837,7 @@ ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx) + * Drop (qos-)data::nullfunc frames silently, since they + * are used only to control station power saving mode. + */ +- if (ieee80211_is_nullfunc(hdr->frame_control) || +- ieee80211_is_qos_nullfunc(hdr->frame_control)) { ++ if (ieee80211_is_any_nullfunc(hdr->frame_control)) { + I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc); + + /* +@@ -2319,7 +2317,7 @@ static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc) + + /* Drop unencrypted frames if key is set. */ + if (unlikely(!ieee80211_has_protected(fc) && +- !ieee80211_is_nullfunc(fc) && ++ !ieee80211_is_any_nullfunc(fc) && + ieee80211_is_data(fc) && rx->key)) + return -EACCES; + +diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c +index e3572be307d6..149ed0510778 100644 +--- a/net/mac80211/sta_info.c ++++ b/net/mac80211/sta_info.c +@@ -231,7 +231,8 @@ struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata, + struct sta_info *sta; + int i = 0; + +- list_for_each_entry_rcu(sta, &local->sta_list, list) { ++ list_for_each_entry_rcu(sta, &local->sta_list, list, ++ lockdep_is_held(&local->sta_mtx)) { + if (sdata != sta->sdata) + continue; + if (i < idx) { +diff --git a/net/mac80211/status.c b/net/mac80211/status.c +index b720feaf9a74..2c2d78bcd78a 100644 +--- a/net/mac80211/status.c ++++ b/net/mac80211/status.c +@@ -643,8 +643,7 @@ static void ieee80211_report_ack_skb(struct ieee80211_local *local, + rcu_read_lock(); + sdata = ieee80211_sdata_from_skb(local, skb); + if (sdata) { +- if (ieee80211_is_nullfunc(hdr->frame_control) || +- ieee80211_is_qos_nullfunc(hdr->frame_control)) ++ if (ieee80211_is_any_nullfunc(hdr->frame_control)) + cfg80211_probe_status(sdata->dev, hdr->addr1, + cookie, acked, + info->status.ack_signal, +@@ -1056,7 +1055,7 @@ static void __ieee80211_tx_status(struct ieee80211_hw *hw, + I802_DEBUG_INC(local->dot11FailedCount); + } + +- if ((ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) && ++ if (ieee80211_is_any_nullfunc(fc) && + ieee80211_has_pm(fc) && + ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) && + !(info->flags & IEEE80211_TX_CTL_INJECTED) && +diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c +index efe4c1fc68e5..a7b92d1feee1 100644 +--- a/net/mac80211/tx.c ++++ b/net/mac80211/tx.c +@@ -297,7 +297,7 @@ ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx) + if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) && + test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) && + !ieee80211_is_probe_req(hdr->frame_control) && +- !ieee80211_is_nullfunc(hdr->frame_control)) ++ !ieee80211_is_any_nullfunc(hdr->frame_control)) + /* + * When software scanning only nullfunc frames (to notify + * the sleep state to the AP) and probe requests (for the +diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c +index 09050c1d5517..f7cb0b7faec2 100644 +--- a/net/sctp/sm_make_chunk.c ++++ b/net/sctp/sm_make_chunk.c +@@ -858,7 +858,11 @@ struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc, + struct sctp_chunk *retval; + __u32 ctsn; + +- ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map); ++ if (chunk && chunk->asoc) ++ ctsn = sctp_tsnmap_get_ctsn(&chunk->asoc->peer.tsn_map); ++ else ++ ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map); ++ + shut.cum_tsn_ack = htonl(ctsn); + + retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN, 0, +diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c +index bd843a81afa0..d36cea4e270d 100644 +--- a/net/sunrpc/cache.c ++++ b/net/sunrpc/cache.c +@@ -521,7 +521,6 @@ void cache_purge(struct cache_detail *detail) + { + struct cache_head *ch = NULL; + struct hlist_head *head = NULL; +- struct hlist_node *tmp = NULL; + int i = 0; + + spin_lock(&detail->hash_lock); +@@ -533,7 +532,9 @@ void cache_purge(struct cache_detail *detail) + dprintk("RPC: %d entries in %s cache\n", detail->entries, detail->name); + for (i = 0; i < detail->hash_size; i++) { + head = &detail->hash_table[i]; +- hlist_for_each_entry_safe(ch, tmp, head, cache_list) { ++ while (!hlist_empty(head)) { ++ ch = hlist_entry(head->first, struct cache_head, ++ cache_list); + sunrpc_begin_cache_remove_entry(ch, detail); + spin_unlock(&detail->hash_lock); + sunrpc_end_cache_remove_entry(ch, detail); +diff --git a/scripts/config b/scripts/config +index e0e39826dae9..eee5b7f3a092 100755 +--- a/scripts/config ++++ b/scripts/config +@@ -7,6 +7,9 @@ myname=${0##*/} + # If no prefix forced, use the default CONFIG_ + CONFIG_="${CONFIG_-CONFIG_}" + ++# We use an uncommon delimiter for sed substitutions ++SED_DELIM=$(echo -en "\001") ++ + usage() { + cat >&2 <<EOL + Manipulate options in a .config file from the command line. +@@ -83,7 +86,7 @@ txt_subst() { + local infile="$3" + local tmpfile="$infile.swp" + +- sed -e "s:$before:$after:" "$infile" >"$tmpfile" ++ sed -e "s$SED_DELIM$before$SED_DELIM$after$SED_DELIM" "$infile" >"$tmpfile" + # replace original file with the edited one + mv "$tmpfile" "$infile" + } +diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c +index 59b60b1f26f8..8b015b27e9c7 100644 +--- a/sound/pci/hda/hda_intel.c ++++ b/sound/pci/hda/hda_intel.c +@@ -2075,9 +2075,10 @@ static void pcm_mmap_prepare(struct snd_pcm_substream *substream, + * some HD-audio PCI entries are exposed without any codecs, and such devices + * should be ignored from the beginning. + */ +-static const struct snd_pci_quirk driver_blacklist[] = { +- SND_PCI_QUIRK(0x1462, 0xcb59, "MSI TRX40 Creator", 0), +- SND_PCI_QUIRK(0x1462, 0xcb60, "MSI TRX40", 0), ++static const struct pci_device_id driver_blacklist[] = { ++ { PCI_DEVICE_SUB(0x1022, 0x1487, 0x1043, 0x874f) }, /* ASUS ROG Zenith II / Strix */ ++ { PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb59) }, /* MSI TRX40 Creator */ ++ { PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb60) }, /* MSI TRX40 */ + {} + }; + +@@ -2097,7 +2098,7 @@ static int azx_probe(struct pci_dev *pci, + bool schedule_probe; + int err; + +- if (snd_pci_quirk_lookup(pci, driver_blacklist)) { ++ if (pci_match_id(driver_blacklist, pci)) { + dev_info(&pci->dev, "Skipping the blacklisted device\n"); + return -ENODEV; + } +diff --git a/sound/soc/codecs/hdac_hdmi.c b/sound/soc/codecs/hdac_hdmi.c +index e6558475e006..f0f689ddbefe 100644 +--- a/sound/soc/codecs/hdac_hdmi.c ++++ b/sound/soc/codecs/hdac_hdmi.c +@@ -142,14 +142,14 @@ static struct hdac_hdmi_pcm * + hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv *hdmi, + struct hdac_hdmi_cvt *cvt) + { +- struct hdac_hdmi_pcm *pcm = NULL; ++ struct hdac_hdmi_pcm *pcm; + + list_for_each_entry(pcm, &hdmi->pcm_list, head) { + if (pcm->cvt == cvt) +- break; ++ return pcm; + } + +- return pcm; ++ return NULL; + } + + static void hdac_hdmi_jack_report(struct hdac_hdmi_pcm *pcm, +diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c +index d5130193b4a2..e8a8bf7b4ffe 100644 +--- a/sound/soc/codecs/sgtl5000.c ++++ b/sound/soc/codecs/sgtl5000.c +@@ -1653,6 +1653,40 @@ static int sgtl5000_i2c_probe(struct i2c_client *client, + dev_err(&client->dev, + "Error %d initializing CHIP_CLK_CTRL\n", ret); + ++ /* Mute everything to avoid pop from the following power-up */ ++ ret = regmap_write(sgtl5000->regmap, SGTL5000_CHIP_ANA_CTRL, ++ SGTL5000_CHIP_ANA_CTRL_DEFAULT); ++ if (ret) { ++ dev_err(&client->dev, ++ "Error %d muting outputs via CHIP_ANA_CTRL\n", ret); ++ goto disable_clk; ++ } ++ ++ /* ++ * If VAG is powered-on (e.g. from previous boot), it would be disabled ++ * by the write to ANA_POWER in later steps of the probe code. This ++ * may create a loud pop even with all outputs muted. The proper way ++ * to circumvent this is disabling the bit first and waiting the proper ++ * cool-down time. ++ */ ++ ret = regmap_read(sgtl5000->regmap, SGTL5000_CHIP_ANA_POWER, &value); ++ if (ret) { ++ dev_err(&client->dev, "Failed to read ANA_POWER: %d\n", ret); ++ goto disable_clk; ++ } ++ if (value & SGTL5000_VAG_POWERUP) { ++ ret = regmap_update_bits(sgtl5000->regmap, ++ SGTL5000_CHIP_ANA_POWER, ++ SGTL5000_VAG_POWERUP, ++ 0); ++ if (ret) { ++ dev_err(&client->dev, "Error %d disabling VAG\n", ret); ++ goto disable_clk; ++ } ++ ++ msleep(SGTL5000_VAG_POWERDOWN_DELAY); ++ } ++ + /* Follow section 2.2.1.1 of AN3663 */ + ana_pwr = SGTL5000_ANA_POWER_DEFAULT; + if (sgtl5000->num_supplies <= VDDD) { +diff --git a/sound/soc/codecs/sgtl5000.h b/sound/soc/codecs/sgtl5000.h +index a4bf4bca95bf..56ec5863f250 100644 +--- a/sound/soc/codecs/sgtl5000.h ++++ b/sound/soc/codecs/sgtl5000.h +@@ -233,6 +233,7 @@ + /* + * SGTL5000_CHIP_ANA_CTRL + */ ++#define SGTL5000_CHIP_ANA_CTRL_DEFAULT 0x0133 + #define SGTL5000_LINE_OUT_MUTE 0x0100 + #define SGTL5000_HP_SEL_MASK 0x0040 + #define SGTL5000_HP_SEL_SHIFT 6 +diff --git a/sound/soc/sh/rcar/ssi.c b/sound/soc/sh/rcar/ssi.c +index fc5d089868df..4a7d3413917f 100644 +--- a/sound/soc/sh/rcar/ssi.c ++++ b/sound/soc/sh/rcar/ssi.c +@@ -594,10 +594,16 @@ static int rsnd_ssi_stop(struct rsnd_mod *mod, + * Capture: It might not receave data. Do nothing + */ + if (rsnd_io_is_play(io)) { +- rsnd_mod_write(mod, SSICR, cr | EN); ++ rsnd_mod_write(mod, SSICR, cr | ssi->cr_en); + rsnd_ssi_status_check(mod, DIRQ); + } + ++ /* In multi-SSI mode, stop is performed by setting ssi0129 in ++ * SSI_CONTROL to 0 (in rsnd_ssio_stop_gen2). Do nothing here. ++ */ ++ if (rsnd_ssi_multi_slaves_runtime(io)) ++ return 0; ++ + /* + * disable SSI, + * and, wait idle state +@@ -737,6 +743,9 @@ static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, + if (!rsnd_rdai_is_clk_master(rdai)) + return; + ++ if (rsnd_ssi_is_multi_slave(mod, io)) ++ return; ++ + switch (rsnd_mod_id(mod)) { + case 1: + case 2: +diff --git a/sound/soc/sh/rcar/ssiu.c b/sound/soc/sh/rcar/ssiu.c +index f35d88211887..9c7c3e7539c9 100644 +--- a/sound/soc/sh/rcar/ssiu.c ++++ b/sound/soc/sh/rcar/ssiu.c +@@ -221,7 +221,7 @@ static int rsnd_ssiu_init_gen2(struct rsnd_mod *mod, + i; + + for_each_rsnd_mod_array(i, pos, io, rsnd_ssi_array) { +- shift = (i * 4) + 16; ++ shift = (i * 4) + 20; + val = (val & ~(0xF << shift)) | + rsnd_mod_id(pos) << shift; + } +diff --git a/sound/soc/soc-topology.c b/sound/soc/soc-topology.c +index a152409e8746..009d65a6fb43 100644 +--- a/sound/soc/soc-topology.c ++++ b/sound/soc/soc-topology.c +@@ -894,7 +894,13 @@ static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count, + } + + /* create any TLV data */ +- soc_tplg_create_tlv(tplg, &kc, &mc->hdr); ++ err = soc_tplg_create_tlv(tplg, &kc, &mc->hdr); ++ if (err < 0) { ++ dev_err(tplg->dev, "ASoC: failed to create TLV %s\n", ++ mc->hdr.name); ++ kfree(sm); ++ continue; ++ } + + /* pass control to driver for optional further init */ + err = soc_tplg_init_kcontrol(tplg, &kc, +@@ -1118,6 +1124,7 @@ static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg, + struct snd_soc_tplg_hdr *hdr) + { + struct snd_soc_tplg_ctl_hdr *control_hdr; ++ int ret; + int i; + + if (tplg->pass != SOC_TPLG_PASS_MIXER) { +@@ -1146,25 +1153,30 @@ static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg, + case SND_SOC_TPLG_CTL_RANGE: + case SND_SOC_TPLG_DAPM_CTL_VOLSW: + case SND_SOC_TPLG_DAPM_CTL_PIN: +- soc_tplg_dmixer_create(tplg, 1, +- le32_to_cpu(hdr->payload_size)); ++ ret = soc_tplg_dmixer_create(tplg, 1, ++ le32_to_cpu(hdr->payload_size)); + break; + case SND_SOC_TPLG_CTL_ENUM: + case SND_SOC_TPLG_CTL_ENUM_VALUE: + case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: + case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: + case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: +- soc_tplg_denum_create(tplg, 1, +- le32_to_cpu(hdr->payload_size)); ++ ret = soc_tplg_denum_create(tplg, 1, ++ le32_to_cpu(hdr->payload_size)); + break; + case SND_SOC_TPLG_CTL_BYTES: +- soc_tplg_dbytes_create(tplg, 1, +- le32_to_cpu(hdr->payload_size)); ++ ret = soc_tplg_dbytes_create(tplg, 1, ++ le32_to_cpu(hdr->payload_size)); + break; + default: + soc_bind_err(tplg, control_hdr, i); + return -EINVAL; + } ++ if (ret < 0) { ++ dev_err(tplg->dev, "ASoC: invalid control\n"); ++ return ret; ++ } ++ + } + + return 0; +@@ -1272,7 +1284,9 @@ static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg, + routes[i]->dobj.index = tplg->index; + list_add(&routes[i]->dobj.list, &tplg->comp->dobj_list); + +- soc_tplg_add_route(tplg, routes[i]); ++ ret = soc_tplg_add_route(tplg, routes[i]); ++ if (ret < 0) ++ break; + + /* add route, but keep going if some fail */ + snd_soc_dapm_add_routes(dapm, routes[i], 1); +@@ -1355,7 +1369,13 @@ static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create( + } + + /* create any TLV data */ +- soc_tplg_create_tlv(tplg, &kc[i], &mc->hdr); ++ err = soc_tplg_create_tlv(tplg, &kc[i], &mc->hdr); ++ if (err < 0) { ++ dev_err(tplg->dev, "ASoC: failed to create TLV %s\n", ++ mc->hdr.name); ++ kfree(sm); ++ continue; ++ } + + /* pass control to driver for optional further init */ + err = soc_tplg_init_kcontrol(tplg, &kc[i], +@@ -1766,10 +1786,13 @@ static int soc_tplg_dapm_complete(struct soc_tplg *tplg) + return 0; + } + +-static void set_stream_info(struct snd_soc_pcm_stream *stream, ++static int set_stream_info(struct snd_soc_pcm_stream *stream, + struct snd_soc_tplg_stream_caps *caps) + { + stream->stream_name = kstrdup(caps->name, GFP_KERNEL); ++ if (!stream->stream_name) ++ return -ENOMEM; ++ + stream->channels_min = le32_to_cpu(caps->channels_min); + stream->channels_max = le32_to_cpu(caps->channels_max); + stream->rates = le32_to_cpu(caps->rates); +@@ -1777,6 +1800,8 @@ static void set_stream_info(struct snd_soc_pcm_stream *stream, + stream->rate_max = le32_to_cpu(caps->rate_max); + stream->formats = le64_to_cpu(caps->formats); + stream->sig_bits = le32_to_cpu(caps->sig_bits); ++ ++ return 0; + } + + static void set_dai_flags(struct snd_soc_dai_driver *dai_drv, +@@ -1812,20 +1837,29 @@ static int soc_tplg_dai_create(struct soc_tplg *tplg, + if (dai_drv == NULL) + return -ENOMEM; + +- if (strlen(pcm->dai_name)) ++ if (strlen(pcm->dai_name)) { + dai_drv->name = kstrdup(pcm->dai_name, GFP_KERNEL); ++ if (!dai_drv->name) { ++ ret = -ENOMEM; ++ goto err; ++ } ++ } + dai_drv->id = le32_to_cpu(pcm->dai_id); + + if (pcm->playback) { + stream = &dai_drv->playback; + caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; +- set_stream_info(stream, caps); ++ ret = set_stream_info(stream, caps); ++ if (ret < 0) ++ goto err; + } + + if (pcm->capture) { + stream = &dai_drv->capture; + caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE]; +- set_stream_info(stream, caps); ++ ret = set_stream_info(stream, caps); ++ if (ret < 0) ++ goto err; + } + + if (pcm->compress) +@@ -1835,11 +1869,7 @@ static int soc_tplg_dai_create(struct soc_tplg *tplg, + ret = soc_tplg_dai_load(tplg, dai_drv, pcm, NULL); + if (ret < 0) { + dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); +- kfree(dai_drv->playback.stream_name); +- kfree(dai_drv->capture.stream_name); +- kfree(dai_drv->name); +- kfree(dai_drv); +- return ret; ++ goto err; + } + + dai_drv->dobj.index = tplg->index; +@@ -1860,6 +1890,14 @@ static int soc_tplg_dai_create(struct soc_tplg *tplg, + return ret; + } + ++ return 0; ++ ++err: ++ kfree(dai_drv->playback.stream_name); ++ kfree(dai_drv->capture.stream_name); ++ kfree(dai_drv->name); ++ kfree(dai_drv); ++ + return ret; + } + +@@ -1916,11 +1954,20 @@ static int soc_tplg_fe_link_create(struct soc_tplg *tplg, + if (strlen(pcm->pcm_name)) { + link->name = kstrdup(pcm->pcm_name, GFP_KERNEL); + link->stream_name = kstrdup(pcm->pcm_name, GFP_KERNEL); ++ if (!link->name || !link->stream_name) { ++ ret = -ENOMEM; ++ goto err; ++ } + } + link->id = le32_to_cpu(pcm->pcm_id); + +- if (strlen(pcm->dai_name)) ++ if (strlen(pcm->dai_name)) { + link->cpus->dai_name = kstrdup(pcm->dai_name, GFP_KERNEL); ++ if (!link->cpus->dai_name) { ++ ret = -ENOMEM; ++ goto err; ++ } ++ } + + link->codecs->name = "snd-soc-dummy"; + link->codecs->dai_name = "snd-soc-dummy-dai"; +@@ -2088,7 +2135,9 @@ static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, + _pcm = pcm; + } else { + abi_match = false; +- pcm_new_ver(tplg, pcm, &_pcm); ++ ret = pcm_new_ver(tplg, pcm, &_pcm); ++ if (ret < 0) ++ return ret; + } + + /* create the FE DAIs and DAI links */ +@@ -2436,13 +2485,17 @@ static int soc_tplg_dai_config(struct soc_tplg *tplg, + if (d->playback) { + stream = &dai_drv->playback; + caps = &d->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; +- set_stream_info(stream, caps); ++ ret = set_stream_info(stream, caps); ++ if (ret < 0) ++ goto err; + } + + if (d->capture) { + stream = &dai_drv->capture; + caps = &d->caps[SND_SOC_TPLG_STREAM_CAPTURE]; +- set_stream_info(stream, caps); ++ ret = set_stream_info(stream, caps); ++ if (ret < 0) ++ goto err; + } + + if (d->flag_mask) +@@ -2454,10 +2507,15 @@ static int soc_tplg_dai_config(struct soc_tplg *tplg, + ret = soc_tplg_dai_load(tplg, dai_drv, NULL, dai); + if (ret < 0) { + dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); +- return ret; ++ goto err; + } + + return 0; ++ ++err: ++ kfree(dai_drv->playback.stream_name); ++ kfree(dai_drv->capture.stream_name); ++ return ret; + } + + /* load physical DAI elements */ +@@ -2466,7 +2524,7 @@ static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, + { + struct snd_soc_tplg_dai *dai; + int count; +- int i; ++ int i, ret; + + count = le32_to_cpu(hdr->count); + +@@ -2481,7 +2539,12 @@ static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, + return -EINVAL; + } + +- soc_tplg_dai_config(tplg, dai); ++ ret = soc_tplg_dai_config(tplg, dai); ++ if (ret < 0) { ++ dev_err(tplg->dev, "ASoC: failed to configure DAI\n"); ++ return ret; ++ } ++ + tplg->pos += (sizeof(*dai) + le32_to_cpu(dai->priv.size)); + } + +@@ -2589,7 +2652,7 @@ static int soc_valid_header(struct soc_tplg *tplg, + } + + /* big endian firmware objects not supported atm */ +- if (hdr->magic == SOC_TPLG_MAGIC_BIG_ENDIAN) { ++ if (le32_to_cpu(hdr->magic) == SOC_TPLG_MAGIC_BIG_ENDIAN) { + dev_err(tplg->dev, + "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", + tplg->pass, hdr->magic, +diff --git a/tools/bpf/runqslower/Makefile b/tools/bpf/runqslower/Makefile +index 39edd68afa8e..8a6f82e56a24 100644 +--- a/tools/bpf/runqslower/Makefile ++++ b/tools/bpf/runqslower/Makefile +@@ -8,7 +8,7 @@ BPFTOOL ?= $(DEFAULT_BPFTOOL) + LIBBPF_SRC := $(abspath ../../lib/bpf) + BPFOBJ := $(OUTPUT)/libbpf.a + BPF_INCLUDE := $(OUTPUT) +-INCLUDES := -I$(BPF_INCLUDE) -I$(OUTPUT) -I$(abspath ../../lib) ++INCLUDES := -I$(OUTPUT) -I$(BPF_INCLUDE) -I$(abspath ../../lib) + CFLAGS := -g -Wall + + # Try to detect best kernel BTF source +diff --git a/tools/testing/selftests/ipc/msgque.c b/tools/testing/selftests/ipc/msgque.c +index 4c156aeab6b8..5ec4d9e18806 100644 +--- a/tools/testing/selftests/ipc/msgque.c ++++ b/tools/testing/selftests/ipc/msgque.c +@@ -137,7 +137,7 @@ int dump_queue(struct msgque_data *msgque) + for (kern_id = 0; kern_id < 256; kern_id++) { + ret = msgctl(kern_id, MSG_STAT, &ds); + if (ret < 0) { +- if (errno == -EINVAL) ++ if (errno == EINVAL) + continue; + printf("Failed to get stats for IPC queue with id %d\n", + kern_id); +diff --git a/tools/testing/selftests/tpm2/test_smoke.sh b/tools/testing/selftests/tpm2/test_smoke.sh +index b630c7b5950a..8155c2ea7ccb 100755 +--- a/tools/testing/selftests/tpm2/test_smoke.sh ++++ b/tools/testing/selftests/tpm2/test_smoke.sh +@@ -1,17 +1,8 @@ + #!/bin/bash + # SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) +-self.flags = flags + +-# Kselftest framework requirement - SKIP code is 4. +-ksft_skip=4 +- +- +-if [ -f /dev/tpm0 ] ; then +- python -m unittest -v tpm2_tests.SmokeTest +- python -m unittest -v tpm2_tests.AsyncTest +-else +- exit $ksft_skip +-fi ++python -m unittest -v tpm2_tests.SmokeTest ++python -m unittest -v tpm2_tests.AsyncTest + + CLEAR_CMD=$(which tpm2_clear) + if [ -n $CLEAR_CMD ]; then +diff --git a/tools/testing/selftests/tpm2/test_space.sh b/tools/testing/selftests/tpm2/test_space.sh +index 180b469c53b4..a6f5e346635e 100755 +--- a/tools/testing/selftests/tpm2/test_space.sh ++++ b/tools/testing/selftests/tpm2/test_space.sh +@@ -1,11 +1,4 @@ + #!/bin/bash + # SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) + +-# Kselftest framework requirement - SKIP code is 4. +-ksft_skip=4 +- +-if [ -f /dev/tpmrm0 ] ; then +- python -m unittest -v tpm2_tests.SpaceTest +-else +- exit $ksft_skip +-fi ++python -m unittest -v tpm2_tests.SpaceTest +diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile +index 7f9a8a8c31da..8074340c6b3a 100644 +--- a/tools/testing/selftests/vm/Makefile ++++ b/tools/testing/selftests/vm/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + # Makefile for vm selftests + uname_M := $(shell uname -m 2>/dev/null || echo not) +-ARCH ?= $(shell echo $(uname_M) | sed -e 's/aarch64.*/arm64/') ++MACHINE ?= $(shell echo $(uname_M) | sed -e 's/aarch64.*/arm64/') + + CFLAGS = -Wall -I ../../../../usr/include $(EXTRA_CFLAGS) + LDLIBS = -lrt +@@ -19,7 +19,7 @@ TEST_GEN_FILES += thuge-gen + TEST_GEN_FILES += transhuge-stress + TEST_GEN_FILES += userfaultfd + +-ifneq (,$(filter $(ARCH),arm64 ia64 mips64 parisc64 ppc64 riscv64 s390x sh64 sparc64 x86_64)) ++ifneq (,$(filter $(MACHINE),arm64 ia64 mips64 parisc64 ppc64 ppc64le riscv64 s390x sh64 sparc64 x86_64)) + TEST_GEN_FILES += va_128TBswitch + TEST_GEN_FILES += virtual_address_range + endif +diff --git a/tools/testing/selftests/vm/run_vmtests b/tools/testing/selftests/vm/run_vmtests +index f33714843198..6e137c9baa1e 100755 +--- a/tools/testing/selftests/vm/run_vmtests ++++ b/tools/testing/selftests/vm/run_vmtests +@@ -59,7 +59,7 @@ else + fi + + #filter 64bit architectures +-ARCH64STR="arm64 ia64 mips64 parisc64 ppc64 riscv64 s390x sh64 sparc64 x86_64" ++ARCH64STR="arm64 ia64 mips64 parisc64 ppc64 ppc64le riscv64 s390x sh64 sparc64 x86_64" + if [ -z $ARCH ]; then + ARCH=`uname -m 2>/dev/null | sed -e 's/aarch64.*/arm64/'` + fi
