commit: 5f098a1db04014be1f66642a7062bf5eb66e1567 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Fri Jun 18 11:37:01 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Fri Jun 18 11:37:01 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=5f098a1d
Linux patch 5.10.45 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1044_linux-5.10.45.patch | 1077 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1081 insertions(+) diff --git a/0000_README b/0000_README index e96b155..5ac74f5 100644 --- a/0000_README +++ b/0000_README @@ -219,6 +219,10 @@ Patch: 1043_linux-5.10.44.patch From: http://www.kernel.org Desc: Linux 5.10.44 +Patch: 1044_linux-5.10.45.patch +From: http://www.kernel.org +Desc: Linux 5.10.45 + 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/1044_linux-5.10.45.patch b/1044_linux-5.10.45.patch new file mode 100644 index 0000000..d41c3c1 --- /dev/null +++ b/1044_linux-5.10.45.patch @@ -0,0 +1,1077 @@ +diff --git a/Makefile b/Makefile +index ae33e048eb8db..808b68483002f 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 10 +-SUBLEVEL = 44 ++SUBLEVEL = 45 + EXTRAVERSION = + NAME = Dare mighty things + +diff --git a/arch/arm/mach-omap1/pm.c b/arch/arm/mach-omap1/pm.c +index 2c1e2b32b9b36..a745d64d46995 100644 +--- a/arch/arm/mach-omap1/pm.c ++++ b/arch/arm/mach-omap1/pm.c +@@ -655,9 +655,13 @@ static int __init omap_pm_init(void) + irq = INT_7XX_WAKE_UP_REQ; + else if (cpu_is_omap16xx()) + irq = INT_1610_WAKE_UP_REQ; +- if (request_irq(irq, omap_wakeup_interrupt, 0, "peripheral wakeup", +- NULL)) +- pr_err("Failed to request irq %d (peripheral wakeup)\n", irq); ++ else ++ irq = -1; ++ ++ if (irq >= 0) { ++ if (request_irq(irq, omap_wakeup_interrupt, 0, "peripheral wakeup", NULL)) ++ pr_err("Failed to request irq %d (peripheral wakeup)\n", irq); ++ } + + /* Program new power ramp-up time + * (0 for most boards since we don't lower voltage when in deep sleep) +diff --git a/arch/arm/mach-omap2/board-n8x0.c b/arch/arm/mach-omap2/board-n8x0.c +index 418a61ecb8275..5e86145db0e2a 100644 +--- a/arch/arm/mach-omap2/board-n8x0.c ++++ b/arch/arm/mach-omap2/board-n8x0.c +@@ -322,6 +322,7 @@ static int n8x0_mmc_get_cover_state(struct device *dev, int slot) + + static void n8x0_mmc_callback(void *data, u8 card_mask) + { ++#ifdef CONFIG_MMC_OMAP + int bit, *openp, index; + + if (board_is_n800()) { +@@ -339,7 +340,6 @@ static void n8x0_mmc_callback(void *data, u8 card_mask) + else + *openp = 0; + +-#ifdef CONFIG_MMC_OMAP + omap_mmc_notify_cover_event(mmc_device, index, *openp); + #else + pr_warn("MMC: notify cover event not available\n"); +diff --git a/arch/riscv/Makefile b/arch/riscv/Makefile +index 0289a97325d12..e241e0e85ac81 100644 +--- a/arch/riscv/Makefile ++++ b/arch/riscv/Makefile +@@ -36,6 +36,15 @@ else + KBUILD_LDFLAGS += -melf32lriscv + endif + ++ifeq ($(CONFIG_LD_IS_LLD),y) ++ KBUILD_CFLAGS += -mno-relax ++ KBUILD_AFLAGS += -mno-relax ++ifneq ($(LLVM_IAS),1) ++ KBUILD_CFLAGS += -Wa,-mno-relax ++ KBUILD_AFLAGS += -Wa,-mno-relax ++endif ++endif ++ + # ISA string setting + riscv-march-$(CONFIG_ARCH_RV32I) := rv32ima + riscv-march-$(CONFIG_ARCH_RV64I) := rv64ima +diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c +index 175cb1c0d5698..b1f0b13cc8bc6 100644 +--- a/drivers/bluetooth/btusb.c ++++ b/drivers/bluetooth/btusb.c +@@ -385,6 +385,8 @@ static const struct usb_device_id blacklist_table[] = { + /* Realtek 8822CE Bluetooth devices */ + { USB_DEVICE(0x0bda, 0xb00c), .driver_info = BTUSB_REALTEK | + BTUSB_WIDEBAND_SPEECH }, ++ { USB_DEVICE(0x0bda, 0xc822), .driver_info = BTUSB_REALTEK | ++ BTUSB_WIDEBAND_SPEECH }, + + /* Realtek Bluetooth devices */ + { USB_VENDOR_AND_INTERFACE_INFO(0x0bda, 0xe0, 0x01, 0x01), +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fru_eeprom.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fru_eeprom.c +index 8f4a8f8d81463..39b6c6bfab453 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fru_eeprom.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fru_eeprom.c +@@ -101,7 +101,8 @@ static int amdgpu_fru_read_eeprom(struct amdgpu_device *adev, uint32_t addrptr, + int amdgpu_fru_get_product_info(struct amdgpu_device *adev) + { + unsigned char buff[34]; +- int addrptr = 0, size = 0; ++ int addrptr, size; ++ int len; + + if (!is_fru_eeprom_supported(adev)) + return 0; +@@ -109,7 +110,7 @@ int amdgpu_fru_get_product_info(struct amdgpu_device *adev) + /* If algo exists, it means that the i2c_adapter's initialized */ + if (!adev->pm.smu_i2c.algo) { + DRM_WARN("Cannot access FRU, EEPROM accessor not initialized"); +- return 0; ++ return -ENODEV; + } + + /* There's a lot of repetition here. This is due to the FRU having +@@ -128,7 +129,7 @@ int amdgpu_fru_get_product_info(struct amdgpu_device *adev) + size = amdgpu_fru_read_eeprom(adev, addrptr, buff); + if (size < 1) { + DRM_ERROR("Failed to read FRU Manufacturer, ret:%d", size); +- return size; ++ return -EINVAL; + } + + /* Increment the addrptr by the size of the field, and 1 due to the +@@ -138,43 +139,45 @@ int amdgpu_fru_get_product_info(struct amdgpu_device *adev) + size = amdgpu_fru_read_eeprom(adev, addrptr, buff); + if (size < 1) { + DRM_ERROR("Failed to read FRU product name, ret:%d", size); +- return size; ++ return -EINVAL; + } + ++ len = size; + /* Product name should only be 32 characters. Any more, + * and something could be wrong. Cap it at 32 to be safe + */ +- if (size > 32) { ++ if (len >= sizeof(adev->product_name)) { + DRM_WARN("FRU Product Number is larger than 32 characters. This is likely a mistake"); +- size = 32; ++ len = sizeof(adev->product_name) - 1; + } + /* Start at 2 due to buff using fields 0 and 1 for the address */ +- memcpy(adev->product_name, &buff[2], size); +- adev->product_name[size] = '\0'; ++ memcpy(adev->product_name, &buff[2], len); ++ adev->product_name[len] = '\0'; + + addrptr += size + 1; + size = amdgpu_fru_read_eeprom(adev, addrptr, buff); + if (size < 1) { + DRM_ERROR("Failed to read FRU product number, ret:%d", size); +- return size; ++ return -EINVAL; + } + ++ len = size; + /* Product number should only be 16 characters. Any more, + * and something could be wrong. Cap it at 16 to be safe + */ +- if (size > 16) { ++ if (len >= sizeof(adev->product_number)) { + DRM_WARN("FRU Product Number is larger than 16 characters. This is likely a mistake"); +- size = 16; ++ len = sizeof(adev->product_number) - 1; + } +- memcpy(adev->product_number, &buff[2], size); +- adev->product_number[size] = '\0'; ++ memcpy(adev->product_number, &buff[2], len); ++ adev->product_number[len] = '\0'; + + addrptr += size + 1; + size = amdgpu_fru_read_eeprom(adev, addrptr, buff); + + if (size < 1) { + DRM_ERROR("Failed to read FRU product version, ret:%d", size); +- return size; ++ return -EINVAL; + } + + addrptr += size + 1; +@@ -182,18 +185,19 @@ int amdgpu_fru_get_product_info(struct amdgpu_device *adev) + + if (size < 1) { + DRM_ERROR("Failed to read FRU serial number, ret:%d", size); +- return size; ++ return -EINVAL; + } + ++ len = size; + /* Serial number should only be 16 characters. Any more, + * and something could be wrong. Cap it at 16 to be safe + */ +- if (size > 16) { ++ if (len >= sizeof(adev->serial)) { + DRM_WARN("FRU Serial Number is larger than 16 characters. This is likely a mistake"); +- size = 16; ++ len = sizeof(adev->serial) - 1; + } +- memcpy(adev->serial, &buff[2], size); +- adev->serial[size] = '\0'; ++ memcpy(adev->serial, &buff[2], len); ++ adev->serial[len] = '\0'; + + return 0; + } +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h +index 919d2fb7427b1..60b7563f4c05d 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h +@@ -73,6 +73,7 @@ struct psp_ring + uint64_t ring_mem_mc_addr; + void *ring_mem_handle; + uint32_t ring_size; ++ uint32_t ring_wptr; + }; + + /* More registers may will be supported */ +diff --git a/drivers/gpu/drm/amd/amdgpu/psp_v11_0.c b/drivers/gpu/drm/amd/amdgpu/psp_v11_0.c +index 6c5d9612abcb6..cb764b5545527 100644 +--- a/drivers/gpu/drm/amd/amdgpu/psp_v11_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/psp_v11_0.c +@@ -732,7 +732,7 @@ static uint32_t psp_v11_0_ring_get_wptr(struct psp_context *psp) + struct amdgpu_device *adev = psp->adev; + + if (amdgpu_sriov_vf(adev)) +- data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102); ++ data = psp->km_ring.ring_wptr; + else + data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67); + +@@ -746,6 +746,7 @@ static void psp_v11_0_ring_set_wptr(struct psp_context *psp, uint32_t value) + if (amdgpu_sriov_vf(adev)) { + WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102, value); + WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_101, GFX_CTRL_CMD_ID_CONSUME_CMD); ++ psp->km_ring.ring_wptr = value; + } else + WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67, value); + } +diff --git a/drivers/gpu/drm/amd/amdgpu/psp_v3_1.c b/drivers/gpu/drm/amd/amdgpu/psp_v3_1.c +index f2e725f72d2f1..908664a5774bb 100644 +--- a/drivers/gpu/drm/amd/amdgpu/psp_v3_1.c ++++ b/drivers/gpu/drm/amd/amdgpu/psp_v3_1.c +@@ -379,7 +379,7 @@ static uint32_t psp_v3_1_ring_get_wptr(struct psp_context *psp) + struct amdgpu_device *adev = psp->adev; + + if (amdgpu_sriov_vf(adev)) +- data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102); ++ data = psp->km_ring.ring_wptr; + else + data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67); + return data; +@@ -394,6 +394,7 @@ static void psp_v3_1_ring_set_wptr(struct psp_context *psp, uint32_t value) + /* send interrupt to PSP for SRIOV ring write pointer update */ + WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_101, + GFX_CTRL_CMD_ID_CONSUME_CMD); ++ psp->km_ring.ring_wptr = value; + } else + WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67, value); + } +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index fbbb1bde6b063..df26c07cb9120 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -870,7 +870,8 @@ static int dm_dmub_hw_init(struct amdgpu_device *adev) + abm->dmcu_is_running = dmcu->funcs->is_dmcu_initialized(dmcu); + } + +- adev->dm.dc->ctx->dmub_srv = dc_dmub_srv_create(adev->dm.dc, dmub_srv); ++ if (!adev->dm.dc->ctx->dmub_srv) ++ adev->dm.dc->ctx->dmub_srv = dc_dmub_srv_create(adev->dm.dc, dmub_srv); + if (!adev->dm.dc->ctx->dmub_srv) { + DRM_ERROR("Couldn't allocate DC DMUB server!\n"); + return -ENOMEM; +@@ -1755,7 +1756,6 @@ static int dm_suspend(void *handle) + + amdgpu_dm_irq_suspend(adev); + +- + dc_set_power_state(dm->dc, DC_ACPI_CM_POWER_STATE_D3); + + return 0; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c +index 33488b3c5c3ce..1812ec7ee11bb 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c +@@ -3232,7 +3232,7 @@ static noinline bool dcn20_validate_bandwidth_fp(struct dc *dc, + voltage_supported = dcn20_validate_bandwidth_internal(dc, context, false); + dummy_pstate_supported = context->bw_ctx.bw.dcn.clk.p_state_change_support; + +- if (voltage_supported && dummy_pstate_supported) { ++ if (voltage_supported && (dummy_pstate_supported || !(context->stream_count))) { + context->bw_ctx.bw.dcn.clk.p_state_change_support = false; + goto restore_dml_state; + } +diff --git a/drivers/gpu/drm/tegra/sor.c b/drivers/gpu/drm/tegra/sor.c +index 7b88261f57bb6..32c83f2e386ca 100644 +--- a/drivers/gpu/drm/tegra/sor.c ++++ b/drivers/gpu/drm/tegra/sor.c +@@ -3125,21 +3125,21 @@ static int tegra_sor_init(struct host1x_client *client) + if (err < 0) { + dev_err(sor->dev, "failed to acquire SOR reset: %d\n", + err); +- return err; ++ goto rpm_put; + } + + err = reset_control_assert(sor->rst); + if (err < 0) { + dev_err(sor->dev, "failed to assert SOR reset: %d\n", + err); +- return err; ++ goto rpm_put; + } + } + + err = clk_prepare_enable(sor->clk); + if (err < 0) { + dev_err(sor->dev, "failed to enable clock: %d\n", err); +- return err; ++ goto rpm_put; + } + + usleep_range(1000, 3000); +@@ -3150,7 +3150,7 @@ static int tegra_sor_init(struct host1x_client *client) + dev_err(sor->dev, "failed to deassert SOR reset: %d\n", + err); + clk_disable_unprepare(sor->clk); +- return err; ++ goto rpm_put; + } + + reset_control_release(sor->rst); +@@ -3171,6 +3171,12 @@ static int tegra_sor_init(struct host1x_client *client) + } + + return 0; ++ ++rpm_put: ++ if (sor->rst) ++ pm_runtime_put(sor->dev); ++ ++ return err; + } + + static int tegra_sor_exit(struct host1x_client *client) +@@ -3916,17 +3922,10 @@ static int tegra_sor_probe(struct platform_device *pdev) + platform_set_drvdata(pdev, sor); + pm_runtime_enable(&pdev->dev); + +- INIT_LIST_HEAD(&sor->client.list); ++ host1x_client_init(&sor->client); + sor->client.ops = &sor_client_ops; + sor->client.dev = &pdev->dev; + +- err = host1x_client_register(&sor->client); +- if (err < 0) { +- dev_err(&pdev->dev, "failed to register host1x client: %d\n", +- err); +- goto rpm_disable; +- } +- + /* + * On Tegra210 and earlier, provide our own implementation for the + * pad output clock. +@@ -3938,13 +3937,13 @@ static int tegra_sor_probe(struct platform_device *pdev) + sor->index); + if (!name) { + err = -ENOMEM; +- goto unregister; ++ goto uninit; + } + + err = host1x_client_resume(&sor->client); + if (err < 0) { + dev_err(sor->dev, "failed to resume: %d\n", err); +- goto unregister; ++ goto uninit; + } + + sor->clk_pad = tegra_clk_sor_pad_register(sor, name); +@@ -3955,14 +3954,20 @@ static int tegra_sor_probe(struct platform_device *pdev) + err = PTR_ERR(sor->clk_pad); + dev_err(sor->dev, "failed to register SOR pad clock: %d\n", + err); +- goto unregister; ++ goto uninit; ++ } ++ ++ err = __host1x_client_register(&sor->client); ++ if (err < 0) { ++ dev_err(&pdev->dev, "failed to register host1x client: %d\n", ++ err); ++ goto uninit; + } + + return 0; + +-unregister: +- host1x_client_unregister(&sor->client); +-rpm_disable: ++uninit: ++ host1x_client_exit(&sor->client); + pm_runtime_disable(&pdev->dev); + remove: + tegra_output_remove(&sor->output); +diff --git a/drivers/gpu/host1x/bus.c b/drivers/gpu/host1x/bus.c +index 9e2cb6968819e..6e3b49d0de66d 100644 +--- a/drivers/gpu/host1x/bus.c ++++ b/drivers/gpu/host1x/bus.c +@@ -703,6 +703,29 @@ void host1x_driver_unregister(struct host1x_driver *driver) + } + EXPORT_SYMBOL(host1x_driver_unregister); + ++/** ++ * __host1x_client_init() - initialize a host1x client ++ * @client: host1x client ++ * @key: lock class key for the client-specific mutex ++ */ ++void __host1x_client_init(struct host1x_client *client, struct lock_class_key *key) ++{ ++ INIT_LIST_HEAD(&client->list); ++ __mutex_init(&client->lock, "host1x client lock", key); ++ client->usecount = 0; ++} ++EXPORT_SYMBOL(__host1x_client_init); ++ ++/** ++ * host1x_client_exit() - uninitialize a host1x client ++ * @client: host1x client ++ */ ++void host1x_client_exit(struct host1x_client *client) ++{ ++ mutex_destroy(&client->lock); ++} ++EXPORT_SYMBOL(host1x_client_exit); ++ + /** + * __host1x_client_register() - register a host1x client + * @client: host1x client +@@ -715,16 +738,11 @@ EXPORT_SYMBOL(host1x_driver_unregister); + * device and call host1x_device_init(), which will in turn call each client's + * &host1x_client_ops.init implementation. + */ +-int __host1x_client_register(struct host1x_client *client, +- struct lock_class_key *key) ++int __host1x_client_register(struct host1x_client *client) + { + struct host1x *host1x; + int err; + +- INIT_LIST_HEAD(&client->list); +- __mutex_init(&client->lock, "host1x client lock", key); +- client->usecount = 0; +- + mutex_lock(&devices_lock); + + list_for_each_entry(host1x, &devices, list) { +diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig +index 9b56226ce0d1c..54bc563a8dff1 100644 +--- a/drivers/hid/Kconfig ++++ b/drivers/hid/Kconfig +@@ -93,11 +93,11 @@ menu "Special HID drivers" + depends on HID + + config HID_A4TECH +- tristate "A4 tech mice" ++ tristate "A4TECH mice" + depends on HID + default !EXPERT + help +- Support for A4 tech X5 and WOP-35 / Trust 450L mice. ++ Support for some A4TECH mice with two scroll wheels. + + config HID_ACCUTOUCH + tristate "Accutouch touch device" +diff --git a/drivers/hid/hid-a4tech.c b/drivers/hid/hid-a4tech.c +index 3a8c4a5971f70..2cbc32dda7f74 100644 +--- a/drivers/hid/hid-a4tech.c ++++ b/drivers/hid/hid-a4tech.c +@@ -147,6 +147,8 @@ static const struct hid_device_id a4_devices[] = { + .driver_data = A4_2WHEEL_MOUSE_HACK_B8 }, + { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649), + .driver_data = A4_2WHEEL_MOUSE_HACK_B8 }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_NB_95), ++ .driver_data = A4_2WHEEL_MOUSE_HACK_B8 }, + { } + }; + MODULE_DEVICE_TABLE(hid, a4_devices); +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 097cb1ee31268..0f69f35f2957e 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -2005,6 +2005,9 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask) + case BUS_I2C: + bus = "I2C"; + break; ++ case BUS_VIRTUAL: ++ bus = "VIRTUAL"; ++ break; + default: + bus = "<UNKNOWN>"; + } +diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c +index d7eaf91003706..982737827b871 100644 +--- a/drivers/hid/hid-debug.c ++++ b/drivers/hid/hid-debug.c +@@ -929,6 +929,7 @@ static const char *keys[KEY_MAX + 1] = { + [KEY_APPSELECT] = "AppSelect", + [KEY_SCREENSAVER] = "ScreenSaver", + [KEY_VOICECOMMAND] = "VoiceCommand", ++ [KEY_EMOJI_PICKER] = "EmojiPicker", + [KEY_BRIGHTNESS_MIN] = "BrightnessMin", + [KEY_BRIGHTNESS_MAX] = "BrightnessMax", + [KEY_BRIGHTNESS_AUTO] = "BrightnessAuto", +diff --git a/drivers/hid/hid-gt683r.c b/drivers/hid/hid-gt683r.c +index 898871c8c768e..29ccb0accfba8 100644 +--- a/drivers/hid/hid-gt683r.c ++++ b/drivers/hid/hid-gt683r.c +@@ -54,6 +54,7 @@ static const struct hid_device_id gt683r_led_id[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) }, + { } + }; ++MODULE_DEVICE_TABLE(hid, gt683r_led_id); + + static void gt683r_brightness_set(struct led_classdev *led_cdev, + enum led_brightness brightness) +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index e220a05a05b48..136b58a91c04c 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -26,6 +26,7 @@ + #define USB_DEVICE_ID_A4TECH_WCP32PU 0x0006 + #define USB_DEVICE_ID_A4TECH_X5_005D 0x000a + #define USB_DEVICE_ID_A4TECH_RP_649 0x001a ++#define USB_DEVICE_ID_A4TECH_NB_95 0x022b + + #define USB_VENDOR_ID_AASHIMA 0x06d6 + #define USB_DEVICE_ID_AASHIMA_GAMEPAD 0x0025 +@@ -741,6 +742,7 @@ + #define USB_DEVICE_ID_LENOVO_X1_COVER 0x6085 + #define USB_DEVICE_ID_LENOVO_X1_TAB 0x60a3 + #define USB_DEVICE_ID_LENOVO_X1_TAB3 0x60b5 ++#define USB_DEVICE_ID_LENOVO_OPTICAL_USB_MOUSE_600E 0x600e + #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D 0x608d + #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_6019 0x6019 + #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_602E 0x602e +@@ -1034,6 +1036,7 @@ + #define USB_DEVICE_ID_SAITEK_X52 0x075c + #define USB_DEVICE_ID_SAITEK_X52_2 0x0255 + #define USB_DEVICE_ID_SAITEK_X52_PRO 0x0762 ++#define USB_DEVICE_ID_SAITEK_X65 0x0b6a + + #define USB_VENDOR_ID_SAMSUNG 0x0419 + #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001 +diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c +index 32024905fd70f..d1ab2dccf6fd7 100644 +--- a/drivers/hid/hid-input.c ++++ b/drivers/hid/hid-input.c +@@ -957,6 +957,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel + + case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break; + case 0x0cf: map_key_clear(KEY_VOICECOMMAND); break; ++ ++ case 0x0d9: map_key_clear(KEY_EMOJI_PICKER); break; ++ + case 0x0e0: map_abs_clear(ABS_VOLUME); break; + case 0x0e2: map_key_clear(KEY_MUTE); break; + case 0x0e5: map_key_clear(KEY_BASSBOOST); break; +diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c +index 8580ace596c25..e5a3704b9fe8f 100644 +--- a/drivers/hid/hid-multitouch.c ++++ b/drivers/hid/hid-multitouch.c +@@ -1580,13 +1580,13 @@ static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi) + /* we do not set suffix = "Touchscreen" */ + hi->input->name = hdev->name; + break; +- case HID_DG_STYLUS: +- /* force BTN_STYLUS to allow tablet matching in udev */ +- __set_bit(BTN_STYLUS, hi->input->keybit); +- break; + case HID_VD_ASUS_CUSTOM_MEDIA_KEYS: + suffix = "Custom Media Keys"; + break; ++ case HID_DG_STYLUS: ++ /* force BTN_STYLUS to allow tablet matching in udev */ ++ __set_bit(BTN_STYLUS, hi->input->keybit); ++ fallthrough; + case HID_DG_PEN: + suffix = "Stylus"; + break; +diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c +index 2e38340e19dfb..be53c723c729d 100644 +--- a/drivers/hid/hid-quirks.c ++++ b/drivers/hid/hid-quirks.c +@@ -110,6 +110,7 @@ static const struct hid_device_id hid_quirks[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_OPTICAL_USB_MOUSE_600E), HID_QUIRK_ALWAYS_POLL }, + { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D), HID_QUIRK_ALWAYS_POLL }, + { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_6019), HID_QUIRK_ALWAYS_POLL }, + { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_602E), HID_QUIRK_ALWAYS_POLL }, +@@ -158,6 +159,7 @@ static const struct hid_device_id hid_quirks[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE }, + { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_2), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE }, + { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_PRO), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X65), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE }, + { HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD2), HID_QUIRK_NO_INIT_REPORTS }, + { HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD), HID_QUIRK_NO_INIT_REPORTS }, + { HID_USB_DEVICE(USB_VENDOR_ID_SENNHEISER, USB_DEVICE_ID_SENNHEISER_BTD500USB), HID_QUIRK_NOGET }, +@@ -212,6 +214,7 @@ static const struct hid_device_id hid_have_special_driver[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) }, + { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) }, + { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_NB_95) }, + #endif + #if IS_ENABLED(CONFIG_HID_ACCUTOUCH) + { HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_ACCUTOUCH_2216) }, +diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c +index 3dd7d32467378..f9983145d4e70 100644 +--- a/drivers/hid/hid-sensor-hub.c ++++ b/drivers/hid/hid-sensor-hub.c +@@ -210,16 +210,21 @@ int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, + buffer_size = buffer_size / sizeof(__s32); + if (buffer_size) { + for (i = 0; i < buffer_size; ++i) { +- hid_set_field(report->field[field_index], i, +- (__force __s32)cpu_to_le32(*buf32)); ++ ret = hid_set_field(report->field[field_index], i, ++ (__force __s32)cpu_to_le32(*buf32)); ++ if (ret) ++ goto done_proc; ++ + ++buf32; + } + } + if (remaining_bytes) { + value = 0; + memcpy(&value, (u8 *)buf32, remaining_bytes); +- hid_set_field(report->field[field_index], i, +- (__force __s32)cpu_to_le32(value)); ++ ret = hid_set_field(report->field[field_index], i, ++ (__force __s32)cpu_to_le32(value)); ++ if (ret) ++ goto done_proc; + } + hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT); + hid_hw_wait(hsdev->hdev); +diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c +index 17a29ee0ac6c2..8d4ac4b9fb9da 100644 +--- a/drivers/hid/usbhid/hid-core.c ++++ b/drivers/hid/usbhid/hid-core.c +@@ -374,7 +374,7 @@ static int hid_submit_ctrl(struct hid_device *hid) + raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report; + dir = usbhid->ctrl[usbhid->ctrltail].dir; + +- len = ((report->size - 1) >> 3) + 1 + (report->id > 0); ++ len = hid_report_len(report); + if (dir == USB_DIR_OUT) { + usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0); + usbhid->urbctrl->transfer_buffer_length = len; +diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c +index c84c8bf2bc20e..fc99ad8e4a388 100644 +--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c ++++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c +@@ -3815,6 +3815,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + dev_err(&pdev->dev, + "invalid sram_size %dB or board span %ldB\n", + mgp->sram_size, mgp->board_span); ++ status = -EINVAL; + goto abort_with_ioremap; + } + memcpy_fromio(mgp->eeprom_strings, +diff --git a/drivers/nvme/target/loop.c b/drivers/nvme/target/loop.c +index b869b686e9623..16d71cc5a50eb 100644 +--- a/drivers/nvme/target/loop.c ++++ b/drivers/nvme/target/loop.c +@@ -251,7 +251,8 @@ static const struct blk_mq_ops nvme_loop_admin_mq_ops = { + + static void nvme_loop_destroy_admin_queue(struct nvme_loop_ctrl *ctrl) + { +- clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags); ++ if (!test_and_clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags)) ++ return; + nvmet_sq_destroy(&ctrl->queues[0].nvme_sq); + blk_cleanup_queue(ctrl->ctrl.admin_q); + blk_cleanup_queue(ctrl->ctrl.fabrics_q); +@@ -287,6 +288,7 @@ static void nvme_loop_destroy_io_queues(struct nvme_loop_ctrl *ctrl) + clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[i].flags); + nvmet_sq_destroy(&ctrl->queues[i].nvme_sq); + } ++ ctrl->ctrl.queue_count = 1; + } + + static int nvme_loop_init_io_queues(struct nvme_loop_ctrl *ctrl) +@@ -393,6 +395,7 @@ static int nvme_loop_configure_admin_queue(struct nvme_loop_ctrl *ctrl) + return 0; + + out_cleanup_queue: ++ clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags); + blk_cleanup_queue(ctrl->ctrl.admin_q); + out_cleanup_fabrics_q: + blk_cleanup_queue(ctrl->ctrl.fabrics_q); +@@ -450,8 +453,10 @@ static void nvme_loop_reset_ctrl_work(struct work_struct *work) + nvme_loop_shutdown_ctrl(ctrl); + + if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) { +- /* state change failure should never happen */ +- WARN_ON_ONCE(1); ++ if (ctrl->ctrl.state != NVME_CTRL_DELETING && ++ ctrl->ctrl.state != NVME_CTRL_DELETING_NOIO) ++ /* state change failure for non-deleted ctrl? */ ++ WARN_ON_ONCE(1); + return; + } + +diff --git a/drivers/scsi/qedf/qedf_main.c b/drivers/scsi/qedf/qedf_main.c +index a464d0a4f4653..846a02de4d510 100644 +--- a/drivers/scsi/qedf/qedf_main.c ++++ b/drivers/scsi/qedf/qedf_main.c +@@ -1827,22 +1827,20 @@ static int qedf_vport_create(struct fc_vport *vport, bool disabled) + fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf)); + QEDF_WARN(&(base_qedf->dbg_ctx), "Failed to create vport, " + "WWPN (0x%s) already exists.\n", buf); +- goto err1; ++ return rc; + } + + if (atomic_read(&base_qedf->link_state) != QEDF_LINK_UP) { + QEDF_WARN(&(base_qedf->dbg_ctx), "Cannot create vport " + "because link is not up.\n"); +- rc = -EIO; +- goto err1; ++ return -EIO; + } + + vn_port = libfc_vport_create(vport, sizeof(struct qedf_ctx)); + if (!vn_port) { + QEDF_WARN(&(base_qedf->dbg_ctx), "Could not create lport " + "for vport.\n"); +- rc = -ENOMEM; +- goto err1; ++ return -ENOMEM; + } + + fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf)); +@@ -1866,7 +1864,7 @@ static int qedf_vport_create(struct fc_vport *vport, bool disabled) + if (rc) { + QEDF_ERR(&(base_qedf->dbg_ctx), "Could not allocate memory " + "for lport stats.\n"); +- goto err2; ++ goto err; + } + + fc_set_wwnn(vn_port, vport->node_name); +@@ -1884,7 +1882,7 @@ static int qedf_vport_create(struct fc_vport *vport, bool disabled) + if (rc) { + QEDF_WARN(&base_qedf->dbg_ctx, + "Error adding Scsi_Host rc=0x%x.\n", rc); +- goto err2; ++ goto err; + } + + /* Set default dev_loss_tmo based on module parameter */ +@@ -1925,9 +1923,10 @@ static int qedf_vport_create(struct fc_vport *vport, bool disabled) + vport_qedf->dbg_ctx.host_no = vn_port->host->host_no; + vport_qedf->dbg_ctx.pdev = base_qedf->pdev; + +-err2: ++ return 0; ++ ++err: + scsi_host_put(vn_port->host); +-err1: + return rc; + } + +@@ -1968,8 +1967,7 @@ static int qedf_vport_destroy(struct fc_vport *vport) + fc_lport_free_stats(vn_port); + + /* Release Scsi_Host */ +- if (vn_port->host) +- scsi_host_put(vn_port->host); ++ scsi_host_put(vn_port->host); + + out: + return 0; +diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c +index ba84244c1b4f6..9a8f9f902f3b4 100644 +--- a/drivers/scsi/scsi_devinfo.c ++++ b/drivers/scsi/scsi_devinfo.c +@@ -184,6 +184,7 @@ static struct { + {"HP", "C3323-300", "4269", BLIST_NOTQ}, + {"HP", "C5713A", NULL, BLIST_NOREPORTLUN}, + {"HP", "DISK-SUBSYSTEM", "*", BLIST_REPORTLUN2}, ++ {"HPE", "OPEN-", "*", BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES}, + {"IBM", "AuSaV1S2", NULL, BLIST_FORCELUN}, + {"IBM", "ProFibre 4000R", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, + {"IBM", "2105", NULL, BLIST_RETRY_HWERROR}, +diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c +index 484f0ba0a65bb..61b79804d462c 100644 +--- a/drivers/target/target_core_transport.c ++++ b/drivers/target/target_core_transport.c +@@ -3038,9 +3038,7 @@ __transport_wait_for_tasks(struct se_cmd *cmd, bool fabric_stop, + __releases(&cmd->t_state_lock) + __acquires(&cmd->t_state_lock) + { +- +- assert_spin_locked(&cmd->t_state_lock); +- WARN_ON_ONCE(!irqs_disabled()); ++ lockdep_assert_held(&cmd->t_state_lock); + + if (fabric_stop) + cmd->transport_state |= CMD_T_FABRIC_STOP; +diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c +index b39b339feddc9..16fb0184ce5e1 100644 +--- a/fs/gfs2/file.c ++++ b/fs/gfs2/file.c +@@ -938,8 +938,11 @@ static ssize_t gfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *from) + current->backing_dev_info = inode_to_bdi(inode); + buffered = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops); + current->backing_dev_info = NULL; +- if (unlikely(buffered <= 0)) ++ if (unlikely(buffered <= 0)) { ++ if (!ret) ++ ret = buffered; + goto out_unlock; ++ } + + /* + * We need to ensure that the page cache pages are written to +diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c +index ea2f2de448063..cd43c481df4b4 100644 +--- a/fs/gfs2/glock.c ++++ b/fs/gfs2/glock.c +@@ -569,6 +569,16 @@ out_locked: + spin_unlock(&gl->gl_lockref.lock); + } + ++static bool is_system_glock(struct gfs2_glock *gl) ++{ ++ struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; ++ struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); ++ ++ if (gl == m_ip->i_gl) ++ return true; ++ return false; ++} ++ + /** + * do_xmote - Calls the DLM to change the state of a lock + * @gl: The lock state +@@ -658,17 +668,25 @@ skip_inval: + * to see sd_log_error and withdraw, and in the meantime, requeue the + * work for later. + * ++ * We make a special exception for some system glocks, such as the ++ * system statfs inode glock, which needs to be granted before the ++ * gfs2_quotad daemon can exit, and that exit needs to finish before ++ * we can unmount the withdrawn file system. ++ * + * However, if we're just unlocking the lock (say, for unmount, when + * gfs2_gl_hash_clear calls clear_glock) and recovery is complete + * then it's okay to tell dlm to unlock it. + */ + if (unlikely(sdp->sd_log_error && !gfs2_withdrawn(sdp))) + gfs2_withdraw_delayed(sdp); +- if (glock_blocked_by_withdraw(gl)) { +- if (target != LM_ST_UNLOCKED || +- test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags)) { ++ if (glock_blocked_by_withdraw(gl) && ++ (target != LM_ST_UNLOCKED || ++ test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags))) { ++ if (!is_system_glock(gl)) { + gfs2_glock_queue_work(gl, GL_GLOCK_DFT_HOLD); + goto out; ++ } else { ++ clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags); + } + } + +@@ -1766,6 +1784,7 @@ __acquires(&lru_lock) + while(!list_empty(list)) { + gl = list_first_entry(list, struct gfs2_glock, gl_lru); + list_del_init(&gl->gl_lru); ++ clear_bit(GLF_LRU, &gl->gl_flags); + if (!spin_trylock(&gl->gl_lockref.lock)) { + add_back_to_lru: + list_add(&gl->gl_lru, &lru_list); +@@ -1811,7 +1830,6 @@ static long gfs2_scan_glock_lru(int nr) + if (!test_bit(GLF_LOCK, &gl->gl_flags)) { + list_move(&gl->gl_lru, &dispose); + atomic_dec(&lru_count); +- clear_bit(GLF_LRU, &gl->gl_flags); + freed++; + continue; + } +diff --git a/include/linux/hid.h b/include/linux/hid.h +index 8578db50ad734..6ed2a97eb55f1 100644 +--- a/include/linux/hid.h ++++ b/include/linux/hid.h +@@ -1156,8 +1156,7 @@ static inline void hid_hw_wait(struct hid_device *hdev) + */ + static inline u32 hid_report_len(struct hid_report *report) + { +- /* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */ +- return ((report->size - 1) >> 3) + 1 + (report->id > 0); ++ return DIV_ROUND_UP(report->size, 8) + (report->id > 0); + } + + int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size, +diff --git a/include/linux/host1x.h b/include/linux/host1x.h +index 9eb77c87a83b0..ed0005ce4285c 100644 +--- a/include/linux/host1x.h ++++ b/include/linux/host1x.h +@@ -320,12 +320,30 @@ static inline struct host1x_device *to_host1x_device(struct device *dev) + int host1x_device_init(struct host1x_device *device); + int host1x_device_exit(struct host1x_device *device); + +-int __host1x_client_register(struct host1x_client *client, +- struct lock_class_key *key); +-#define host1x_client_register(class) \ +- ({ \ +- static struct lock_class_key __key; \ +- __host1x_client_register(class, &__key); \ ++void __host1x_client_init(struct host1x_client *client, struct lock_class_key *key); ++void host1x_client_exit(struct host1x_client *client); ++ ++#define host1x_client_init(client) \ ++ ({ \ ++ static struct lock_class_key __key; \ ++ __host1x_client_init(client, &__key); \ ++ }) ++ ++int __host1x_client_register(struct host1x_client *client); ++ ++/* ++ * Note that this wrapper calls __host1x_client_init() for compatibility ++ * with existing callers. Callers that want to separately initialize and ++ * register a host1x client must first initialize using either of the ++ * __host1x_client_init() or host1x_client_init() functions and then use ++ * the low-level __host1x_client_register() function to avoid the client ++ * getting reinitialized. ++ */ ++#define host1x_client_register(client) \ ++ ({ \ ++ static struct lock_class_key __key; \ ++ __host1x_client_init(client, &__key); \ ++ __host1x_client_register(client); \ + }) + + int host1x_client_unregister(struct host1x_client *client); +diff --git a/include/uapi/linux/input-event-codes.h b/include/uapi/linux/input-event-codes.h +index ee93428ced9a1..225ec87d4f228 100644 +--- a/include/uapi/linux/input-event-codes.h ++++ b/include/uapi/linux/input-event-codes.h +@@ -611,6 +611,7 @@ + #define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */ + #define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */ + #define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */ ++#define KEY_EMOJI_PICKER 0x249 /* Show/hide emoji picker (HUTRR101) */ + + #define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */ + #define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */ +diff --git a/net/compat.c b/net/compat.c +index ddd15af3a2837..210fc3b4d0d83 100644 +--- a/net/compat.c ++++ b/net/compat.c +@@ -177,7 +177,7 @@ int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg, struct sock *sk, + if (kcmlen > stackbuf_size) + kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL); + if (kcmsg == NULL) +- return -ENOBUFS; ++ return -ENOMEM; + + /* Now copy them over neatly. */ + memset(kcmsg, 0, kcmlen); +diff --git a/net/core/fib_rules.c b/net/core/fib_rules.c +index 7bcfb16854cbb..9258ffc4ebffc 100644 +--- a/net/core/fib_rules.c ++++ b/net/core/fib_rules.c +@@ -1168,7 +1168,7 @@ static void notify_rule_change(int event, struct fib_rule *rule, + { + struct net *net; + struct sk_buff *skb; +- int err = -ENOBUFS; ++ int err = -ENOMEM; + + net = ops->fro_net; + skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL); +diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c +index eae8e87930cd7..83894723ebeea 100644 +--- a/net/core/rtnetlink.c ++++ b/net/core/rtnetlink.c +@@ -4842,8 +4842,10 @@ static int rtnl_bridge_notify(struct net_device *dev) + if (err < 0) + goto errout; + +- if (!skb->len) ++ if (!skb->len) { ++ err = -EINVAL; + goto errout; ++ } + + rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); + return 0; +diff --git a/net/ieee802154/nl802154.c b/net/ieee802154/nl802154.c +index f0b47d43c9f6e..b34e4f827e756 100644 +--- a/net/ieee802154/nl802154.c ++++ b/net/ieee802154/nl802154.c +@@ -1298,19 +1298,20 @@ ieee802154_llsec_parse_dev_addr(struct nlattr *nla, + if (!nla || nla_parse_nested_deprecated(attrs, NL802154_DEV_ADDR_ATTR_MAX, nla, nl802154_dev_addr_policy, NULL)) + return -EINVAL; + +- if (!attrs[NL802154_DEV_ADDR_ATTR_PAN_ID] || +- !attrs[NL802154_DEV_ADDR_ATTR_MODE] || +- !(attrs[NL802154_DEV_ADDR_ATTR_SHORT] || +- attrs[NL802154_DEV_ADDR_ATTR_EXTENDED])) ++ if (!attrs[NL802154_DEV_ADDR_ATTR_PAN_ID] || !attrs[NL802154_DEV_ADDR_ATTR_MODE]) + return -EINVAL; + + addr->pan_id = nla_get_le16(attrs[NL802154_DEV_ADDR_ATTR_PAN_ID]); + addr->mode = nla_get_u32(attrs[NL802154_DEV_ADDR_ATTR_MODE]); + switch (addr->mode) { + case NL802154_DEV_ADDR_SHORT: ++ if (!attrs[NL802154_DEV_ADDR_ATTR_SHORT]) ++ return -EINVAL; + addr->short_addr = nla_get_le16(attrs[NL802154_DEV_ADDR_ATTR_SHORT]); + break; + case NL802154_DEV_ADDR_EXTENDED: ++ if (!attrs[NL802154_DEV_ADDR_ATTR_EXTENDED]) ++ return -EINVAL; + addr->extended_addr = nla_get_le64(attrs[NL802154_DEV_ADDR_ATTR_EXTENDED]); + break; + default: +diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c +index 3cd13e1bc6a70..213a1c91507d9 100644 +--- a/net/ipv4/ipconfig.c ++++ b/net/ipv4/ipconfig.c +@@ -870,7 +870,7 @@ static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_d + + + /* +- * Copy BOOTP-supplied string if not already set. ++ * Copy BOOTP-supplied string + */ + static int __init ic_bootp_string(char *dest, char *src, int len, int max) + { +@@ -919,12 +919,15 @@ static void __init ic_do_bootp_ext(u8 *ext) + } + break; + case 12: /* Host name */ +- ic_bootp_string(utsname()->nodename, ext+1, *ext, +- __NEW_UTS_LEN); +- ic_host_name_set = 1; ++ if (!ic_host_name_set) { ++ ic_bootp_string(utsname()->nodename, ext+1, *ext, ++ __NEW_UTS_LEN); ++ ic_host_name_set = 1; ++ } + break; + case 15: /* Domain name (DNS) */ +- ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain)); ++ if (!ic_domain[0]) ++ ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain)); + break; + case 17: /* Root path */ + if (!root_server_path[0]) +diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c +index e65a50192432c..03ed170b8125e 100644 +--- a/net/x25/af_x25.c ++++ b/net/x25/af_x25.c +@@ -546,7 +546,7 @@ static int x25_create(struct net *net, struct socket *sock, int protocol, + if (protocol) + goto out; + +- rc = -ENOBUFS; ++ rc = -ENOMEM; + if ((sk = x25_alloc_socket(net, kern)) == NULL) + goto out; +
