commit: fd5746a92ae302dc305683a6ef9fd4802b08a829 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Thu Apr 2 15:24:34 2020 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Thu Apr 2 15:24:34 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=fd5746a9
Linux patch 4.19.114 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1113_linux-4.19.114.patch | 3587 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 3591 insertions(+) diff --git a/0000_README b/0000_README index a53677c..99fb8b5 100644 --- a/0000_README +++ b/0000_README @@ -491,6 +491,10 @@ Patch: 1112_linux-4.19.113.patch From: https://www.kernel.org Desc: Linux 4.19.113 +Patch: 1113_linux-4.19.114.patch +From: https://www.kernel.org +Desc: Linux 4.19.114 + 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/1113_linux-4.19.114.patch b/1113_linux-4.19.114.patch new file mode 100644 index 0000000..7ea62ad --- /dev/null +++ b/1113_linux-4.19.114.patch @@ -0,0 +1,3587 @@ +diff --git a/Documentation/devicetree/bindings/net/fsl-fman.txt b/Documentation/devicetree/bindings/net/fsl-fman.txt +index 299c0dcd67db..1316f0aec0cf 100644 +--- a/Documentation/devicetree/bindings/net/fsl-fman.txt ++++ b/Documentation/devicetree/bindings/net/fsl-fman.txt +@@ -110,6 +110,13 @@ PROPERTIES + Usage: required + Definition: See soc/fsl/qman.txt and soc/fsl/bman.txt + ++- fsl,erratum-a050385 ++ Usage: optional ++ Value type: boolean ++ Definition: A boolean property. Indicates the presence of the ++ erratum A050385 which indicates that DMA transactions that are ++ split can result in a FMan lock. ++ + ============================================================================= + FMan MURAM Node + +diff --git a/Makefile b/Makefile +index 61bfe5519a16..6f849dafbfec 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 113 ++SUBLEVEL = 114 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/arm/boot/dts/bcm2835-rpi-zero-w.dts b/arch/arm/boot/dts/bcm2835-rpi-zero-w.dts +index b7f79f1c431a..5fcadb9cf992 100644 +--- a/arch/arm/boot/dts/bcm2835-rpi-zero-w.dts ++++ b/arch/arm/boot/dts/bcm2835-rpi-zero-w.dts +@@ -118,6 +118,7 @@ + &sdhci { + #address-cells = <1>; + #size-cells = <0>; ++ pinctrl-names = "default"; + pinctrl-0 = <&emmc_gpio34 &gpclk2_gpio43>; + mmc-pwrseq = <&wifi_pwrseq>; + non-removable; +diff --git a/arch/arm/boot/dts/dra7.dtsi b/arch/arm/boot/dts/dra7.dtsi +index c1ef3201950a..e97ef16ce68a 100644 +--- a/arch/arm/boot/dts/dra7.dtsi ++++ b/arch/arm/boot/dts/dra7.dtsi +@@ -150,6 +150,7 @@ + #address-cells = <1>; + #size-cells = <1>; + ranges = <0x0 0x0 0x0 0xc0000000>; ++ dma-ranges = <0x80000000 0x0 0x80000000 0x80000000>; + ti,hwmods = "l3_main_1", "l3_main_2"; + reg = <0x0 0x44000000 0x0 0x1000000>, + <0x0 0x45000000 0x0 0x1000>; +diff --git a/arch/arm/boot/dts/imx6qdl-phytec-phycore-som.dtsi b/arch/arm/boot/dts/imx6qdl-phytec-phycore-som.dtsi +index 881cea0b61ba..31fa37d2fe47 100644 +--- a/arch/arm/boot/dts/imx6qdl-phytec-phycore-som.dtsi ++++ b/arch/arm/boot/dts/imx6qdl-phytec-phycore-som.dtsi +@@ -107,14 +107,14 @@ + regulators { + vdd_arm: buck1 { + regulator-name = "vdd_arm"; +- regulator-min-microvolt = <730000>; ++ regulator-min-microvolt = <925000>; + regulator-max-microvolt = <1380000>; + regulator-always-on; + }; + + vdd_soc: buck2 { + regulator-name = "vdd_soc"; +- regulator-min-microvolt = <730000>; ++ regulator-min-microvolt = <1150000>; + regulator-max-microvolt = <1380000>; + regulator-always-on; + }; +diff --git a/arch/arm/boot/dts/omap3-n900.dts b/arch/arm/boot/dts/omap3-n900.dts +index 37785e7d1238..00b2eb8c3195 100644 +--- a/arch/arm/boot/dts/omap3-n900.dts ++++ b/arch/arm/boot/dts/omap3-n900.dts +@@ -852,34 +852,46 @@ + compatible = "ti,omap2-onenand"; + reg = <0 0 0x20000>; /* CS0, offset 0, IO size 128K */ + ++ /* ++ * These timings are based on CONFIG_OMAP_GPMC_DEBUG=y reported ++ * bootloader set values when booted with v5.1 ++ * (OneNAND Manufacturer: Samsung): ++ * ++ * cs0 GPMC_CS_CONFIG1: 0xfb001202 ++ * cs0 GPMC_CS_CONFIG2: 0x00111100 ++ * cs0 GPMC_CS_CONFIG3: 0x00020200 ++ * cs0 GPMC_CS_CONFIG4: 0x11001102 ++ * cs0 GPMC_CS_CONFIG5: 0x03101616 ++ * cs0 GPMC_CS_CONFIG6: 0x90060000 ++ */ + gpmc,sync-read; + gpmc,sync-write; + gpmc,burst-length = <16>; + gpmc,burst-read; + gpmc,burst-wrap; + gpmc,burst-write; +- gpmc,device-width = <2>; /* GPMC_DEVWIDTH_16BIT */ +- gpmc,mux-add-data = <2>; /* GPMC_MUX_AD */ ++ gpmc,device-width = <2>; ++ gpmc,mux-add-data = <2>; + gpmc,cs-on-ns = <0>; +- gpmc,cs-rd-off-ns = <87>; +- gpmc,cs-wr-off-ns = <87>; ++ gpmc,cs-rd-off-ns = <102>; ++ gpmc,cs-wr-off-ns = <102>; + gpmc,adv-on-ns = <0>; +- gpmc,adv-rd-off-ns = <10>; +- gpmc,adv-wr-off-ns = <10>; +- gpmc,oe-on-ns = <15>; +- gpmc,oe-off-ns = <87>; ++ gpmc,adv-rd-off-ns = <12>; ++ gpmc,adv-wr-off-ns = <12>; ++ gpmc,oe-on-ns = <12>; ++ gpmc,oe-off-ns = <102>; + gpmc,we-on-ns = <0>; +- gpmc,we-off-ns = <87>; +- gpmc,rd-cycle-ns = <112>; +- gpmc,wr-cycle-ns = <112>; +- gpmc,access-ns = <81>; +- gpmc,page-burst-access-ns = <15>; ++ gpmc,we-off-ns = <102>; ++ gpmc,rd-cycle-ns = <132>; ++ gpmc,wr-cycle-ns = <132>; ++ gpmc,access-ns = <96>; ++ gpmc,page-burst-access-ns = <18>; + gpmc,bus-turnaround-ns = <0>; + gpmc,cycle2cycle-delay-ns = <0>; + gpmc,wait-monitoring-ns = <0>; +- gpmc,clk-activation-ns = <5>; +- gpmc,wr-data-mux-bus-ns = <30>; +- gpmc,wr-access-ns = <81>; ++ gpmc,clk-activation-ns = <6>; ++ gpmc,wr-data-mux-bus-ns = <36>; ++ gpmc,wr-access-ns = <96>; + gpmc,sync-clk-ps = <15000>; + + /* +diff --git a/arch/arm/boot/dts/omap5.dtsi b/arch/arm/boot/dts/omap5.dtsi +index 574ac11c0489..3c0bafe0fb05 100644 +--- a/arch/arm/boot/dts/omap5.dtsi ++++ b/arch/arm/boot/dts/omap5.dtsi +@@ -144,6 +144,7 @@ + #address-cells = <1>; + #size-cells = <1>; + ranges = <0 0 0 0xc0000000>; ++ dma-ranges = <0x80000000 0x0 0x80000000 0x80000000>; + ti,hwmods = "l3_main_1", "l3_main_2", "l3_main_3"; + reg = <0 0x44000000 0 0x2000>, + <0 0x44800000 0 0x3000>, +diff --git a/arch/arm/boot/dts/ox810se.dtsi b/arch/arm/boot/dts/ox810se.dtsi +index c2b48a1838eb..6ebad0e80b9c 100644 +--- a/arch/arm/boot/dts/ox810se.dtsi ++++ b/arch/arm/boot/dts/ox810se.dtsi +@@ -322,8 +322,8 @@ + interrupt-controller; + reg = <0 0x200>; + #interrupt-cells = <1>; +- valid-mask = <0xFFFFFFFF>; +- clear-mask = <0>; ++ valid-mask = <0xffffffff>; ++ clear-mask = <0xffffffff>; + }; + + timer0: timer@200 { +diff --git a/arch/arm/boot/dts/ox820.dtsi b/arch/arm/boot/dts/ox820.dtsi +index 085bbd33eadc..f7dddfb01f81 100644 +--- a/arch/arm/boot/dts/ox820.dtsi ++++ b/arch/arm/boot/dts/ox820.dtsi +@@ -239,8 +239,8 @@ + reg = <0 0x200>; + interrupts = <GIC_SPI 5 IRQ_TYPE_LEVEL_HIGH>; + #interrupt-cells = <1>; +- valid-mask = <0xFFFFFFFF>; +- clear-mask = <0>; ++ valid-mask = <0xffffffff>; ++ clear-mask = <0xffffffff>; + }; + + timer0: timer@200 { +diff --git a/arch/arm64/boot/dts/freescale/fsl-ls1043-post.dtsi b/arch/arm64/boot/dts/freescale/fsl-ls1043-post.dtsi +index 6082ae022136..d237162a8744 100644 +--- a/arch/arm64/boot/dts/freescale/fsl-ls1043-post.dtsi ++++ b/arch/arm64/boot/dts/freescale/fsl-ls1043-post.dtsi +@@ -20,6 +20,8 @@ + }; + + &fman0 { ++ fsl,erratum-a050385; ++ + /* these aliases provide the FMan ports mapping */ + enet0: ethernet@e0000 { + }; +diff --git a/arch/arm64/boot/dts/freescale/fsl-ls1043a-rdb.dts b/arch/arm64/boot/dts/freescale/fsl-ls1043a-rdb.dts +index 7b01ba8d3b7e..2dcec0a75550 100644 +--- a/arch/arm64/boot/dts/freescale/fsl-ls1043a-rdb.dts ++++ b/arch/arm64/boot/dts/freescale/fsl-ls1043a-rdb.dts +@@ -118,12 +118,12 @@ + + ethernet@e4000 { + phy-handle = <&rgmii_phy1>; +- phy-connection-type = "rgmii-txid"; ++ phy-connection-type = "rgmii-id"; + }; + + ethernet@e6000 { + phy-handle = <&rgmii_phy2>; +- phy-connection-type = "rgmii-txid"; ++ phy-connection-type = "rgmii-id"; + }; + + ethernet@e8000 { +diff --git a/arch/arm64/boot/dts/freescale/fsl-ls1046a-rdb.dts b/arch/arm64/boot/dts/freescale/fsl-ls1046a-rdb.dts +index a59b48203688..d4f37b9aef8e 100644 +--- a/arch/arm64/boot/dts/freescale/fsl-ls1046a-rdb.dts ++++ b/arch/arm64/boot/dts/freescale/fsl-ls1046a-rdb.dts +@@ -125,12 +125,12 @@ + &fman0 { + ethernet@e4000 { + phy-handle = <&rgmii_phy1>; +- phy-connection-type = "rgmii"; ++ phy-connection-type = "rgmii-id"; + }; + + ethernet@e6000 { + phy-handle = <&rgmii_phy2>; +- phy-connection-type = "rgmii"; ++ phy-connection-type = "rgmii-id"; + }; + + ethernet@e8000 { +diff --git a/arch/arm64/include/asm/alternative.h b/arch/arm64/include/asm/alternative.h +index 887a8512bf10..1a7ba3de7079 100644 +--- a/arch/arm64/include/asm/alternative.h ++++ b/arch/arm64/include/asm/alternative.h +@@ -221,7 +221,7 @@ alternative_endif + + .macro user_alt, label, oldinstr, newinstr, cond + 9999: alternative_insn "\oldinstr", "\newinstr", \cond +- _ASM_EXTABLE 9999b, \label ++ _asm_extable 9999b, \label + .endm + + /* +diff --git a/arch/x86/kernel/ftrace.c b/arch/x86/kernel/ftrace.c +index 5790671857e5..32b63b30ec40 100644 +--- a/arch/x86/kernel/ftrace.c ++++ b/arch/x86/kernel/ftrace.c +@@ -35,6 +35,7 @@ + #ifdef CONFIG_DYNAMIC_FTRACE + + int ftrace_arch_code_modify_prepare(void) ++ __acquires(&text_mutex) + { + mutex_lock(&text_mutex); + set_kernel_text_rw(); +@@ -43,6 +44,7 @@ int ftrace_arch_code_modify_prepare(void) + } + + int ftrace_arch_code_modify_post_process(void) ++ __releases(&text_mutex) + { + set_all_modules_text_ro(); + set_kernel_text_ro(); +diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c +index bbc8710704e2..8df0ec85cc7b 100644 +--- a/drivers/ata/ahci.c ++++ b/drivers/ata/ahci.c +@@ -409,6 +409,7 @@ static const struct pci_device_id ahci_pci_tbl[] = { + { PCI_VDEVICE(INTEL, 0xa252), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa256), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa356), board_ahci }, /* Cannon Lake PCH-H RAID */ ++ { PCI_VDEVICE(INTEL, 0x06d7), board_ahci }, /* Comet Lake-H RAID */ + { PCI_VDEVICE(INTEL, 0x0f22), board_ahci_mobile }, /* Bay Trail AHCI */ + { PCI_VDEVICE(INTEL, 0x0f23), board_ahci_mobile }, /* Bay Trail AHCI */ + { PCI_VDEVICE(INTEL, 0x22a3), board_ahci_mobile }, /* Cherry Tr. AHCI */ +diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c +index d872dc82725e..18f5973b9697 100644 +--- a/drivers/gpio/gpiolib-acpi.c ++++ b/drivers/gpio/gpiolib-acpi.c +@@ -24,18 +24,21 @@ + + #include "gpiolib.h" + +-#define QUIRK_NO_EDGE_EVENTS_ON_BOOT 0x01l +-#define QUIRK_NO_WAKEUP 0x02l +- + static int run_edge_events_on_boot = -1; + module_param(run_edge_events_on_boot, int, 0444); + MODULE_PARM_DESC(run_edge_events_on_boot, + "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto"); + +-static int honor_wakeup = -1; +-module_param(honor_wakeup, int, 0444); +-MODULE_PARM_DESC(honor_wakeup, +- "Honor the ACPI wake-capable flag: 0=no, 1=yes, -1=auto"); ++static char *ignore_wake; ++module_param(ignore_wake, charp, 0444); ++MODULE_PARM_DESC(ignore_wake, ++ "controller@pin combos on which to ignore the ACPI wake flag " ++ "ignore_wake=controller@pin[,controller@pin[,...]]"); ++ ++struct acpi_gpiolib_dmi_quirk { ++ bool no_edge_events_on_boot; ++ char *ignore_wake; ++}; + + /** + * struct acpi_gpio_event - ACPI GPIO event handler data +@@ -205,6 +208,57 @@ static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio) + acpi_gpiochip_request_irq(acpi_gpio, event); + } + ++static bool acpi_gpio_in_ignore_list(const char *controller_in, int pin_in) ++{ ++ const char *controller, *pin_str; ++ int len, pin; ++ char *endp; ++ ++ controller = ignore_wake; ++ while (controller) { ++ pin_str = strchr(controller, '@'); ++ if (!pin_str) ++ goto err; ++ ++ len = pin_str - controller; ++ if (len == strlen(controller_in) && ++ strncmp(controller, controller_in, len) == 0) { ++ pin = simple_strtoul(pin_str + 1, &endp, 10); ++ if (*endp != 0 && *endp != ',') ++ goto err; ++ ++ if (pin == pin_in) ++ return true; ++ } ++ ++ controller = strchr(controller, ','); ++ if (controller) ++ controller++; ++ } ++ ++ return false; ++err: ++ pr_err_once("Error invalid value for gpiolib_acpi.ignore_wake: %s\n", ++ ignore_wake); ++ return false; ++} ++ ++static bool acpi_gpio_irq_is_wake(struct device *parent, ++ struct acpi_resource_gpio *agpio) ++{ ++ int pin = agpio->pin_table[0]; ++ ++ if (agpio->wake_capable != ACPI_WAKE_CAPABLE) ++ return false; ++ ++ if (acpi_gpio_in_ignore_list(dev_name(parent), pin)) { ++ dev_info(parent, "Ignoring wakeup on pin %d\n", pin); ++ return false; ++ } ++ ++ return true; ++} ++ + static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, + void *context) + { +@@ -286,7 +340,7 @@ static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, + event->handle = evt_handle; + event->handler = handler; + event->irq = irq; +- event->irq_is_wake = honor_wakeup && agpio->wake_capable == ACPI_WAKE_CAPABLE; ++ event->irq_is_wake = acpi_gpio_irq_is_wake(chip->parent, agpio); + event->pin = pin; + event->desc = desc; + +@@ -1282,7 +1336,9 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { + DMI_MATCH(DMI_SYS_VENDOR, "MINIX"), + DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"), + }, +- .driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT, ++ .driver_data = &(struct acpi_gpiolib_dmi_quirk) { ++ .no_edge_events_on_boot = true, ++ }, + }, + { + /* +@@ -1295,16 +1351,20 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { + DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"), + DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"), + }, +- .driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT, ++ .driver_data = &(struct acpi_gpiolib_dmi_quirk) { ++ .no_edge_events_on_boot = true, ++ }, + }, + { + /* +- * Various HP X2 10 Cherry Trail models use an external +- * embedded-controller connected via I2C + an ACPI GPIO +- * event handler. The embedded controller generates various +- * spurious wakeup events when suspended. So disable wakeup +- * for its handler (it uses the only ACPI GPIO event handler). +- * This breaks wakeup when opening the lid, the user needs ++ * HP X2 10 models with Cherry Trail SoC + TI PMIC use an ++ * external embedded-controller connected via I2C + an ACPI GPIO ++ * event handler on INT33FF:01 pin 0, causing spurious wakeups. ++ * When suspending by closing the LID, the power to the USB ++ * keyboard is turned off, causing INT0002 ACPI events to ++ * trigger once the XHCI controller notices the keyboard is ++ * gone. So INT0002 events cause spurious wakeups too. Ignoring ++ * EC wakes breaks wakeup when opening the lid, the user needs + * to press the power-button to wakeup the system. The + * alternative is suspend simply not working, which is worse. + */ +@@ -1312,33 +1372,61 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { + DMI_MATCH(DMI_SYS_VENDOR, "HP"), + DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"), + }, +- .driver_data = (void *)QUIRK_NO_WAKEUP, ++ .driver_data = &(struct acpi_gpiolib_dmi_quirk) { ++ .ignore_wake = "INT33FF:01@0,INT0002:00@2", ++ }, ++ }, ++ { ++ /* ++ * HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an ++ * external embedded-controller connected via I2C + an ACPI GPIO ++ * event handler on INT33FC:02 pin 28, causing spurious wakeups. ++ */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), ++ DMI_MATCH(DMI_BOARD_NAME, "815D"), ++ }, ++ .driver_data = &(struct acpi_gpiolib_dmi_quirk) { ++ .ignore_wake = "INT33FC:02@28", ++ }, ++ }, ++ { ++ /* ++ * HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an ++ * external embedded-controller connected via I2C + an ACPI GPIO ++ * event handler on INT33FF:01 pin 0, causing spurious wakeups. ++ */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "HP"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), ++ DMI_MATCH(DMI_BOARD_NAME, "813E"), ++ }, ++ .driver_data = &(struct acpi_gpiolib_dmi_quirk) { ++ .ignore_wake = "INT33FF:01@0", ++ }, + }, + {} /* Terminating entry */ + }; + + static int acpi_gpio_setup_params(void) + { ++ const struct acpi_gpiolib_dmi_quirk *quirk = NULL; + const struct dmi_system_id *id; +- long quirks = 0; + + id = dmi_first_match(gpiolib_acpi_quirks); + if (id) +- quirks = (long)id->driver_data; ++ quirk = id->driver_data; + + if (run_edge_events_on_boot < 0) { +- if (quirks & QUIRK_NO_EDGE_EVENTS_ON_BOOT) ++ if (quirk && quirk->no_edge_events_on_boot) + run_edge_events_on_boot = 0; + else + run_edge_events_on_boot = 1; + } + +- if (honor_wakeup < 0) { +- if (quirks & QUIRK_NO_WAKEUP) +- honor_wakeup = 0; +- else +- honor_wakeup = 1; +- } ++ if (ignore_wake == NULL && quirk && quirk->ignore_wake) ++ ignore_wake = quirk->ignore_wake; + + return 0; + } +diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c +index bf4eed5f6a7e..fc978603fc94 100644 +--- a/drivers/gpu/drm/drm_dp_mst_topology.c ++++ b/drivers/gpu/drm/drm_dp_mst_topology.c +@@ -1022,20 +1022,9 @@ static struct drm_dp_mst_port *drm_dp_mst_get_port_ref_locked(struct drm_dp_mst_ + static struct drm_dp_mst_port *drm_dp_get_validated_port_ref(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port) + { + struct drm_dp_mst_port *rport = NULL; +- + mutex_lock(&mgr->lock); +- /* +- * Port may or may not be 'valid' but we don't care about that when +- * destroying the port and we are guaranteed that the port pointer +- * will be valid until we've finished +- */ +- if (current_work() == &mgr->destroy_connector_work) { +- kref_get(&port->kref); +- rport = port; +- } else if (mgr->mst_primary) { +- rport = drm_dp_mst_get_port_ref_locked(mgr->mst_primary, +- port); +- } ++ if (mgr->mst_primary) ++ rport = drm_dp_mst_get_port_ref_locked(mgr->mst_primary, port); + mutex_unlock(&mgr->lock); + return rport; + } +diff --git a/drivers/i2c/busses/i2c-hix5hd2.c b/drivers/i2c/busses/i2c-hix5hd2.c +index 061a4bfb03f4..b5ad7696adf9 100644 +--- a/drivers/i2c/busses/i2c-hix5hd2.c ++++ b/drivers/i2c/busses/i2c-hix5hd2.c +@@ -482,6 +482,7 @@ static int hix5hd2_i2c_remove(struct platform_device *pdev) + i2c_del_adapter(&priv->adap); + pm_runtime_disable(priv->dev); + pm_runtime_set_suspended(priv->dev); ++ clk_disable_unprepare(priv->clk); + + return 0; + } +diff --git a/drivers/infiniband/core/security.c b/drivers/infiniband/core/security.c +index f2c2e725375e..6df6cc55fd16 100644 +--- a/drivers/infiniband/core/security.c ++++ b/drivers/infiniband/core/security.c +@@ -346,16 +346,11 @@ static struct ib_ports_pkeys *get_new_pps(const struct ib_qp *qp, + else if (qp_pps) + new_pps->main.pkey_index = qp_pps->main.pkey_index; + +- if ((qp_attr_mask & IB_QP_PKEY_INDEX) && (qp_attr_mask & IB_QP_PORT)) ++ if (((qp_attr_mask & IB_QP_PKEY_INDEX) && ++ (qp_attr_mask & IB_QP_PORT)) || ++ (qp_pps && qp_pps->main.state != IB_PORT_PKEY_NOT_VALID)) + new_pps->main.state = IB_PORT_PKEY_VALID; + +- if (!(qp_attr_mask & (IB_QP_PKEY_INDEX | IB_QP_PORT)) && qp_pps) { +- new_pps->main.port_num = qp_pps->main.port_num; +- new_pps->main.pkey_index = qp_pps->main.pkey_index; +- if (qp_pps->main.state != IB_PORT_PKEY_NOT_VALID) +- new_pps->main.state = IB_PORT_PKEY_VALID; +- } +- + if (qp_attr_mask & IB_QP_ALT_PATH) { + new_pps->alt.port_num = qp_attr->alt_port_num; + new_pps->alt.pkey_index = qp_attr->alt_pkey_index; +diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c +index 4c0f0ce02d2f..4fc9278d0dde 100644 +--- a/drivers/infiniband/hw/mlx5/qp.c ++++ b/drivers/infiniband/hw/mlx5/qp.c +@@ -5524,6 +5524,10 @@ struct ib_wq *mlx5_ib_create_wq(struct ib_pd *pd, + if (udata->outlen && udata->outlen < min_resp_len) + return ERR_PTR(-EINVAL); + ++ if (!capable(CAP_SYS_RAWIO) && ++ init_attr->create_flags & IB_WQ_FLAGS_DELAY_DROP) ++ return ERR_PTR(-EPERM); ++ + dev = to_mdev(pd->device); + switch (init_attr->wq_type) { + case IB_WQT_RQ: +diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c +index f47e3fca403d..d9042d0566ab 100644 +--- a/drivers/input/mouse/synaptics.c ++++ b/drivers/input/mouse/synaptics.c +@@ -189,6 +189,7 @@ static const char * const smbus_pnp_ids[] = { + "SYN3052", /* HP EliteBook 840 G4 */ + "SYN3221", /* HP 15-ay000 */ + "SYN323d", /* HP Spectre X360 13-w013dx */ ++ "SYN3257", /* HP Envy 13-ad105ng */ + NULL + }; + +diff --git a/drivers/input/touchscreen/raydium_i2c_ts.c b/drivers/input/touchscreen/raydium_i2c_ts.c +index c89853a36f9e..05c1054330b7 100644 +--- a/drivers/input/touchscreen/raydium_i2c_ts.c ++++ b/drivers/input/touchscreen/raydium_i2c_ts.c +@@ -441,7 +441,7 @@ static int raydium_i2c_write_object(struct i2c_client *client, + return 0; + } + +-static bool raydium_i2c_boot_trigger(struct i2c_client *client) ++static int raydium_i2c_boot_trigger(struct i2c_client *client) + { + static const u8 cmd[7][6] = { + { 0x08, 0x0C, 0x09, 0x00, 0x50, 0xD7 }, +@@ -466,10 +466,10 @@ static bool raydium_i2c_boot_trigger(struct i2c_client *client) + } + } + +- return false; ++ return 0; + } + +-static bool raydium_i2c_fw_trigger(struct i2c_client *client) ++static int raydium_i2c_fw_trigger(struct i2c_client *client) + { + static const u8 cmd[5][11] = { + { 0, 0x09, 0x71, 0x0C, 0x09, 0x00, 0x50, 0xD7, 0, 0, 0 }, +@@ -492,7 +492,7 @@ static bool raydium_i2c_fw_trigger(struct i2c_client *client) + } + } + +- return false; ++ return 0; + } + + static int raydium_i2c_check_path(struct i2c_client *client) +diff --git a/drivers/media/usb/b2c2/flexcop-usb.c b/drivers/media/usb/b2c2/flexcop-usb.c +index 427cda457af6..5104678f29b7 100644 +--- a/drivers/media/usb/b2c2/flexcop-usb.c ++++ b/drivers/media/usb/b2c2/flexcop-usb.c +@@ -510,6 +510,9 @@ static int flexcop_usb_init(struct flexcop_usb *fc_usb) + return ret; + } + ++ if (fc_usb->uintf->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + switch (fc_usb->udev->speed) { + case USB_SPEED_LOW: + err("cannot handle USB speed because it is too slow."); +@@ -543,9 +546,6 @@ static int flexcop_usb_probe(struct usb_interface *intf, + struct flexcop_device *fc = NULL; + int ret; + +- if (intf->cur_altsetting->desc.bNumEndpoints < 1) +- return -ENODEV; +- + if ((fc = flexcop_device_kmalloc(sizeof(struct flexcop_usb))) == NULL) { + err("out of memory\n"); + return -ENOMEM; +diff --git a/drivers/media/usb/dvb-usb/dib0700_core.c b/drivers/media/usb/dvb-usb/dib0700_core.c +index 94bd176104c1..6a53ff93c4d8 100644 +--- a/drivers/media/usb/dvb-usb/dib0700_core.c ++++ b/drivers/media/usb/dvb-usb/dib0700_core.c +@@ -821,7 +821,7 @@ int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf) + + /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */ + +- if (intf->altsetting[0].desc.bNumEndpoints < rc_ep + 1) ++ if (intf->cur_altsetting->desc.bNumEndpoints < rc_ep + 1) + return -ENODEV; + + purb = usb_alloc_urb(0, GFP_KERNEL); +@@ -841,7 +841,7 @@ int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf) + * Some devices like the Hauppauge NovaTD model 52009 use an interrupt + * endpoint, while others use a bulk one. + */ +- e = &intf->altsetting[0].endpoint[rc_ep].desc; ++ e = &intf->cur_altsetting->endpoint[rc_ep].desc; + if (usb_endpoint_dir_in(e)) { + if (usb_endpoint_xfer_bulk(e)) { + pipe = usb_rcvbulkpipe(d->udev, rc_ep); +diff --git a/drivers/media/usb/gspca/ov519.c b/drivers/media/usb/gspca/ov519.c +index cb41e61d50dd..1e9835dc24d4 100644 +--- a/drivers/media/usb/gspca/ov519.c ++++ b/drivers/media/usb/gspca/ov519.c +@@ -3487,6 +3487,11 @@ static void ov511_mode_init_regs(struct sd *sd) + return; + } + ++ if (alt->desc.bNumEndpoints < 1) { ++ sd->gspca_dev.usb_err = -ENODEV; ++ return; ++ } ++ + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + reg_w(sd, R51x_FIFO_PSIZE, packet_size >> 5); + +@@ -3613,6 +3618,11 @@ static void ov518_mode_init_regs(struct sd *sd) + return; + } + ++ if (alt->desc.bNumEndpoints < 1) { ++ sd->gspca_dev.usb_err = -ENODEV; ++ return; ++ } ++ + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + ov518_reg_w32(sd, R51x_FIFO_PSIZE, packet_size & ~7, 2); + +diff --git a/drivers/media/usb/gspca/stv06xx/stv06xx.c b/drivers/media/usb/gspca/stv06xx/stv06xx.c +index 6080a35310ca..b7ea4f982964 100644 +--- a/drivers/media/usb/gspca/stv06xx/stv06xx.c ++++ b/drivers/media/usb/gspca/stv06xx/stv06xx.c +@@ -291,6 +291,9 @@ static int stv06xx_start(struct gspca_dev *gspca_dev) + return -EIO; + } + ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + err = stv06xx_write_bridge(sd, STV_ISO_SIZE_L, packet_size); + if (err < 0) +@@ -315,11 +318,21 @@ out: + + static int stv06xx_isoc_init(struct gspca_dev *gspca_dev) + { ++ struct usb_interface_cache *intfc; + struct usb_host_interface *alt; + struct sd *sd = (struct sd *) gspca_dev; + ++ intfc = gspca_dev->dev->actconfig->intf_cache[0]; ++ ++ if (intfc->num_altsetting < 2) ++ return -ENODEV; ++ ++ alt = &intfc->altsetting[1]; ++ ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + /* Start isoc bandwidth "negotiation" at max isoc bandwidth */ +- alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; + alt->endpoint[0].desc.wMaxPacketSize = + cpu_to_le16(sd->sensor->max_packet_size[gspca_dev->curr_mode]); + +@@ -332,6 +345,10 @@ static int stv06xx_isoc_nego(struct gspca_dev *gspca_dev) + struct usb_host_interface *alt; + struct sd *sd = (struct sd *) gspca_dev; + ++ /* ++ * Existence of altsetting and endpoint was verified in ++ * stv06xx_isoc_init() ++ */ + alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + min_packet_size = sd->sensor->min_packet_size[gspca_dev->curr_mode]; +diff --git a/drivers/media/usb/gspca/stv06xx/stv06xx_pb0100.c b/drivers/media/usb/gspca/stv06xx/stv06xx_pb0100.c +index 7374aeb0a67a..6f1ced465472 100644 +--- a/drivers/media/usb/gspca/stv06xx/stv06xx_pb0100.c ++++ b/drivers/media/usb/gspca/stv06xx/stv06xx_pb0100.c +@@ -194,6 +194,10 @@ static int pb0100_start(struct sd *sd) + alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt); + if (!alt) + return -ENODEV; ++ ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + + /* If we don't have enough bandwidth use a lower framerate */ +diff --git a/drivers/media/usb/gspca/xirlink_cit.c b/drivers/media/usb/gspca/xirlink_cit.c +index 58deb0c38826..fa65c3eaa725 100644 +--- a/drivers/media/usb/gspca/xirlink_cit.c ++++ b/drivers/media/usb/gspca/xirlink_cit.c +@@ -1452,6 +1452,9 @@ static int cit_get_packet_size(struct gspca_dev *gspca_dev) + return -EIO; + } + ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + } + +@@ -2636,6 +2639,7 @@ static int sd_start(struct gspca_dev *gspca_dev) + + static int sd_isoc_init(struct gspca_dev *gspca_dev) + { ++ struct usb_interface_cache *intfc; + struct usb_host_interface *alt; + int max_packet_size; + +@@ -2651,8 +2655,17 @@ static int sd_isoc_init(struct gspca_dev *gspca_dev) + break; + } + ++ intfc = gspca_dev->dev->actconfig->intf_cache[0]; ++ ++ if (intfc->num_altsetting < 2) ++ return -ENODEV; ++ ++ alt = &intfc->altsetting[1]; ++ ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + /* Start isoc bandwidth "negotiation" at max isoc bandwidth */ +- alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; + alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size); + + return 0; +@@ -2675,6 +2688,9 @@ static int sd_isoc_nego(struct gspca_dev *gspca_dev) + break; + } + ++ /* ++ * Existence of altsetting and endpoint was verified in sd_isoc_init() ++ */ + alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; + packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); + if (packet_size <= min_packet_size) +diff --git a/drivers/media/usb/usbtv/usbtv-core.c b/drivers/media/usb/usbtv/usbtv-core.c +index 5095c380b2c1..ee9c656d121f 100644 +--- a/drivers/media/usb/usbtv/usbtv-core.c ++++ b/drivers/media/usb/usbtv/usbtv-core.c +@@ -56,7 +56,7 @@ int usbtv_set_regs(struct usbtv *usbtv, const u16 regs[][2], int size) + + ret = usb_control_msg(usbtv->udev, pipe, USBTV_REQUEST_REG, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, +- value, index, NULL, 0, 0); ++ value, index, NULL, 0, USB_CTRL_GET_TIMEOUT); + if (ret < 0) + return ret; + } +diff --git a/drivers/media/usb/usbtv/usbtv-video.c b/drivers/media/usb/usbtv/usbtv-video.c +index 36a9a4017185..6ff806ca43f5 100644 +--- a/drivers/media/usb/usbtv/usbtv-video.c ++++ b/drivers/media/usb/usbtv/usbtv-video.c +@@ -805,7 +805,8 @@ static int usbtv_s_ctrl(struct v4l2_ctrl *ctrl) + ret = usb_control_msg(usbtv->udev, + usb_rcvctrlpipe(usbtv->udev, 0), USBTV_CONTROL_REG, + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, +- 0, USBTV_BASE + 0x0244, (void *)data, 3, 0); ++ 0, USBTV_BASE + 0x0244, (void *)data, 3, ++ USB_CTRL_GET_TIMEOUT); + if (ret < 0) + goto error; + } +@@ -856,7 +857,7 @@ static int usbtv_s_ctrl(struct v4l2_ctrl *ctrl) + ret = usb_control_msg(usbtv->udev, usb_sndctrlpipe(usbtv->udev, 0), + USBTV_CONTROL_REG, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, +- 0, index, (void *)data, size, 0); ++ 0, index, (void *)data, size, USB_CTRL_SET_TIMEOUT); + + error: + if (ret < 0) +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index 0a74785e575b..56f7f3600469 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -2043,8 +2043,11 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from, + * the erase operation does not exceed the max_busy_timeout, we should + * use R1B response. Or we need to prevent the host from doing hw busy + * detection, which is done by converting to a R1 response instead. ++ * Note, some hosts requires R1B, which also means they are on their own ++ * when it comes to deal with the busy timeout. + */ +- if (card->host->max_busy_timeout && ++ if (!(card->host->caps & MMC_CAP_NEED_RSP_BUSY) && ++ card->host->max_busy_timeout && + busy_timeout > card->host->max_busy_timeout) { + cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; + } else { +diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c +index f1fe446eee66..5ca53e225382 100644 +--- a/drivers/mmc/core/mmc.c ++++ b/drivers/mmc/core/mmc.c +@@ -1901,9 +1901,12 @@ static int mmc_sleep(struct mmc_host *host) + * If the max_busy_timeout of the host is specified, validate it against + * the sleep cmd timeout. A failure means we need to prevent the host + * from doing hw busy detection, which is done by converting to a R1 +- * response instead of a R1B. ++ * response instead of a R1B. Note, some hosts requires R1B, which also ++ * means they are on their own when it comes to deal with the busy ++ * timeout. + */ +- if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) { ++ if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout && ++ (timeout_ms > host->max_busy_timeout)) { + cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; + } else { + cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; +diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c +index 873b2aa0c155..693b99eff74b 100644 +--- a/drivers/mmc/core/mmc_ops.c ++++ b/drivers/mmc/core/mmc_ops.c +@@ -536,10 +536,12 @@ int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, + * If the cmd timeout and the max_busy_timeout of the host are both + * specified, let's validate them. A failure means we need to prevent + * the host from doing hw busy detection, which is done by converting +- * to a R1 response instead of a R1B. ++ * to a R1 response instead of a R1B. Note, some hosts requires R1B, ++ * which also means they are on their own when it comes to deal with the ++ * busy timeout. + */ +- if (timeout_ms && host->max_busy_timeout && +- (timeout_ms > host->max_busy_timeout)) ++ if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && timeout_ms && ++ host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) + use_r1b_resp = false; + + cmd.opcode = MMC_SWITCH; +diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c +index e9793d8e83a0..05ade7a2dd24 100644 +--- a/drivers/mmc/host/sdhci-omap.c ++++ b/drivers/mmc/host/sdhci-omap.c +@@ -1147,6 +1147,9 @@ static int sdhci_omap_probe(struct platform_device *pdev) + host->mmc_host_ops.execute_tuning = sdhci_omap_execute_tuning; + host->mmc_host_ops.enable_sdio_irq = sdhci_omap_enable_sdio_irq; + ++ /* R1B responses is required to properly manage HW busy detection. */ ++ mmc->caps |= MMC_CAP_NEED_RSP_BUSY; ++ + ret = sdhci_setup_host(host); + if (ret) + goto err_put_sync; +diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c +index 14d749a0de95..27bdf6d499bd 100644 +--- a/drivers/mmc/host/sdhci-tegra.c ++++ b/drivers/mmc/host/sdhci-tegra.c +@@ -502,6 +502,9 @@ static int sdhci_tegra_probe(struct platform_device *pdev) + if (tegra_host->soc_data->nvquirks & NVQUIRK_ENABLE_DDR50) + host->mmc->caps |= MMC_CAP_1_8V_DDR; + ++ /* R1B responses is required to properly manage HW busy detection. */ ++ host->mmc->caps |= MMC_CAP_NEED_RSP_BUSY; ++ + tegra_host->power_gpio = devm_gpiod_get_optional(&pdev->dev, "power", + GPIOD_OUT_HIGH); + if (IS_ERR(tegra_host->power_gpio)) { +diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c +index b2e5bcae7fbe..db9607809620 100644 +--- a/drivers/net/can/slcan.c ++++ b/drivers/net/can/slcan.c +@@ -621,7 +621,10 @@ err_free_chan: + tty->disc_data = NULL; + clear_bit(SLF_INUSE, &sl->flags); + slc_free_netdev(sl->dev); ++ /* do not call free_netdev before rtnl_unlock */ ++ rtnl_unlock(); + free_netdev(sl->dev); ++ return err; + + err_exit: + rtnl_unlock(); +diff --git a/drivers/net/dsa/mt7530.c b/drivers/net/dsa/mt7530.c +index 62e486652e62..8aa3b0af9fc2 100644 +--- a/drivers/net/dsa/mt7530.c ++++ b/drivers/net/dsa/mt7530.c +@@ -549,7 +549,7 @@ mt7530_mib_reset(struct dsa_switch *ds) + static void + mt7530_port_set_status(struct mt7530_priv *priv, int port, int enable) + { +- u32 mask = PMCR_TX_EN | PMCR_RX_EN; ++ u32 mask = PMCR_TX_EN | PMCR_RX_EN | PMCR_FORCE_LNK; + + if (enable) + mt7530_set(priv, MT7530_PMCR_P(port), mask); +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +index 911cea2e5aa5..f008c91d4566 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +@@ -8822,6 +8822,10 @@ static int bnxt_set_dflt_rings(struct bnxt *bp, bool sh) + bp->rx_nr_rings++; + bp->cp_nr_rings++; + } ++ if (rc) { ++ bp->tx_nr_rings = 0; ++ bp->rx_nr_rings = 0; ++ } + return rc; + } + +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c +index 0e4e0b47f5d8..5becfcf55ffd 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c +@@ -479,24 +479,26 @@ static int bnxt_dcbnl_ieee_getets(struct net_device *dev, struct ieee_ets *ets) + { + struct bnxt *bp = netdev_priv(dev); + struct ieee_ets *my_ets = bp->ieee_ets; ++ int rc; + + ets->ets_cap = bp->max_tc; + + if (!my_ets) { +- int rc; +- + if (bp->dcbx_cap & DCB_CAP_DCBX_HOST) + return 0; + + my_ets = kzalloc(sizeof(*my_ets), GFP_KERNEL); + if (!my_ets) +- return 0; ++ return -ENOMEM; + rc = bnxt_hwrm_queue_cos2bw_qcfg(bp, my_ets); + if (rc) +- return 0; ++ goto error; + rc = bnxt_hwrm_queue_pri2cos_qcfg(bp, my_ets); + if (rc) +- return 0; ++ goto error; ++ ++ /* cache result */ ++ bp->ieee_ets = my_ets; + } + + ets->cbs = my_ets->cbs; +@@ -505,6 +507,9 @@ static int bnxt_dcbnl_ieee_getets(struct net_device *dev, struct ieee_ets *ets) + memcpy(ets->tc_tsa, my_ets->tc_tsa, sizeof(ets->tc_tsa)); + memcpy(ets->prio_tc, my_ets->prio_tc, sizeof(ets->prio_tc)); + return 0; ++error: ++ kfree(my_ets); ++ return rc; + } + + static int bnxt_dcbnl_ieee_setets(struct net_device *dev, struct ieee_ets *ets) +diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +index d7736c9c6339..4b21ae27a9fd 100644 +--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c ++++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +@@ -2764,9 +2764,7 @@ static inline u16 dpaa_get_headroom(struct dpaa_buffer_layout *bl) + headroom = (u16)(bl->priv_data_size + DPAA_PARSE_RESULTS_SIZE + + DPAA_TIME_STAMP_SIZE + DPAA_HASH_RESULTS_SIZE); + +- return DPAA_FD_DATA_ALIGNMENT ? ALIGN(headroom, +- DPAA_FD_DATA_ALIGNMENT) : +- headroom; ++ return ALIGN(headroom, DPAA_FD_DATA_ALIGNMENT); + } + + static int dpaa_eth_probe(struct platform_device *pdev) +diff --git a/drivers/net/ethernet/freescale/fman/Kconfig b/drivers/net/ethernet/freescale/fman/Kconfig +index dc0850b3b517..0b07ece83a2f 100644 +--- a/drivers/net/ethernet/freescale/fman/Kconfig ++++ b/drivers/net/ethernet/freescale/fman/Kconfig +@@ -7,3 +7,31 @@ config FSL_FMAN + help + Freescale Data-Path Acceleration Architecture Frame Manager + (FMan) support ++ ++config DPAA_ERRATUM_A050385 ++ bool ++ depends on ARM64 && FSL_DPAA ++ default y ++ help ++ DPAA FMan erratum A050385 software workaround implementation: ++ align buffers, data start, SG fragment length to avoid FMan DMA ++ splits. ++ FMAN DMA read or writes under heavy traffic load may cause FMAN ++ internal resource leak thus stopping further packet processing. ++ The FMAN internal queue can overflow when FMAN splits single ++ read or write transactions into multiple smaller transactions ++ such that more than 17 AXI transactions are in flight from FMAN ++ to interconnect. When the FMAN internal queue overflows, it can ++ stall further packet processing. The issue can occur with any ++ one of the following three conditions: ++ 1. FMAN AXI transaction crosses 4K address boundary (Errata ++ A010022) ++ 2. FMAN DMA address for an AXI transaction is not 16 byte ++ aligned, i.e. the last 4 bits of an address are non-zero ++ 3. Scatter Gather (SG) frames have more than one SG buffer in ++ the SG list and any one of the buffers, except the last ++ buffer in the SG list has data size that is not a multiple ++ of 16 bytes, i.e., other than 16, 32, 48, 64, etc. ++ With any one of the above three conditions present, there is ++ likelihood of stalled FMAN packet processing, especially under ++ stress with multiple ports injecting line-rate traffic. +diff --git a/drivers/net/ethernet/freescale/fman/fman.c b/drivers/net/ethernet/freescale/fman/fman.c +index e80fedb27cee..21d8023535ae 100644 +--- a/drivers/net/ethernet/freescale/fman/fman.c ++++ b/drivers/net/ethernet/freescale/fman/fman.c +@@ -1,5 +1,6 @@ + /* + * Copyright 2008-2015 Freescale Semiconductor Inc. ++ * Copyright 2020 NXP + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: +@@ -566,6 +567,10 @@ struct fman_cfg { + u32 qmi_def_tnums_thresh; + }; + ++#ifdef CONFIG_DPAA_ERRATUM_A050385 ++static bool fman_has_err_a050385; ++#endif ++ + static irqreturn_t fman_exceptions(struct fman *fman, + enum fman_exceptions exception) + { +@@ -2517,6 +2522,14 @@ struct fman *fman_bind(struct device *fm_dev) + } + EXPORT_SYMBOL(fman_bind); + ++#ifdef CONFIG_DPAA_ERRATUM_A050385 ++bool fman_has_errata_a050385(void) ++{ ++ return fman_has_err_a050385; ++} ++EXPORT_SYMBOL(fman_has_errata_a050385); ++#endif ++ + static irqreturn_t fman_err_irq(int irq, void *handle) + { + struct fman *fman = (struct fman *)handle; +@@ -2844,6 +2857,11 @@ static struct fman *read_dts_node(struct platform_device *of_dev) + goto fman_free; + } + ++#ifdef CONFIG_DPAA_ERRATUM_A050385 ++ fman_has_err_a050385 = ++ of_property_read_bool(fm_node, "fsl,erratum-a050385"); ++#endif ++ + return fman; + + fman_node_put: +diff --git a/drivers/net/ethernet/freescale/fman/fman.h b/drivers/net/ethernet/freescale/fman/fman.h +index 935c317fa696..f2ede1360f03 100644 +--- a/drivers/net/ethernet/freescale/fman/fman.h ++++ b/drivers/net/ethernet/freescale/fman/fman.h +@@ -1,5 +1,6 @@ + /* + * Copyright 2008-2015 Freescale Semiconductor Inc. ++ * Copyright 2020 NXP + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: +@@ -398,6 +399,10 @@ u16 fman_get_max_frm(void); + + int fman_get_rx_extra_headroom(void); + ++#ifdef CONFIG_DPAA_ERRATUM_A050385 ++bool fman_has_errata_a050385(void); ++#endif ++ + struct fman *fman_bind(struct device *dev); + + #endif /* __FM_H */ +diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c +index 51885e6dec50..30a16cf796c7 100644 +--- a/drivers/net/ethernet/marvell/mvneta.c ++++ b/drivers/net/ethernet/marvell/mvneta.c +@@ -2801,11 +2801,10 @@ static int mvneta_poll(struct napi_struct *napi, int budget) + /* For the case where the last mvneta_poll did not process all + * RX packets + */ +- rx_queue = fls(((cause_rx_tx >> 8) & 0xff)); +- + cause_rx_tx |= pp->neta_armada3700 ? pp->cause_rx_tx : + port->cause_rx_tx; + ++ rx_queue = fls(((cause_rx_tx >> 8) & 0xff)); + if (rx_queue) { + rx_queue = rx_queue - 1; + if (pp->bm_priv) +diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c +index 54275624718b..336e5ecc68f8 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c +@@ -637,12 +637,12 @@ static int mlxsw_sp_mr_vif_resolve(struct mlxsw_sp_mr_table *mr_table, + return 0; + + err_erif_unresolve: +- list_for_each_entry_from_reverse(erve, &mr_vif->route_evif_list, +- vif_node) ++ list_for_each_entry_continue_reverse(erve, &mr_vif->route_evif_list, ++ vif_node) + mlxsw_sp_mr_route_evif_unresolve(mr_table, erve); + err_irif_unresolve: +- list_for_each_entry_from_reverse(irve, &mr_vif->route_ivif_list, +- vif_node) ++ list_for_each_entry_continue_reverse(irve, &mr_vif->route_ivif_list, ++ vif_node) + mlxsw_sp_mr_route_ivif_unresolve(mr_table, irve); + mr_vif->rif = NULL; + return err; +diff --git a/drivers/net/ethernet/micrel/ks8851_mll.c b/drivers/net/ethernet/micrel/ks8851_mll.c +index a5525bf977e2..68af0d8cf613 100644 +--- a/drivers/net/ethernet/micrel/ks8851_mll.c ++++ b/drivers/net/ethernet/micrel/ks8851_mll.c +@@ -475,6 +475,50 @@ static int msg_enable; + * chip is busy transferring packet data (RX/TX FIFO accesses). + */ + ++/** ++ * ks_check_endian - Check whether endianness of the bus is correct ++ * @ks : The chip information ++ * ++ * The KS8851-16MLL EESK pin allows selecting the endianness of the 16bit ++ * bus. To maintain optimum performance, the bus endianness should be set ++ * such that it matches the endianness of the CPU. ++ */ ++ ++static int ks_check_endian(struct ks_net *ks) ++{ ++ u16 cider; ++ ++ /* ++ * Read CIDER register first, however read it the "wrong" way around. ++ * If the endian strap on the KS8851-16MLL in incorrect and the chip ++ * is operating in different endianness than the CPU, then the meaning ++ * of BE[3:0] byte-enable bits is also swapped such that: ++ * BE[3,2,1,0] becomes BE[1,0,3,2] ++ * ++ * Luckily for us, the byte-enable bits are the top four MSbits of ++ * the address register and the CIDER register is at offset 0xc0. ++ * Hence, by reading address 0xc0c0, which is not impacted by endian ++ * swapping, we assert either BE[3:2] or BE[1:0] while reading the ++ * CIDER register. ++ * ++ * If the bus configuration is correct, reading 0xc0c0 asserts ++ * BE[3:2] and this read returns 0x0000, because to read register ++ * with bottom two LSbits of address set to 0, BE[1:0] must be ++ * asserted. ++ * ++ * If the bus configuration is NOT correct, reading 0xc0c0 asserts ++ * BE[1:0] and this read returns non-zero 0x8872 value. ++ */ ++ iowrite16(BE3 | BE2 | KS_CIDER, ks->hw_addr_cmd); ++ cider = ioread16(ks->hw_addr); ++ if (!cider) ++ return 0; ++ ++ netdev_err(ks->netdev, "incorrect EESK endian strap setting\n"); ++ ++ return -EINVAL; ++} ++ + /** + * ks_rdreg16 - read 16 bit register from device + * @ks : The chip information +@@ -485,7 +529,7 @@ static int msg_enable; + + static u16 ks_rdreg16(struct ks_net *ks, int offset) + { +- ks->cmd_reg_cache = (u16)offset | ((BE3 | BE2) >> (offset & 0x02)); ++ ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02)); + iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); + return ioread16(ks->hw_addr); + } +@@ -500,7 +544,7 @@ static u16 ks_rdreg16(struct ks_net *ks, int offset) + + static void ks_wrreg16(struct ks_net *ks, int offset, u16 value) + { +- ks->cmd_reg_cache = (u16)offset | ((BE3 | BE2) >> (offset & 0x02)); ++ ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02)); + iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); + iowrite16(value, ks->hw_addr); + } +@@ -516,7 +560,7 @@ static inline void ks_inblk(struct ks_net *ks, u16 *wptr, u32 len) + { + len >>= 1; + while (len--) +- *wptr++ = be16_to_cpu(ioread16(ks->hw_addr)); ++ *wptr++ = (u16)ioread16(ks->hw_addr); + } + + /** +@@ -530,7 +574,7 @@ static inline void ks_outblk(struct ks_net *ks, u16 *wptr, u32 len) + { + len >>= 1; + while (len--) +- iowrite16(cpu_to_be16(*wptr++), ks->hw_addr); ++ iowrite16(*wptr++, ks->hw_addr); + } + + static void ks_disable_int(struct ks_net *ks) +@@ -1540,6 +1584,10 @@ static int ks8851_probe(struct platform_device *pdev) + goto err_free; + } + ++ err = ks_check_endian(ks); ++ if (err) ++ goto err_free; ++ + netdev->irq = platform_get_irq(pdev, 0); + + if ((int)netdev->irq < 0) { +diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c +index 6ea43e48d5f9..807ef43a3cda 100644 +--- a/drivers/net/ethernet/realtek/r8169.c ++++ b/drivers/net/ethernet/realtek/r8169.c +@@ -7249,7 +7249,7 @@ static int rtl_alloc_irq(struct rtl8169_private *tp) + RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable); + RTL_W8(tp, Cfg9346, Cfg9346_Lock); + /* fall through */ +- case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_24: ++ case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_17: + flags = PCI_IRQ_LEGACY; + break; + default: +@@ -7433,15 +7433,6 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) + int chipset, region, i; + int jumbo_max, rc; + +- /* Some tools for creating an initramfs don't consider softdeps, then +- * r8169.ko may be in initramfs, but realtek.ko not. Then the generic +- * PHY driver is used that doesn't work with most chip versions. +- */ +- if (!driver_find("RTL8201CP Ethernet", &mdio_bus_type)) { +- dev_err(&pdev->dev, "realtek.ko not loaded, maybe it needs to be added to initramfs?\n"); +- return -ENOENT; +- } +- + dev = devm_alloc_etherdev(&pdev->dev, sizeof (*tp)); + if (!dev) + return -ENOMEM; +diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c +index a9da1ad4b4f2..30cd087aa67c 100644 +--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c ++++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c +@@ -2282,7 +2282,7 @@ static int __init sxgbe_cmdline_opt(char *str) + if (!str || !*str) + return -EINVAL; + while ((opt = strsep(&str, ",")) != NULL) { +- if (!strncmp(opt, "eee_timer:", 6)) { ++ if (!strncmp(opt, "eee_timer:", 10)) { + if (kstrtoint(opt + 10, 0, &eee_timer)) + goto err; + } +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c +index f45df6df6932..4e83ccab7253 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c +@@ -1420,7 +1420,7 @@ static int rk_gmac_probe(struct platform_device *pdev) + + ret = rk_gmac_clk_init(plat_dat); + if (ret) +- return ret; ++ goto err_remove_config_dt; + + ret = rk_gmac_powerup(plat_dat->bsp_priv); + if (ret) +diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c +index e1427b56a073..ff83408733d4 100644 +--- a/drivers/net/geneve.c ++++ b/drivers/net/geneve.c +@@ -1725,8 +1725,6 @@ static void geneve_destroy_tunnels(struct net *net, struct list_head *head) + if (!net_eq(dev_net(geneve->dev), net)) + unregister_netdevice_queue(geneve->dev, head); + } +- +- WARN_ON_ONCE(!list_empty(&gn->sock_list)); + } + + static void __net_exit geneve_exit_batch_net(struct list_head *net_list) +@@ -1741,6 +1739,12 @@ static void __net_exit geneve_exit_batch_net(struct list_head *net_list) + /* unregister the devices gathered above */ + unregister_netdevice_many(&list); + rtnl_unlock(); ++ ++ list_for_each_entry(net, net_list, exit_list) { ++ const struct geneve_net *gn = net_generic(net, geneve_net_id); ++ ++ WARN_ON_ONCE(!list_empty(&gn->sock_list)); ++ } + } + + static struct pernet_operations geneve_net_ops = { +diff --git a/drivers/net/macsec.c b/drivers/net/macsec.c +index 9a8ec94e8a44..df7d6de7c59c 100644 +--- a/drivers/net/macsec.c ++++ b/drivers/net/macsec.c +@@ -20,6 +20,7 @@ + #include <net/genetlink.h> + #include <net/sock.h> + #include <net/gro_cells.h> ++#include <linux/if_arp.h> + + #include <uapi/linux/if_macsec.h> + +@@ -3248,6 +3249,8 @@ static int macsec_newlink(struct net *net, struct net_device *dev, + real_dev = __dev_get_by_index(net, nla_get_u32(tb[IFLA_LINK])); + if (!real_dev) + return -ENODEV; ++ if (real_dev->type != ARPHRD_ETHER) ++ return -EINVAL; + + dev->priv_flags |= IFF_MACSEC; + +diff --git a/drivers/net/phy/mdio-mux-bcm-iproc.c b/drivers/net/phy/mdio-mux-bcm-iproc.c +index c017486e9b86..575e0bd76193 100644 +--- a/drivers/net/phy/mdio-mux-bcm-iproc.c ++++ b/drivers/net/phy/mdio-mux-bcm-iproc.c +@@ -301,8 +301,13 @@ static int mdio_mux_iproc_resume(struct device *dev) + { + struct platform_device *pdev = to_platform_device(dev); + struct iproc_mdiomux_desc *md = platform_get_drvdata(pdev); ++ int rc; + +- clk_prepare_enable(md->core_clk); ++ rc = clk_prepare_enable(md->core_clk); ++ if (rc) { ++ dev_err(md->dev, "failed to enable core clk\n"); ++ return rc; ++ } + mdio_mux_iproc_config(md); + + return 0; +diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c +index 1d60ccd48ec2..a7804def1120 100644 +--- a/drivers/net/usb/qmi_wwan.c ++++ b/drivers/net/usb/qmi_wwan.c +@@ -1147,6 +1147,7 @@ static const struct usb_device_id products[] = { + {QMI_FIXED_INTF(0x1435, 0xd182, 5)}, /* Wistron NeWeb D18 */ + {QMI_FIXED_INTF(0x1435, 0xd191, 4)}, /* Wistron NeWeb D19Q1 */ + {QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */ ++ {QMI_FIXED_INTF(0x1690, 0x7588, 4)}, /* ASKEY WWHC050 */ + {QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */ + {QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */ + {QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */ +diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c +index df88981e796a..64751b089482 100644 +--- a/drivers/net/vxlan.c ++++ b/drivers/net/vxlan.c +@@ -2451,10 +2451,19 @@ static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan, + /* Setup stats when device is created */ + static int vxlan_init(struct net_device *dev) + { ++ struct vxlan_dev *vxlan = netdev_priv(dev); ++ int err; ++ + dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); + if (!dev->tstats) + return -ENOMEM; + ++ err = gro_cells_init(&vxlan->gro_cells, dev); ++ if (err) { ++ free_percpu(dev->tstats); ++ return err; ++ } ++ + return 0; + } + +@@ -2712,8 +2721,6 @@ static void vxlan_setup(struct net_device *dev) + + vxlan->dev = dev; + +- gro_cells_init(&vxlan->gro_cells, dev); +- + for (h = 0; h < FDB_HASH_SIZE; ++h) + INIT_HLIST_HEAD(&vxlan->fdb_head[h]); + } +diff --git a/drivers/nfc/fdp/fdp.c b/drivers/nfc/fdp/fdp.c +index d5784a47fc13..954c83e917eb 100644 +--- a/drivers/nfc/fdp/fdp.c ++++ b/drivers/nfc/fdp/fdp.c +@@ -192,7 +192,7 @@ static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type) + const struct firmware *fw; + struct sk_buff *skb; + unsigned long len; +- u8 max_size, payload_size; ++ int max_size, payload_size; + int rc = 0; + + if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) || +@@ -215,8 +215,7 @@ static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type) + + while (len) { + +- payload_size = min_t(unsigned long, (unsigned long) max_size, +- len); ++ payload_size = min_t(unsigned long, max_size, len); + + skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size), + GFP_KERNEL); +diff --git a/drivers/of/of_mdio.c b/drivers/of/of_mdio.c +index 7d2bc22680d9..af7572fe090f 100644 +--- a/drivers/of/of_mdio.c ++++ b/drivers/of/of_mdio.c +@@ -270,6 +270,7 @@ int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np) + rc = of_mdiobus_register_phy(mdio, child, addr); + if (rc && rc != -ENODEV) + goto unregister; ++ break; + } + } + } +diff --git a/drivers/platform/x86/pmc_atom.c b/drivers/platform/x86/pmc_atom.c +index 9c94ebb251cb..26351e9e0aaf 100644 +--- a/drivers/platform/x86/pmc_atom.c ++++ b/drivers/platform/x86/pmc_atom.c +@@ -413,6 +413,14 @@ static const struct dmi_system_id critclk_systems[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "3I380D"), + }, + }, ++ { ++ /* pmc_plt_clk* - are used for ethernet controllers */ ++ .ident = "Lex 2I385SW", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Lex BayTrail"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "2I385SW"), ++ }, ++ }, + { + /* pmc_plt_clk* - are used for ethernet controllers */ + .ident = "Beckhoff CB3163", +diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c +index d99bfbfcafb7..5f59e2dfc7db 100644 +--- a/drivers/s390/net/qeth_core_main.c ++++ b/drivers/s390/net/qeth_core_main.c +@@ -2811,12 +2811,12 @@ static int qeth_init_input_buffer(struct qeth_card *card, + buf->rx_skb = netdev_alloc_skb(card->dev, + QETH_RX_PULL_LEN + ETH_HLEN); + if (!buf->rx_skb) +- return 1; ++ return -ENOMEM; + } + + pool_entry = qeth_find_free_buffer_pool_entry(card); + if (!pool_entry) +- return 1; ++ return -ENOBUFS; + + /* + * since the buffer is accessed only from the input_tasklet +@@ -2848,10 +2848,15 @@ int qeth_init_qdio_queues(struct qeth_card *card) + /* inbound queue */ + qdio_reset_buffers(card->qdio.in_q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q); + memset(&card->rx, 0, sizeof(struct qeth_rx)); ++ + qeth_initialize_working_pool_list(card); + /*give only as many buffers to hardware as we have buffer pool entries*/ +- for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; ++i) +- qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]); ++ for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; i++) { ++ rc = qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]); ++ if (rc) ++ return rc; ++ } ++ + card->qdio.in_q->next_buf_to_init = + card->qdio.in_buf_pool.buf_count - 1; + rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 0, +diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c +index 271990bc065b..1b04a8223eb0 100644 +--- a/drivers/scsi/ipr.c ++++ b/drivers/scsi/ipr.c +@@ -9958,6 +9958,7 @@ static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg, + ioa_cfg->max_devs_supported = ipr_max_devs; + + if (ioa_cfg->sis64) { ++ host->max_channel = IPR_MAX_SIS64_BUSES; + host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS; + host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET; + if (ipr_max_devs > IPR_MAX_SIS64_DEVS) +@@ -9966,6 +9967,7 @@ static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg, + + ((sizeof(struct ipr_config_table_entry64) + * ioa_cfg->max_devs_supported))); + } else { ++ host->max_channel = IPR_VSET_BUS; + host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS; + host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET; + if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS) +@@ -9975,7 +9977,6 @@ static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg, + * ioa_cfg->max_devs_supported))); + } + +- host->max_channel = IPR_VSET_BUS; + host->unique_id = host->host_no; + host->max_cmd_len = IPR_MAX_CDB_LEN; + host->can_queue = ioa_cfg->max_cmds; +diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h +index f6baa2351313..9fbcdc283cdb 100644 +--- a/drivers/scsi/ipr.h ++++ b/drivers/scsi/ipr.h +@@ -1313,6 +1313,7 @@ struct ipr_resource_entry { + #define IPR_ARRAY_VIRTUAL_BUS 0x1 + #define IPR_VSET_VIRTUAL_BUS 0x2 + #define IPR_IOAFP_VIRTUAL_BUS 0x3 ++#define IPR_MAX_SIS64_BUSES 0x4 + + #define IPR_GET_RES_PHYS_LOC(res) \ + (((res)->bus << 24) | ((res)->target << 8) | (res)->lun) +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index 345b18d52ec6..f2f14d8d5943 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -3210,9 +3210,11 @@ static int sd_revalidate_disk(struct gendisk *disk) + if (sd_validate_opt_xfer_size(sdkp, dev_max)) { + q->limits.io_opt = logical_to_bytes(sdp, sdkp->opt_xfer_blocks); + rw_max = logical_to_sectors(sdp, sdkp->opt_xfer_blocks); +- } else ++ } else { ++ q->limits.io_opt = 0; + rw_max = min_not_zero(logical_to_sectors(sdp, dev_max), + (sector_t)BLK_DEF_MAX_SECTORS); ++ } + + /* Do not exceed controller limit */ + rw_max = min(rw_max, queue_max_hw_sectors(q)); +diff --git a/drivers/staging/rtl8188eu/os_dep/usb_intf.c b/drivers/staging/rtl8188eu/os_dep/usb_intf.c +index adf2937e395b..276c965afc11 100644 +--- a/drivers/staging/rtl8188eu/os_dep/usb_intf.c ++++ b/drivers/staging/rtl8188eu/os_dep/usb_intf.c +@@ -32,6 +32,7 @@ static const struct usb_device_id rtw_usb_id_tbl[] = { + /****** 8188EUS ********/ + {USB_DEVICE(0x056e, 0x4008)}, /* Elecom WDC-150SU2M */ + {USB_DEVICE(0x07b8, 0x8179)}, /* Abocom - Abocom */ ++ {USB_DEVICE(0x0B05, 0x18F0)}, /* ASUS USB-N10 Nano B1 */ + {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */ + {USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */ + {USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */ +diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c +index 767ec8184adf..65ad9773018e 100644 +--- a/drivers/staging/wlan-ng/hfa384x_usb.c ++++ b/drivers/staging/wlan-ng/hfa384x_usb.c +@@ -3494,6 +3494,8 @@ static void hfa384x_int_rxmonitor(struct wlandevice *wlandev, + WLAN_HDR_A4_LEN + WLAN_DATA_MAXLEN + WLAN_CRC_LEN)) { + pr_debug("overlen frm: len=%zd\n", + skblen - sizeof(struct p80211_caphdr)); ++ ++ return; + } + + skb = dev_alloc_skb(skblen); +diff --git a/drivers/staging/wlan-ng/prism2usb.c b/drivers/staging/wlan-ng/prism2usb.c +index b5ba176004c1..d8d86761b790 100644 +--- a/drivers/staging/wlan-ng/prism2usb.c ++++ b/drivers/staging/wlan-ng/prism2usb.c +@@ -180,6 +180,7 @@ static void prism2sta_disconnect_usb(struct usb_interface *interface) + + cancel_work_sync(&hw->link_bh); + cancel_work_sync(&hw->commsqual_bh); ++ cancel_work_sync(&hw->usb_work); + + /* Now we complete any outstanding commands + * and tell everyone who is waiting for their +diff --git a/drivers/tty/vt/selection.c b/drivers/tty/vt/selection.c +index 8a1671724835..34a0e529cb5a 100644 +--- a/drivers/tty/vt/selection.c ++++ b/drivers/tty/vt/selection.c +@@ -85,6 +85,11 @@ void clear_selection(void) + } + } + ++bool vc_is_sel(struct vc_data *vc) ++{ ++ return vc == sel_cons; ++} ++ + /* + * User settable table: what characters are to be considered alphabetic? + * 128 bits. Locked by the console lock. +diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c +index 5cecf529562a..36c6f1b98372 100644 +--- a/drivers/tty/vt/vt.c ++++ b/drivers/tty/vt/vt.c +@@ -890,8 +890,9 @@ static void hide_softcursor(struct vc_data *vc) + + static void hide_cursor(struct vc_data *vc) + { +- if (vc == sel_cons) ++ if (vc_is_sel(vc)) + clear_selection(); ++ + vc->vc_sw->con_cursor(vc, CM_ERASE); + hide_softcursor(vc); + } +@@ -901,7 +902,7 @@ static void set_cursor(struct vc_data *vc) + if (!con_is_fg(vc) || console_blanked || vc->vc_mode == KD_GRAPHICS) + return; + if (vc->vc_deccm) { +- if (vc == sel_cons) ++ if (vc_is_sel(vc)) + clear_selection(); + add_softcursor(vc); + if ((vc->vc_cursor_type & 0x0f) != 1) +@@ -1077,6 +1078,17 @@ static void visual_deinit(struct vc_data *vc) + module_put(vc->vc_sw->owner); + } + ++static void vc_port_destruct(struct tty_port *port) ++{ ++ struct vc_data *vc = container_of(port, struct vc_data, port); ++ ++ kfree(vc); ++} ++ ++static const struct tty_port_operations vc_port_ops = { ++ .destruct = vc_port_destruct, ++}; ++ + int vc_allocate(unsigned int currcons) /* return 0 on success */ + { + struct vt_notifier_param param; +@@ -1102,6 +1114,7 @@ int vc_allocate(unsigned int currcons) /* return 0 on success */ + + vc_cons[currcons].d = vc; + tty_port_init(&vc->port); ++ vc->port.ops = &vc_port_ops; + INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK); + + visual_init(vc, currcons, 1); +@@ -1210,7 +1223,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc, + } + } + +- if (vc == sel_cons) ++ if (vc_is_sel(vc)) + clear_selection(); + + old_rows = vc->vc_rows; +@@ -3228,6 +3241,7 @@ static int con_install(struct tty_driver *driver, struct tty_struct *tty) + + tty->driver_data = vc; + vc->port.tty = tty; ++ tty_port_get(&vc->port); + + if (!tty->winsize.ws_row && !tty->winsize.ws_col) { + tty->winsize.ws_row = vc_cons[currcons].d->vc_rows; +@@ -3263,6 +3277,13 @@ static void con_shutdown(struct tty_struct *tty) + console_unlock(); + } + ++static void con_cleanup(struct tty_struct *tty) ++{ ++ struct vc_data *vc = tty->driver_data; ++ ++ tty_port_put(&vc->port); ++} ++ + static int default_color = 7; /* white */ + static int default_italic_color = 2; // green (ASCII) + static int default_underline_color = 3; // cyan (ASCII) +@@ -3387,7 +3408,8 @@ static const struct tty_operations con_ops = { + .throttle = con_throttle, + .unthrottle = con_unthrottle, + .resize = vt_resize, +- .shutdown = con_shutdown ++ .shutdown = con_shutdown, ++ .cleanup = con_cleanup, + }; + + static struct cdev vc0_cdev; +diff --git a/drivers/tty/vt/vt_ioctl.c b/drivers/tty/vt/vt_ioctl.c +index 2bb6de89b029..5de81431c835 100644 +--- a/drivers/tty/vt/vt_ioctl.c ++++ b/drivers/tty/vt/vt_ioctl.c +@@ -39,11 +39,32 @@ + #include <linux/kbd_diacr.h> + #include <linux/selection.h> + +-char vt_dont_switch; +-extern struct tty_driver *console_driver; ++bool vt_dont_switch; + +-#define VT_IS_IN_USE(i) (console_driver->ttys[i] && console_driver->ttys[i]->count) +-#define VT_BUSY(i) (VT_IS_IN_USE(i) || i == fg_console || vc_cons[i].d == sel_cons) ++static inline bool vt_in_use(unsigned int i) ++{ ++ const struct vc_data *vc = vc_cons[i].d; ++ ++ /* ++ * console_lock must be held to prevent the vc from being deallocated ++ * while we're checking whether it's in-use. ++ */ ++ WARN_CONSOLE_UNLOCKED(); ++ ++ return vc && kref_read(&vc->port.kref) > 1; ++} ++ ++static inline bool vt_busy(int i) ++{ ++ if (vt_in_use(i)) ++ return true; ++ if (i == fg_console) ++ return true; ++ if (vc_is_sel(vc_cons[i].d)) ++ return true; ++ ++ return false; ++} + + /* + * Console (vt and kd) routines, as defined by USL SVR4 manual, and by +@@ -289,16 +310,14 @@ static int vt_disallocate(unsigned int vc_num) + int ret = 0; + + console_lock(); +- if (VT_BUSY(vc_num)) ++ if (vt_busy(vc_num)) + ret = -EBUSY; + else if (vc_num) + vc = vc_deallocate(vc_num); + console_unlock(); + +- if (vc && vc_num >= MIN_NR_CONSOLES) { +- tty_port_destroy(&vc->port); +- kfree(vc); +- } ++ if (vc && vc_num >= MIN_NR_CONSOLES) ++ tty_port_put(&vc->port); + + return ret; + } +@@ -311,17 +330,15 @@ static void vt_disallocate_all(void) + + console_lock(); + for (i = 1; i < MAX_NR_CONSOLES; i++) +- if (!VT_BUSY(i)) ++ if (!vt_busy(i)) + vc[i] = vc_deallocate(i); + else + vc[i] = NULL; + console_unlock(); + + for (i = 1; i < MAX_NR_CONSOLES; i++) { +- if (vc[i] && i >= MIN_NR_CONSOLES) { +- tty_port_destroy(&vc[i]->port); +- kfree(vc[i]); +- } ++ if (vc[i] && i >= MIN_NR_CONSOLES) ++ tty_port_put(&vc[i]->port); + } + } + +@@ -335,22 +352,13 @@ int vt_ioctl(struct tty_struct *tty, + { + struct vc_data *vc = tty->driver_data; + struct console_font_op op; /* used in multiple places here */ +- unsigned int console; ++ unsigned int console = vc->vc_num; + unsigned char ucval; + unsigned int uival; + void __user *up = (void __user *)arg; + int i, perm; + int ret = 0; + +- console = vc->vc_num; +- +- +- if (!vc_cons_allocated(console)) { /* impossible? */ +- ret = -ENOIOCTLCMD; +- goto out; +- } +- +- + /* + * To have permissions to do most of the vt ioctls, we either have + * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG. +@@ -641,15 +649,16 @@ int vt_ioctl(struct tty_struct *tty, + struct vt_stat __user *vtstat = up; + unsigned short state, mask; + +- /* Review: FIXME: Console lock ? */ + if (put_user(fg_console + 1, &vtstat->v_active)) + ret = -EFAULT; + else { + state = 1; /* /dev/tty0 is always open */ ++ console_lock(); /* required by vt_in_use() */ + for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; + ++i, mask <<= 1) +- if (VT_IS_IN_USE(i)) ++ if (vt_in_use(i)) + state |= mask; ++ console_unlock(); + ret = put_user(state, &vtstat->v_state); + } + break; +@@ -659,10 +668,11 @@ int vt_ioctl(struct tty_struct *tty, + * Returns the first available (non-opened) console. + */ + case VT_OPENQRY: +- /* FIXME: locking ? - but then this is a stupid API */ ++ console_lock(); /* required by vt_in_use() */ + for (i = 0; i < MAX_NR_CONSOLES; ++i) +- if (! VT_IS_IN_USE(i)) ++ if (!vt_in_use(i)) + break; ++ console_unlock(); + uival = i < MAX_NR_CONSOLES ? (i+1) : -1; + goto setint; + +@@ -1011,12 +1021,12 @@ int vt_ioctl(struct tty_struct *tty, + case VT_LOCKSWITCH: + if (!capable(CAP_SYS_TTY_CONFIG)) + return -EPERM; +- vt_dont_switch = 1; ++ vt_dont_switch = true; + break; + case VT_UNLOCKSWITCH: + if (!capable(CAP_SYS_TTY_CONFIG)) + return -EPERM; +- vt_dont_switch = 0; ++ vt_dont_switch = false; + break; + case VT_GETHIFONTMASK: + ret = put_user(vc->vc_hi_font_mask, +@@ -1180,18 +1190,10 @@ long vt_compat_ioctl(struct tty_struct *tty, + { + struct vc_data *vc = tty->driver_data; + struct console_font_op op; /* used in multiple places here */ +- unsigned int console; + void __user *up = (void __user *)arg; + int perm; + int ret = 0; + +- console = vc->vc_num; +- +- if (!vc_cons_allocated(console)) { /* impossible? */ +- ret = -ENOIOCTLCMD; +- goto out; +- } +- + /* + * To have permissions to do most of the vt ioctls, we either have + * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG. +@@ -1251,7 +1253,7 @@ long vt_compat_ioctl(struct tty_struct *tty, + arg = (unsigned long)compat_ptr(arg); + goto fallback; + } +-out: ++ + return ret; + + fallback: +diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c +index 8689bf7ba60f..6e0b41861735 100644 +--- a/drivers/usb/class/cdc-acm.c ++++ b/drivers/usb/class/cdc-acm.c +@@ -949,16 +949,16 @@ static int set_serial_info(struct acm *acm, + + mutex_lock(&acm->port.mutex); + +- if ((new_serial.close_delay != old_close_delay) || +- (new_serial.closing_wait != old_closing_wait)) { +- if (!capable(CAP_SYS_ADMIN)) ++ if (!capable(CAP_SYS_ADMIN)) { ++ if ((new_serial.close_delay != old_close_delay) || ++ (new_serial.closing_wait != old_closing_wait)) + retval = -EPERM; +- else { +- acm->port.close_delay = close_delay; +- acm->port.closing_wait = closing_wait; +- } +- } else +- retval = -EOPNOTSUPP; ++ else ++ retval = -EOPNOTSUPP; ++ } else { ++ acm->port.close_delay = close_delay; ++ acm->port.closing_wait = closing_wait; ++ } + + mutex_unlock(&acm->port.mutex); + return retval; +diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c +index b59ce9ad14ce..68f18afa8b2c 100644 +--- a/drivers/usb/musb/musb_host.c ++++ b/drivers/usb/musb/musb_host.c +@@ -1462,10 +1462,7 @@ done: + * We need to map sg if the transfer_buffer is + * NULL. + */ +- if (!urb->transfer_buffer) +- qh->use_sg = true; +- +- if (qh->use_sg) { ++ if (!urb->transfer_buffer) { + /* sg_miter_start is already done in musb_ep_program */ + if (!sg_miter_next(&qh->sg_miter)) { + dev_err(musb->controller, "error: sg list empty\n"); +@@ -1473,9 +1470,8 @@ done: + status = -EINVAL; + goto done; + } +- urb->transfer_buffer = qh->sg_miter.addr; + length = min_t(u32, length, qh->sg_miter.length); +- musb_write_fifo(hw_ep, length, urb->transfer_buffer); ++ musb_write_fifo(hw_ep, length, qh->sg_miter.addr); + qh->sg_miter.consumed = length; + sg_miter_stop(&qh->sg_miter); + } else { +@@ -1484,11 +1480,6 @@ done: + + qh->segsize = length; + +- if (qh->use_sg) { +- if (offset + length >= urb->transfer_buffer_length) +- qh->use_sg = false; +- } +- + musb_ep_select(mbase, epnum); + musb_writew(epio, MUSB_TXCSR, + MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY); +@@ -2003,8 +1994,10 @@ finish: + urb->actual_length += xfer_len; + qh->offset += xfer_len; + if (done) { +- if (qh->use_sg) ++ if (qh->use_sg) { + qh->use_sg = false; ++ urb->transfer_buffer = NULL; ++ } + + if (urb->status == -EINPROGRESS) + urb->status = status; +diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c +index 5d101b022e71..dab8c18e726f 100644 +--- a/drivers/usb/serial/io_edgeport.c ++++ b/drivers/usb/serial/io_edgeport.c +@@ -710,7 +710,7 @@ static void edge_interrupt_callback(struct urb *urb) + /* grab the txcredits for the ports if available */ + position = 2; + portNumber = 0; +- while ((position < length) && ++ while ((position < length - 1) && + (portNumber < edge_serial->serial->num_ports)) { + txCredits = data[position] | (data[position+1] << 8); + if (txCredits) { +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 1d4c370d44fe..8dad374ec81d 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -1992,8 +1992,14 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */ + { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */ + { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x7e11, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/A3 */ ++ { USB_DEVICE_INTERFACE_CLASS(0x1435, 0xd191, 0xff), /* Wistron Neweb D19Q1 */ ++ .driver_info = RSVD(1) | RSVD(4) }, ++ { USB_DEVICE_INTERFACE_CLASS(0x1690, 0x7588, 0xff), /* ASKEY WWHC050 */ ++ .driver_info = RSVD(1) | RSVD(4) }, + { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x2031, 0xff), /* Olicard 600 */ + .driver_info = RSVD(4) }, ++ { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x2033, 0xff), /* BroadMobi BM806U */ ++ .driver_info = RSVD(4) }, + { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x2060, 0xff), /* BroadMobi BM818 */ + .driver_info = RSVD(4) }, + { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x4000, 0xff) }, /* OLICARD300 - MT6225 */ +diff --git a/fs/afs/rxrpc.c b/fs/afs/rxrpc.c +index 560dd5ff5a15..5d6d4f9f092a 100644 +--- a/fs/afs/rxrpc.c ++++ b/fs/afs/rxrpc.c +@@ -159,7 +159,7 @@ void afs_put_call(struct afs_call *call) + int n = atomic_dec_return(&call->usage); + int o = atomic_read(&net->nr_outstanding_calls); + +- trace_afs_call(call, afs_call_trace_put, n + 1, o, ++ trace_afs_call(call, afs_call_trace_put, n, o, + __builtin_return_address(0)); + + ASSERTCMP(n, >=, 0); +@@ -654,7 +654,7 @@ static void afs_wake_up_async_call(struct sock *sk, struct rxrpc_call *rxcall, + + u = atomic_fetch_add_unless(&call->usage, 1, 0); + if (u != 0) { +- trace_afs_call(call, afs_call_trace_wake, u, ++ trace_afs_call(call, afs_call_trace_wake, u + 1, + atomic_read(&call->net->nr_outstanding_calls), + __builtin_return_address(0)); + +diff --git a/fs/ceph/file.c b/fs/ceph/file.c +index 91a7ad259bcf..faca455bd3c6 100644 +--- a/fs/ceph/file.c ++++ b/fs/ceph/file.c +@@ -1384,9 +1384,12 @@ static ssize_t ceph_write_iter(struct kiocb *iocb, struct iov_iter *from) + struct inode *inode = file_inode(file); + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_fs_client *fsc = ceph_inode_to_client(inode); ++ struct ceph_osd_client *osdc = &fsc->client->osdc; + struct ceph_cap_flush *prealloc_cf; + ssize_t count, written = 0; + int err, want, got; ++ u32 map_flags; ++ u64 pool_flags; + loff_t pos; + loff_t limit = max(i_size_read(inode), fsc->max_file_size); + +@@ -1441,8 +1444,12 @@ retry_snap: + goto out; + } + +- /* FIXME: not complete since it doesn't account for being at quota */ +- if (ceph_osdmap_flag(&fsc->client->osdc, CEPH_OSDMAP_FULL)) { ++ down_read(&osdc->lock); ++ map_flags = osdc->osdmap->flags; ++ pool_flags = ceph_pg_pool_flags(osdc->osdmap, ci->i_layout.pool_id); ++ up_read(&osdc->lock); ++ if ((map_flags & CEPH_OSDMAP_FULL) || ++ (pool_flags & CEPH_POOL_FLAG_FULL)) { + err = -ENOSPC; + goto out; + } +@@ -1532,7 +1539,8 @@ retry_snap: + } + + if (written >= 0) { +- if (ceph_osdmap_flag(&fsc->client->osdc, CEPH_OSDMAP_NEARFULL)) ++ if ((map_flags & CEPH_OSDMAP_NEARFULL) || ++ (pool_flags & CEPH_POOL_FLAG_NEARFULL)) + iocb->ki_flags |= IOCB_DSYNC; + written = generic_write_sync(iocb, written); + } +diff --git a/fs/libfs.c b/fs/libfs.c +index bd2d193d0a2a..02158618f4c9 100644 +--- a/fs/libfs.c ++++ b/fs/libfs.c +@@ -802,7 +802,7 @@ int simple_attr_open(struct inode *inode, struct file *file, + { + struct simple_attr *attr; + +- attr = kmalloc(sizeof(*attr), GFP_KERNEL); ++ attr = kzalloc(sizeof(*attr), GFP_KERNEL); + if (!attr) + return -ENOMEM; + +@@ -842,9 +842,11 @@ ssize_t simple_attr_read(struct file *file, char __user *buf, + if (ret) + return ret; + +- if (*ppos) { /* continued read */ ++ if (*ppos && attr->get_buf[0]) { ++ /* continued read */ + size = strlen(attr->get_buf); +- } else { /* first read */ ++ } else { ++ /* first read */ + u64 val; + ret = attr->get(attr->data, &val); + if (ret) +diff --git a/fs/nfs/client.c b/fs/nfs/client.c +index 0a2b59c1ecb3..07c5ddd5d6d5 100644 +--- a/fs/nfs/client.c ++++ b/fs/nfs/client.c +@@ -157,6 +157,7 @@ struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init) + if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL) + goto error_0; + ++ clp->cl_minorversion = cl_init->minorversion; + clp->cl_nfs_mod = cl_init->nfs_mod; + if (!try_module_get(clp->cl_nfs_mod->owner)) + goto error_dealloc; +diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c +index a7bc4e0494f9..6f45b1a95739 100644 +--- a/fs/nfs/fscache.c ++++ b/fs/nfs/fscache.c +@@ -35,6 +35,7 @@ static DEFINE_SPINLOCK(nfs_fscache_keys_lock); + struct nfs_server_key { + struct { + uint16_t nfsversion; /* NFS protocol version */ ++ uint32_t minorversion; /* NFSv4 minor version */ + uint16_t family; /* address family */ + __be16 port; /* IP port */ + } hdr; +@@ -59,6 +60,7 @@ void nfs_fscache_get_client_cookie(struct nfs_client *clp) + + memset(&key, 0, sizeof(key)); + key.hdr.nfsversion = clp->rpc_ops->version; ++ key.hdr.minorversion = clp->cl_minorversion; + key.hdr.family = clp->cl_addr.ss_family; + + switch (clp->cl_addr.ss_family) { +diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c +index 86991bcfbeb1..faaabbedc891 100644 +--- a/fs/nfs/nfs4client.c ++++ b/fs/nfs/nfs4client.c +@@ -210,7 +210,6 @@ struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) + INIT_LIST_HEAD(&clp->cl_ds_clients); + rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client"); + clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED; +- clp->cl_minorversion = cl_init->minorversion; + clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion]; + clp->cl_mig_gen = 1; + #if IS_ENABLED(CONFIG_NFS_V4_1) +diff --git a/include/linux/ceph/osdmap.h b/include/linux/ceph/osdmap.h +index 5675b1f09bc5..43fdadeb22da 100644 +--- a/include/linux/ceph/osdmap.h ++++ b/include/linux/ceph/osdmap.h +@@ -37,6 +37,9 @@ int ceph_spg_compare(const struct ceph_spg *lhs, const struct ceph_spg *rhs); + #define CEPH_POOL_FLAG_HASHPSPOOL (1ULL << 0) /* hash pg seed and pool id + together */ + #define CEPH_POOL_FLAG_FULL (1ULL << 1) /* pool is full */ ++#define CEPH_POOL_FLAG_FULL_QUOTA (1ULL << 10) /* pool ran out of quota, ++ will set FULL too */ ++#define CEPH_POOL_FLAG_NEARFULL (1ULL << 11) /* pool is nearfull */ + + struct ceph_pg_pool_info { + struct rb_node node; +@@ -305,5 +308,6 @@ extern struct ceph_pg_pool_info *ceph_pg_pool_by_id(struct ceph_osdmap *map, + + extern const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id); + extern int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name); ++u64 ceph_pg_pool_flags(struct ceph_osdmap *map, u64 id); + + #endif +diff --git a/include/linux/ceph/rados.h b/include/linux/ceph/rados.h +index f1988387c5ad..f6026bf4d8f4 100644 +--- a/include/linux/ceph/rados.h ++++ b/include/linux/ceph/rados.h +@@ -143,8 +143,10 @@ extern const char *ceph_osd_state_name(int s); + /* + * osd map flag bits + */ +-#define CEPH_OSDMAP_NEARFULL (1<<0) /* sync writes (near ENOSPC) */ +-#define CEPH_OSDMAP_FULL (1<<1) /* no data writes (ENOSPC) */ ++#define CEPH_OSDMAP_NEARFULL (1<<0) /* sync writes (near ENOSPC), ++ not set since ~luminous */ ++#define CEPH_OSDMAP_FULL (1<<1) /* no data writes (ENOSPC), ++ not set since ~luminous */ + #define CEPH_OSDMAP_PAUSERD (1<<2) /* pause all reads */ + #define CEPH_OSDMAP_PAUSEWR (1<<3) /* pause all writes */ + #define CEPH_OSDMAP_PAUSEREC (1<<4) /* pause recovery */ +diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h +index 840462ed1ec7..7e8e5b20e82b 100644 +--- a/include/linux/mmc/host.h ++++ b/include/linux/mmc/host.h +@@ -332,6 +332,7 @@ struct mmc_host { + MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | \ + MMC_CAP_UHS_DDR50) + /* (1 << 21) is free for reuse */ ++#define MMC_CAP_NEED_RSP_BUSY (1 << 22) /* Commands with R1B can't use R1. */ + #define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */ + #define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */ + #define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */ +diff --git a/include/linux/selection.h b/include/linux/selection.h +index a8f5b97b216f..77a1fb7c3fd5 100644 +--- a/include/linux/selection.h ++++ b/include/linux/selection.h +@@ -13,8 +13,8 @@ + + struct tty_struct; + +-extern struct vc_data *sel_cons; + struct tty_struct; ++struct vc_data; + + extern void clear_selection(void); + extern int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *tty); +@@ -23,6 +23,8 @@ extern int sel_loadlut(char __user *p); + extern int mouse_reporting(void); + extern void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry); + ++bool vc_is_sel(struct vc_data *vc); ++ + extern int console_blanked; + + extern const unsigned char color_table[]; +diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h +index 3fd07912909c..a3de234d3350 100644 +--- a/include/linux/vt_kern.h ++++ b/include/linux/vt_kern.h +@@ -142,7 +142,7 @@ static inline bool vt_force_oops_output(struct vc_data *vc) + return false; + } + +-extern char vt_dont_switch; ++extern bool vt_dont_switch; + extern int default_utf8; + extern int global_cursor_default; + +diff --git a/include/trace/events/afs.h b/include/trace/events/afs.h +index d0a341bc4540..5bc2e30c0d75 100644 +--- a/include/trace/events/afs.h ++++ b/include/trace/events/afs.h +@@ -94,7 +94,7 @@ enum afs_edit_dir_reason { + EM(afs_call_trace_free, "FREE ") \ + EM(afs_call_trace_put, "PUT ") \ + EM(afs_call_trace_wake, "WAKE ") \ +- E_(afs_call_trace_work, "WORK ") ++ E_(afs_call_trace_work, "QUEUE") + + #define afs_fs_operations \ + EM(afs_FS_FetchData, "FS.FetchData") \ +diff --git a/include/uapi/linux/serio.h b/include/uapi/linux/serio.h +index a0cac1d8670d..1937915be413 100644 +--- a/include/uapi/linux/serio.h ++++ b/include/uapi/linux/serio.h +@@ -9,7 +9,7 @@ + #ifndef _UAPI_SERIO_H + #define _UAPI_SERIO_H + +- ++#include <linux/const.h> + #include <linux/ioctl.h> + + #define SPIOCSTYPE _IOW('q', 0x01, unsigned long) +@@ -18,10 +18,10 @@ + /* + * bit masks for use in "interrupt" flags (3rd argument) + */ +-#define SERIO_TIMEOUT BIT(0) +-#define SERIO_PARITY BIT(1) +-#define SERIO_FRAME BIT(2) +-#define SERIO_OOB_DATA BIT(3) ++#define SERIO_TIMEOUT _BITUL(0) ++#define SERIO_PARITY _BITUL(1) ++#define SERIO_FRAME _BITUL(2) ++#define SERIO_OOB_DATA _BITUL(3) + + /* + * Serio types +diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c +index 3e2413345e71..471cc5c117a5 100644 +--- a/kernel/bpf/btf.c ++++ b/kernel/bpf/btf.c +@@ -1763,7 +1763,7 @@ static int btf_enum_check_member(struct btf_verifier_env *env, + + struct_size = struct_type->size; + bytes_offset = BITS_ROUNDDOWN_BYTES(struct_bits_off); +- if (struct_size - bytes_offset < sizeof(int)) { ++ if (struct_size - bytes_offset < member_type->size) { + btf_verifier_log_member(env, struct_type, member, + "Member exceeds struct_size"); + return -EINVAL; +@@ -2387,7 +2387,7 @@ int btf_get_info_by_fd(const struct btf *btf, + union bpf_attr __user *uattr) + { + struct bpf_btf_info __user *uinfo; +- struct bpf_btf_info info = {}; ++ struct bpf_btf_info info; + u32 info_copy, btf_copy; + void __user *ubtf; + u32 uinfo_len; +@@ -2396,6 +2396,7 @@ int btf_get_info_by_fd(const struct btf *btf, + uinfo_len = attr->info.info_len; + + info_copy = min_t(u32, uinfo_len, sizeof(info)); ++ memset(&info, 0, sizeof(info)); + if (copy_from_user(&info, uinfo, info_copy)) + return -EFAULT; + +diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c +index 596959288eb9..b766265cf37d 100644 +--- a/kernel/bpf/syscall.c ++++ b/kernel/bpf/syscall.c +@@ -1958,7 +1958,7 @@ static int bpf_prog_get_info_by_fd(struct bpf_prog *prog, + union bpf_attr __user *uattr) + { + struct bpf_prog_info __user *uinfo = u64_to_user_ptr(attr->info.info); +- struct bpf_prog_info info = {}; ++ struct bpf_prog_info info; + u32 info_len = attr->info.info_len; + char __user *uinsns; + u32 ulen; +@@ -1969,6 +1969,7 @@ static int bpf_prog_get_info_by_fd(struct bpf_prog *prog, + return err; + info_len = min_t(u32, sizeof(info), info_len); + ++ memset(&info, 0, sizeof(info)); + if (copy_from_user(&info, uinfo, info_len)) + return -EFAULT; + +@@ -2136,7 +2137,7 @@ static int bpf_map_get_info_by_fd(struct bpf_map *map, + union bpf_attr __user *uattr) + { + struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info); +- struct bpf_map_info info = {}; ++ struct bpf_map_info info; + u32 info_len = attr->info.info_len; + int err; + +@@ -2145,6 +2146,7 @@ static int bpf_map_get_info_by_fd(struct bpf_map *map, + return err; + info_len = min_t(u32, sizeof(info), info_len); + ++ memset(&info, 0, sizeof(info)); + info.type = map->map_type; + info.id = map->id; + info.key_size = map->key_size; +@@ -2372,7 +2374,7 @@ out: + + SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size) + { +- union bpf_attr attr = {}; ++ union bpf_attr attr; + int err; + + if (sysctl_unprivileged_bpf_disabled && !capable(CAP_SYS_ADMIN)) +@@ -2384,6 +2386,7 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz + size = min_t(u32, size, sizeof(attr)); + + /* copy attributes from user space, may be less than sizeof(bpf_attr) */ ++ memset(&attr, 0, sizeof(attr)); + if (copy_from_user(&attr, uattr, size) != 0) + return -EFAULT; + +diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c +index 51063e7a93c2..dd8bdbfbbde1 100644 +--- a/kernel/cgroup/cgroup-v1.c ++++ b/kernel/cgroup/cgroup-v1.c +@@ -501,6 +501,7 @@ static void *cgroup_pidlist_next(struct seq_file *s, void *v, loff_t *pos) + */ + p++; + if (p >= end) { ++ (*pos)++; + return NULL; + } else { + *pos = *p; +@@ -811,7 +812,7 @@ void cgroup1_release_agent(struct work_struct *work) + + pathbuf = kmalloc(PATH_MAX, GFP_KERNEL); + agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL); +- if (!pathbuf || !agentbuf) ++ if (!pathbuf || !agentbuf || !strlen(agentbuf)) + goto out; + + spin_lock_irq(&css_set_lock); +diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c +index eb69b805f908..efcb54ee0922 100644 +--- a/kernel/irq/manage.c ++++ b/kernel/irq/manage.c +@@ -283,7 +283,11 @@ int irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask, + + if (desc->affinity_notify) { + kref_get(&desc->affinity_notify->kref); +- schedule_work(&desc->affinity_notify->work); ++ if (!schedule_work(&desc->affinity_notify->work)) { ++ /* Work was already scheduled, drop our extra ref */ ++ kref_put(&desc->affinity_notify->kref, ++ desc->affinity_notify->release); ++ } + } + irqd_set(data, IRQD_AFFINITY_SET); + +@@ -383,7 +387,10 @@ irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify) + raw_spin_unlock_irqrestore(&desc->lock, flags); + + if (old_notify) { +- cancel_work_sync(&old_notify->work); ++ if (cancel_work_sync(&old_notify->work)) { ++ /* Pending work had a ref, put that one too */ ++ kref_put(&old_notify->kref, old_notify->release); ++ } + kref_put(&old_notify->kref, old_notify->release); + } + +diff --git a/net/ceph/osdmap.c b/net/ceph/osdmap.c +index 98c0ff3d6441..7cb6025fe092 100644 +--- a/net/ceph/osdmap.c ++++ b/net/ceph/osdmap.c +@@ -711,6 +711,15 @@ int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name) + } + EXPORT_SYMBOL(ceph_pg_poolid_by_name); + ++u64 ceph_pg_pool_flags(struct ceph_osdmap *map, u64 id) ++{ ++ struct ceph_pg_pool_info *pi; ++ ++ pi = __lookup_pg_pool(&map->pg_pools, id); ++ return pi ? pi->flags : 0; ++} ++EXPORT_SYMBOL(ceph_pg_pool_flags); ++ + static void __remove_pg_pool(struct rb_root *root, struct ceph_pg_pool_info *pi) + { + rb_erase(&pi->node, root); +diff --git a/net/dsa/tag_brcm.c b/net/dsa/tag_brcm.c +index 2b06bb91318b..2709bddef7d5 100644 +--- a/net/dsa/tag_brcm.c ++++ b/net/dsa/tag_brcm.c +@@ -141,6 +141,8 @@ static struct sk_buff *brcm_tag_rcv_ll(struct sk_buff *skb, + /* Remove Broadcom tag and update checksum */ + skb_pull_rcsum(skb, BRCM_TAG_LEN); + ++ skb->offload_fwd_mark = 1; ++ + return skb; + } + +diff --git a/net/hsr/hsr_framereg.c b/net/hsr/hsr_framereg.c +index 9af16cb68f76..f5a3601948ca 100644 +--- a/net/hsr/hsr_framereg.c ++++ b/net/hsr/hsr_framereg.c +@@ -466,13 +466,9 @@ int hsr_get_node_data(struct hsr_priv *hsr, + struct hsr_port *port; + unsigned long tdiff; + +- +- rcu_read_lock(); + node = find_node_by_AddrA(&hsr->node_db, addr); +- if (!node) { +- rcu_read_unlock(); +- return -ENOENT; /* No such entry */ +- } ++ if (!node) ++ return -ENOENT; + + ether_addr_copy(addr_b, node->MacAddressB); + +@@ -507,7 +503,5 @@ int hsr_get_node_data(struct hsr_priv *hsr, + *addr_b_ifindex = -1; + } + +- rcu_read_unlock(); +- + return 0; + } +diff --git a/net/hsr/hsr_netlink.c b/net/hsr/hsr_netlink.c +index b9cce0fd5696..37708dabebd1 100644 +--- a/net/hsr/hsr_netlink.c ++++ b/net/hsr/hsr_netlink.c +@@ -259,17 +259,16 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info) + if (!na) + goto invalid; + +- hsr_dev = __dev_get_by_index(genl_info_net(info), +- nla_get_u32(info->attrs[HSR_A_IFINDEX])); ++ rcu_read_lock(); ++ hsr_dev = dev_get_by_index_rcu(genl_info_net(info), ++ nla_get_u32(info->attrs[HSR_A_IFINDEX])); + if (!hsr_dev) +- goto invalid; ++ goto rcu_unlock; + if (!is_hsr_master(hsr_dev)) +- goto invalid; +- ++ goto rcu_unlock; + + /* Send reply */ +- +- skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); ++ skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC); + if (!skb_out) { + res = -ENOMEM; + goto fail; +@@ -321,12 +320,10 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info) + res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq); + if (res < 0) + goto nla_put_failure; +- rcu_read_lock(); + port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A); + if (port) + res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX, + port->dev->ifindex); +- rcu_read_unlock(); + if (res < 0) + goto nla_put_failure; + +@@ -336,20 +333,22 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info) + res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq); + if (res < 0) + goto nla_put_failure; +- rcu_read_lock(); + port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B); + if (port) + res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX, + port->dev->ifindex); +- rcu_read_unlock(); + if (res < 0) + goto nla_put_failure; + ++ rcu_read_unlock(); ++ + genlmsg_end(skb_out, msg_head); + genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid); + + return 0; + ++rcu_unlock: ++ rcu_read_unlock(); + invalid: + netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL); + return 0; +@@ -359,6 +358,7 @@ nla_put_failure: + /* Fall through */ + + fail: ++ rcu_read_unlock(); + return res; + } + +@@ -366,16 +366,14 @@ fail: + */ + static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info) + { +- /* For receiving */ +- struct nlattr *na; ++ unsigned char addr[ETH_ALEN]; + struct net_device *hsr_dev; +- +- /* For sending */ + struct sk_buff *skb_out; +- void *msg_head; + struct hsr_priv *hsr; +- void *pos; +- unsigned char addr[ETH_ALEN]; ++ bool restart = false; ++ struct nlattr *na; ++ void *pos = NULL; ++ void *msg_head; + int res; + + if (!info) +@@ -385,17 +383,17 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info) + if (!na) + goto invalid; + +- hsr_dev = __dev_get_by_index(genl_info_net(info), +- nla_get_u32(info->attrs[HSR_A_IFINDEX])); ++ rcu_read_lock(); ++ hsr_dev = dev_get_by_index_rcu(genl_info_net(info), ++ nla_get_u32(info->attrs[HSR_A_IFINDEX])); + if (!hsr_dev) +- goto invalid; ++ goto rcu_unlock; + if (!is_hsr_master(hsr_dev)) +- goto invalid; +- ++ goto rcu_unlock; + ++restart: + /* Send reply */ +- +- skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); ++ skb_out = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC); + if (!skb_out) { + res = -ENOMEM; + goto fail; +@@ -409,18 +407,26 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info) + goto nla_put_failure; + } + +- res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex); +- if (res < 0) +- goto nla_put_failure; ++ if (!restart) { ++ res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex); ++ if (res < 0) ++ goto nla_put_failure; ++ } + + hsr = netdev_priv(hsr_dev); + +- rcu_read_lock(); +- pos = hsr_get_next_node(hsr, NULL, addr); ++ if (!pos) ++ pos = hsr_get_next_node(hsr, NULL, addr); + while (pos) { + res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr); + if (res < 0) { +- rcu_read_unlock(); ++ if (res == -EMSGSIZE) { ++ genlmsg_end(skb_out, msg_head); ++ genlmsg_unicast(genl_info_net(info), skb_out, ++ info->snd_portid); ++ restart = true; ++ goto restart; ++ } + goto nla_put_failure; + } + pos = hsr_get_next_node(hsr, pos, addr); +@@ -432,15 +438,18 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info) + + return 0; + ++rcu_unlock: ++ rcu_read_unlock(); + invalid: + netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL); + return 0; + + nla_put_failure: +- kfree_skb(skb_out); ++ nlmsg_free(skb_out); + /* Fall through */ + + fail: ++ rcu_read_unlock(); + return res; + } + +@@ -467,6 +476,7 @@ static struct genl_family hsr_genl_family __ro_after_init = { + .name = "HSR", + .version = 1, + .maxattr = HSR_A_MAX, ++ .netnsok = true, + .module = THIS_MODULE, + .ops = hsr_ops, + .n_ops = ARRAY_SIZE(hsr_ops), +diff --git a/net/hsr/hsr_slave.c b/net/hsr/hsr_slave.c +index 5fee6ec7c93d..b215df0bce0e 100644 +--- a/net/hsr/hsr_slave.c ++++ b/net/hsr/hsr_slave.c +@@ -152,16 +152,16 @@ int hsr_add_port(struct hsr_priv *hsr, struct net_device *dev, + if (port == NULL) + return -ENOMEM; + ++ port->hsr = hsr; ++ port->dev = dev; ++ port->type = type; ++ + if (type != HSR_PT_MASTER) { + res = hsr_portdev_setup(dev, port); + if (res) + goto fail_dev_setup; + } + +- port->hsr = hsr; +- port->dev = dev; +- port->type = type; +- + list_add_tail_rcu(&port->port_list, &hsr->ports); + synchronize_rcu(); + +diff --git a/net/ipv4/Kconfig b/net/ipv4/Kconfig +index 32cae39cdff6..2e12f848203a 100644 +--- a/net/ipv4/Kconfig ++++ b/net/ipv4/Kconfig +@@ -302,6 +302,7 @@ config SYN_COOKIES + + config NET_IPVTI + tristate "Virtual (secure) IP: tunneling" ++ depends on IPV6 || IPV6=n + select INET_TUNNEL + select NET_IP_TUNNEL + depends on INET_XFRM_MODE_TUNNEL +diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c +index a3f77441f3e6..ffcb5983107d 100644 +--- a/net/ipv4/ip_gre.c ++++ b/net/ipv4/ip_gre.c +@@ -1226,6 +1226,24 @@ static int ipgre_netlink_parms(struct net_device *dev, + if (data[IFLA_GRE_FWMARK]) + *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]); + ++ return 0; ++} ++ ++static int erspan_netlink_parms(struct net_device *dev, ++ struct nlattr *data[], ++ struct nlattr *tb[], ++ struct ip_tunnel_parm *parms, ++ __u32 *fwmark) ++{ ++ struct ip_tunnel *t = netdev_priv(dev); ++ int err; ++ ++ err = ipgre_netlink_parms(dev, data, tb, parms, fwmark); ++ if (err) ++ return err; ++ if (!data) ++ return 0; ++ + if (data[IFLA_GRE_ERSPAN_VER]) { + t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]); + +@@ -1355,45 +1373,70 @@ bool is_gretap_dev(const struct net_device *dev) + } + EXPORT_SYMBOL_GPL(is_gretap_dev); + +-static int ipgre_newlink(struct net *src_net, struct net_device *dev, +- struct nlattr *tb[], struct nlattr *data[], +- struct netlink_ext_ack *extack) ++static int ++ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[]) + { +- struct ip_tunnel_parm p; + struct ip_tunnel_encap ipencap; +- __u32 fwmark = 0; +- int err; + + if (ipgre_netlink_encap_parms(data, &ipencap)) { + struct ip_tunnel *t = netdev_priv(dev); +- err = ip_tunnel_encap_setup(t, &ipencap); ++ int err = ip_tunnel_encap_setup(t, &ipencap); + + if (err < 0) + return err; + } + ++ return 0; ++} ++ ++static int ipgre_newlink(struct net *src_net, struct net_device *dev, ++ struct nlattr *tb[], struct nlattr *data[], ++ struct netlink_ext_ack *extack) ++{ ++ struct ip_tunnel_parm p; ++ __u32 fwmark = 0; ++ int err; ++ ++ err = ipgre_newlink_encap_setup(dev, data); ++ if (err) ++ return err; ++ + err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark); + if (err < 0) + return err; + return ip_tunnel_newlink(dev, tb, &p, fwmark); + } + ++static int erspan_newlink(struct net *src_net, struct net_device *dev, ++ struct nlattr *tb[], struct nlattr *data[], ++ struct netlink_ext_ack *extack) ++{ ++ struct ip_tunnel_parm p; ++ __u32 fwmark = 0; ++ int err; ++ ++ err = ipgre_newlink_encap_setup(dev, data); ++ if (err) ++ return err; ++ ++ err = erspan_netlink_parms(dev, data, tb, &p, &fwmark); ++ if (err) ++ return err; ++ return ip_tunnel_newlink(dev, tb, &p, fwmark); ++} ++ + static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[], + struct nlattr *data[], + struct netlink_ext_ack *extack) + { + struct ip_tunnel *t = netdev_priv(dev); +- struct ip_tunnel_encap ipencap; + __u32 fwmark = t->fwmark; + struct ip_tunnel_parm p; + int err; + +- if (ipgre_netlink_encap_parms(data, &ipencap)) { +- err = ip_tunnel_encap_setup(t, &ipencap); +- +- if (err < 0) +- return err; +- } ++ err = ipgre_newlink_encap_setup(dev, data); ++ if (err) ++ return err; + + err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark); + if (err < 0) +@@ -1406,8 +1449,34 @@ static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[], + t->parms.i_flags = p.i_flags; + t->parms.o_flags = p.o_flags; + +- if (strcmp(dev->rtnl_link_ops->kind, "erspan")) +- ipgre_link_update(dev, !tb[IFLA_MTU]); ++ ipgre_link_update(dev, !tb[IFLA_MTU]); ++ ++ return 0; ++} ++ ++static int erspan_changelink(struct net_device *dev, struct nlattr *tb[], ++ struct nlattr *data[], ++ struct netlink_ext_ack *extack) ++{ ++ struct ip_tunnel *t = netdev_priv(dev); ++ __u32 fwmark = t->fwmark; ++ struct ip_tunnel_parm p; ++ int err; ++ ++ err = ipgre_newlink_encap_setup(dev, data); ++ if (err) ++ return err; ++ ++ err = erspan_netlink_parms(dev, data, tb, &p, &fwmark); ++ if (err < 0) ++ return err; ++ ++ err = ip_tunnel_changelink(dev, tb, &p, fwmark); ++ if (err < 0) ++ return err; ++ ++ t->parms.i_flags = p.i_flags; ++ t->parms.o_flags = p.o_flags; + + return 0; + } +@@ -1598,8 +1667,8 @@ static struct rtnl_link_ops erspan_link_ops __read_mostly = { + .priv_size = sizeof(struct ip_tunnel), + .setup = erspan_setup, + .validate = erspan_validate, +- .newlink = ipgre_newlink, +- .changelink = ipgre_changelink, ++ .newlink = erspan_newlink, ++ .changelink = erspan_changelink, + .dellink = ip_tunnel_dellink, + .get_size = ipgre_get_size, + .fill_info = ipgre_fill_info, +diff --git a/net/ipv4/ip_vti.c b/net/ipv4/ip_vti.c +index f5e5fcd90859..ccb1d97dfa05 100644 +--- a/net/ipv4/ip_vti.c ++++ b/net/ipv4/ip_vti.c +@@ -208,17 +208,39 @@ static netdev_tx_t vti_xmit(struct sk_buff *skb, struct net_device *dev, + int mtu; + + if (!dst) { +- struct rtable *rt; +- +- fl->u.ip4.flowi4_oif = dev->ifindex; +- fl->u.ip4.flowi4_flags |= FLOWI_FLAG_ANYSRC; +- rt = __ip_route_output_key(dev_net(dev), &fl->u.ip4); +- if (IS_ERR(rt)) { ++ switch (skb->protocol) { ++ case htons(ETH_P_IP): { ++ struct rtable *rt; ++ ++ fl->u.ip4.flowi4_oif = dev->ifindex; ++ fl->u.ip4.flowi4_flags |= FLOWI_FLAG_ANYSRC; ++ rt = __ip_route_output_key(dev_net(dev), &fl->u.ip4); ++ if (IS_ERR(rt)) { ++ dev->stats.tx_carrier_errors++; ++ goto tx_error_icmp; ++ } ++ dst = &rt->dst; ++ skb_dst_set(skb, dst); ++ break; ++ } ++#if IS_ENABLED(CONFIG_IPV6) ++ case htons(ETH_P_IPV6): ++ fl->u.ip6.flowi6_oif = dev->ifindex; ++ fl->u.ip6.flowi6_flags |= FLOWI_FLAG_ANYSRC; ++ dst = ip6_route_output(dev_net(dev), NULL, &fl->u.ip6); ++ if (dst->error) { ++ dst_release(dst); ++ dst = NULL; ++ dev->stats.tx_carrier_errors++; ++ goto tx_error_icmp; ++ } ++ skb_dst_set(skb, dst); ++ break; ++#endif ++ default: + dev->stats.tx_carrier_errors++; + goto tx_error_icmp; + } +- dst = &rt->dst; +- skb_dst_set(skb, dst); + } + + dst_hold(dst); +diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c +index 34fda81c7db0..54dda47a9a56 100644 +--- a/net/ipv4/tcp.c ++++ b/net/ipv4/tcp.c +@@ -2870,8 +2870,10 @@ static int do_tcp_setsockopt(struct sock *sk, int level, + err = -EPERM; + else if (tp->repair_queue == TCP_SEND_QUEUE) + tp->write_seq = val; +- else if (tp->repair_queue == TCP_RECV_QUEUE) ++ else if (tp->repair_queue == TCP_RECV_QUEUE) { + WRITE_ONCE(tp->rcv_nxt, val); ++ WRITE_ONCE(tp->copied_seq, val); ++ } + else + err = -EINVAL; + break; +diff --git a/net/ipv6/ip6_vti.c b/net/ipv6/ip6_vti.c +index 67ff206b6d61..94f16e82a458 100644 +--- a/net/ipv6/ip6_vti.c ++++ b/net/ipv6/ip6_vti.c +@@ -315,7 +315,7 @@ static int vti6_rcv(struct sk_buff *skb) + + if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) { + rcu_read_unlock(); +- return 0; ++ goto discard; + } + + ipv6h = ipv6_hdr(skb); +@@ -454,15 +454,33 @@ vti6_xmit(struct sk_buff *skb, struct net_device *dev, struct flowi *fl) + int mtu; + + if (!dst) { +- fl->u.ip6.flowi6_oif = dev->ifindex; +- fl->u.ip6.flowi6_flags |= FLOWI_FLAG_ANYSRC; +- dst = ip6_route_output(dev_net(dev), NULL, &fl->u.ip6); +- if (dst->error) { +- dst_release(dst); +- dst = NULL; ++ switch (skb->protocol) { ++ case htons(ETH_P_IP): { ++ struct rtable *rt; ++ ++ fl->u.ip4.flowi4_oif = dev->ifindex; ++ fl->u.ip4.flowi4_flags |= FLOWI_FLAG_ANYSRC; ++ rt = __ip_route_output_key(dev_net(dev), &fl->u.ip4); ++ if (IS_ERR(rt)) ++ goto tx_err_link_failure; ++ dst = &rt->dst; ++ skb_dst_set(skb, dst); ++ break; ++ } ++ case htons(ETH_P_IPV6): ++ fl->u.ip6.flowi6_oif = dev->ifindex; ++ fl->u.ip6.flowi6_flags |= FLOWI_FLAG_ANYSRC; ++ dst = ip6_route_output(dev_net(dev), NULL, &fl->u.ip6); ++ if (dst->error) { ++ dst_release(dst); ++ dst = NULL; ++ goto tx_err_link_failure; ++ } ++ skb_dst_set(skb, dst); ++ break; ++ default: + goto tx_err_link_failure; + } +- skb_dst_set(skb, dst); + } + + dst_hold(dst); +diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h +index cfd30671ccdf..a879d8071712 100644 +--- a/net/mac80211/ieee80211_i.h ++++ b/net/mac80211/ieee80211_i.h +@@ -1729,7 +1729,8 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb, + struct net_device *dev); + void __ieee80211_subif_start_xmit(struct sk_buff *skb, + struct net_device *dev, +- u32 info_flags); ++ u32 info_flags, ++ u32 ctrl_flags); + void ieee80211_purge_tx_queue(struct ieee80211_hw *hw, + struct sk_buff_head *skbs); + struct sk_buff * +diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c +index 740dc9fa127c..433d136282de 100644 +--- a/net/mac80211/mesh_hwmp.c ++++ b/net/mac80211/mesh_hwmp.c +@@ -1137,7 +1137,8 @@ int mesh_nexthop_resolve(struct ieee80211_sub_if_data *sdata, + } + } + +- if (!(mpath->flags & MESH_PATH_RESOLVING)) ++ if (!(mpath->flags & MESH_PATH_RESOLVING) && ++ mesh_path_sel_is_hwmp(sdata)) + mesh_queue_preq(mpath, PREQ_Q_F_START); + + if (skb_queue_len(&mpath->frame_queue) >= MESH_FRAME_QUEUE_LEN) +diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c +index 0c80a59ef914..ec2e83272f9d 100644 +--- a/net/mac80211/sta_info.c ++++ b/net/mac80211/sta_info.c +@@ -3,7 +3,7 @@ + * Copyright 2006-2007 Jiri Benc <[email protected]> + * Copyright 2013-2014 Intel Mobile Communications GmbH + * Copyright (C) 2015 - 2017 Intel Deutschland GmbH +- * Copyright (C) 2018 Intel Corporation ++ * Copyright (C) 2018-2020 Intel Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as +@@ -979,6 +979,11 @@ static void __sta_info_destroy_part2(struct sta_info *sta) + might_sleep(); + lockdep_assert_held(&local->sta_mtx); + ++ while (sta->sta_state == IEEE80211_STA_AUTHORIZED) { ++ ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC); ++ WARN_ON_ONCE(ret); ++ } ++ + /* now keys can no longer be reached */ + ieee80211_free_sta_keys(local, sta); + +diff --git a/net/mac80211/tdls.c b/net/mac80211/tdls.c +index 67745d1d4c5d..aa6fabfed3a7 100644 +--- a/net/mac80211/tdls.c ++++ b/net/mac80211/tdls.c +@@ -1055,7 +1055,7 @@ ieee80211_tdls_prep_mgmt_packet(struct wiphy *wiphy, struct net_device *dev, + + /* disable bottom halves when entering the Tx path */ + local_bh_disable(); +- __ieee80211_subif_start_xmit(skb, dev, flags); ++ __ieee80211_subif_start_xmit(skb, dev, flags, 0); + local_bh_enable(); + + return ret; +diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c +index 2f726cde9998..84639363173b 100644 +--- a/net/mac80211/tx.c ++++ b/net/mac80211/tx.c +@@ -4,7 +4,7 @@ + * Copyright 2006-2007 Jiri Benc <[email protected]> + * Copyright 2007 Johannes Berg <[email protected]> + * Copyright 2013-2014 Intel Mobile Communications GmbH +- * Copyright (C) 2018 Intel Corporation ++ * Copyright (C) 2018, 2020 Intel Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as +@@ -2399,6 +2399,7 @@ static int ieee80211_lookup_ra_sta(struct ieee80211_sub_if_data *sdata, + * @sdata: virtual interface to build the header for + * @skb: the skb to build the header in + * @info_flags: skb flags to set ++ * @ctrl_flags: info control flags to set + * + * This function takes the skb with 802.3 header and reformats the header to + * the appropriate IEEE 802.11 header based on which interface the packet is +@@ -2414,7 +2415,7 @@ static int ieee80211_lookup_ra_sta(struct ieee80211_sub_if_data *sdata, + */ + static struct sk_buff *ieee80211_build_hdr(struct ieee80211_sub_if_data *sdata, + struct sk_buff *skb, u32 info_flags, +- struct sta_info *sta) ++ struct sta_info *sta, u32 ctrl_flags) + { + struct ieee80211_local *local = sdata->local; + struct ieee80211_tx_info *info; +@@ -2786,6 +2787,7 @@ static struct sk_buff *ieee80211_build_hdr(struct ieee80211_sub_if_data *sdata, + info->flags = info_flags; + info->ack_frame_id = info_id; + info->band = band; ++ info->control.flags = ctrl_flags; + + return skb; + free: +@@ -3511,8 +3513,26 @@ begin: + tx.skb = skb; + tx.sdata = vif_to_sdata(info->control.vif); + +- if (txq->sta) ++ if (txq->sta) { + tx.sta = container_of(txq->sta, struct sta_info, sta); ++ /* ++ * Drop unicast frames to unauthorised stations unless they are ++ * EAPOL frames from the local station. ++ */ ++ if (unlikely(ieee80211_is_data(hdr->frame_control) && ++ !ieee80211_vif_is_mesh(&tx.sdata->vif) && ++ tx.sdata->vif.type != NL80211_IFTYPE_OCB && ++ !is_multicast_ether_addr(hdr->addr1) && ++ !test_sta_flag(tx.sta, WLAN_STA_AUTHORIZED) && ++ (!(info->control.flags & ++ IEEE80211_TX_CTRL_PORT_CTRL_PROTO) || ++ !ether_addr_equal(tx.sdata->vif.addr, ++ hdr->addr2)))) { ++ I802_DEBUG_INC(local->tx_handlers_drop_unauth_port); ++ ieee80211_free_txskb(&local->hw, skb); ++ goto begin; ++ } ++ } + + /* + * The key can be removed while the packet was queued, so need to call +@@ -3595,7 +3615,8 @@ EXPORT_SYMBOL(ieee80211_tx_dequeue); + + void __ieee80211_subif_start_xmit(struct sk_buff *skb, + struct net_device *dev, +- u32 info_flags) ++ u32 info_flags, ++ u32 ctrl_flags) + { + struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); + struct sta_info *sta; +@@ -3666,7 +3687,8 @@ void __ieee80211_subif_start_xmit(struct sk_buff *skb, + skb->prev = NULL; + skb->next = NULL; + +- skb = ieee80211_build_hdr(sdata, skb, info_flags, sta); ++ skb = ieee80211_build_hdr(sdata, skb, info_flags, ++ sta, ctrl_flags); + if (IS_ERR(skb)) + goto out; + +@@ -3806,9 +3828,9 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb, + __skb_queue_head_init(&queue); + ieee80211_convert_to_unicast(skb, dev, &queue); + while ((skb = __skb_dequeue(&queue))) +- __ieee80211_subif_start_xmit(skb, dev, 0); ++ __ieee80211_subif_start_xmit(skb, dev, 0, 0); + } else { +- __ieee80211_subif_start_xmit(skb, dev, 0); ++ __ieee80211_subif_start_xmit(skb, dev, 0, 0); + } + + return NETDEV_TX_OK; +@@ -3833,7 +3855,7 @@ ieee80211_build_data_template(struct ieee80211_sub_if_data *sdata, + goto out; + } + +- skb = ieee80211_build_hdr(sdata, skb, info_flags, sta); ++ skb = ieee80211_build_hdr(sdata, skb, info_flags, sta, 0); + if (IS_ERR(skb)) + goto out; + +@@ -4836,6 +4858,7 @@ int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev, + struct ieee80211_local *local = sdata->local; + struct sk_buff *skb; + struct ethhdr *ehdr; ++ u32 ctrl_flags = 0; + u32 flags; + + /* Only accept CONTROL_PORT_PROTOCOL configured in CONNECT/ASSOCIATE +@@ -4845,6 +4868,9 @@ int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev, + proto != cpu_to_be16(ETH_P_PREAUTH)) + return -EINVAL; + ++ if (proto == sdata->control_port_protocol) ++ ctrl_flags |= IEEE80211_TX_CTRL_PORT_CTRL_PROTO; ++ + if (unencrypted) + flags = IEEE80211_TX_INTFL_DONT_ENCRYPT; + else +@@ -4870,7 +4896,7 @@ int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev, + skb_reset_mac_header(skb); + + local_bh_disable(); +- __ieee80211_subif_start_xmit(skb, skb->dev, flags); ++ __ieee80211_subif_start_xmit(skb, skb->dev, flags, ctrl_flags); + local_bh_enable(); + + return 0; +diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c +index a8c9ea12c3f5..bd01edfe44ea 100644 +--- a/net/netfilter/nf_flow_table_ip.c ++++ b/net/netfilter/nf_flow_table_ip.c +@@ -188,6 +188,7 @@ static int nf_flow_tuple_ip(struct sk_buff *skb, const struct net_device *dev, + if (!pskb_may_pull(skb, thoff + sizeof(*ports))) + return -1; + ++ iph = ip_hdr(skb); + ports = (struct flow_ports *)(skb_network_header(skb) + thoff); + + tuple->src_v4.s_addr = iph->saddr; +@@ -421,6 +422,7 @@ static int nf_flow_tuple_ipv6(struct sk_buff *skb, const struct net_device *dev, + if (!pskb_may_pull(skb, thoff + sizeof(*ports))) + return -1; + ++ ip6h = ipv6_hdr(skb); + ports = (struct flow_ports *)(skb_network_header(skb) + thoff); + + tuple->src_v6 = ip6h->saddr; +diff --git a/net/netfilter/nft_fwd_netdev.c b/net/netfilter/nft_fwd_netdev.c +index 8abb9891cdf2..649edbe77a20 100644 +--- a/net/netfilter/nft_fwd_netdev.c ++++ b/net/netfilter/nft_fwd_netdev.c +@@ -186,6 +186,13 @@ nla_put_failure: + return -1; + } + ++static int nft_fwd_validate(const struct nft_ctx *ctx, ++ const struct nft_expr *expr, ++ const struct nft_data **data) ++{ ++ return nft_chain_validate_hooks(ctx->chain, (1 << NF_NETDEV_INGRESS)); ++} ++ + static struct nft_expr_type nft_fwd_netdev_type; + static const struct nft_expr_ops nft_fwd_neigh_netdev_ops = { + .type = &nft_fwd_netdev_type, +@@ -193,6 +200,7 @@ static const struct nft_expr_ops nft_fwd_neigh_netdev_ops = { + .eval = nft_fwd_neigh_eval, + .init = nft_fwd_neigh_init, + .dump = nft_fwd_neigh_dump, ++ .validate = nft_fwd_validate, + }; + + static const struct nft_expr_ops nft_fwd_netdev_ops = { +@@ -201,6 +209,7 @@ static const struct nft_expr_ops nft_fwd_netdev_ops = { + .eval = nft_fwd_netdev_eval, + .init = nft_fwd_netdev_init, + .dump = nft_fwd_netdev_dump, ++ .validate = nft_fwd_validate, + }; + + static const struct nft_expr_ops * +diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c +index ecea8edae61c..0e029aefa707 100644 +--- a/net/packet/af_packet.c ++++ b/net/packet/af_packet.c +@@ -2165,6 +2165,7 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, + struct timespec ts; + __u32 ts_status; + bool is_drop_n_account = false; ++ unsigned int slot_id = 0; + bool do_vnet = false; + + /* struct tpacket{2,3}_hdr is aligned to a multiple of TPACKET_ALIGNMENT. +@@ -2261,6 +2262,13 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, + if (!h.raw) + goto drop_n_account; + ++ if (po->tp_version <= TPACKET_V2) { ++ slot_id = po->rx_ring.head; ++ if (test_bit(slot_id, po->rx_ring.rx_owner_map)) ++ goto drop_n_account; ++ __set_bit(slot_id, po->rx_ring.rx_owner_map); ++ } ++ + if (do_vnet && + virtio_net_hdr_from_skb(skb, h.raw + macoff - + sizeof(struct virtio_net_hdr), +@@ -2366,7 +2374,10 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, + #endif + + if (po->tp_version <= TPACKET_V2) { ++ spin_lock(&sk->sk_receive_queue.lock); + __packet_set_status(po, h.raw, status); ++ __clear_bit(slot_id, po->rx_ring.rx_owner_map); ++ spin_unlock(&sk->sk_receive_queue.lock); + sk->sk_data_ready(sk); + } else { + prb_clear_blk_fill_status(&po->rx_ring); +@@ -4260,6 +4271,7 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, + { + struct pgv *pg_vec = NULL; + struct packet_sock *po = pkt_sk(sk); ++ unsigned long *rx_owner_map = NULL; + int was_running, order = 0; + struct packet_ring_buffer *rb; + struct sk_buff_head *rb_queue; +@@ -4345,6 +4357,12 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, + } + break; + default: ++ if (!tx_ring) { ++ rx_owner_map = bitmap_alloc(req->tp_frame_nr, ++ GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO); ++ if (!rx_owner_map) ++ goto out_free_pg_vec; ++ } + break; + } + } +@@ -4374,6 +4392,8 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, + err = 0; + spin_lock_bh(&rb_queue->lock); + swap(rb->pg_vec, pg_vec); ++ if (po->tp_version <= TPACKET_V2) ++ swap(rb->rx_owner_map, rx_owner_map); + rb->frame_max = (req->tp_frame_nr - 1); + rb->head = 0; + rb->frame_size = req->tp_frame_size; +@@ -4405,6 +4425,7 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, + } + + out_free_pg_vec: ++ bitmap_free(rx_owner_map); + if (pg_vec) + free_pg_vec(pg_vec, order, req->tp_block_nr); + out: +diff --git a/net/packet/internal.h b/net/packet/internal.h +index c70a2794456f..f10294800aaf 100644 +--- a/net/packet/internal.h ++++ b/net/packet/internal.h +@@ -70,7 +70,10 @@ struct packet_ring_buffer { + + unsigned int __percpu *pending_refcnt; + +- struct tpacket_kbdq_core prb_bdqc; ++ union { ++ unsigned long *rx_owner_map; ++ struct tpacket_kbdq_core prb_bdqc; ++ }; + }; + + extern struct mutex fanout_mutex; +diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c +index 37ae23db4a44..0256777b838e 100644 +--- a/net/sched/cls_route.c ++++ b/net/sched/cls_route.c +@@ -536,8 +536,8 @@ static int route4_change(struct net *net, struct sk_buff *in_skb, + fp = &b->ht[h]; + for (pfp = rtnl_dereference(*fp); pfp; + fp = &pfp->next, pfp = rtnl_dereference(*fp)) { +- if (pfp == f) { +- *fp = f->next; ++ if (pfp == fold) { ++ rcu_assign_pointer(*fp, fold->next); + break; + } + } +diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c +index db4b5d9ffaf7..0d7a0aac8dbb 100644 +--- a/net/sched/cls_tcindex.c ++++ b/net/sched/cls_tcindex.c +@@ -357,6 +357,7 @@ tcindex_set_parms(struct net *net, struct tcf_proto *tp, unsigned long base, + + if (tcindex_alloc_perfect_hash(net, cp) < 0) + goto errout; ++ cp->alloc_hash = cp->hash; + for (i = 0; i < min(cp->hash, p->hash); i++) + cp->perfect[i].res = p->perfect[i].res; + balloc = 1; +diff --git a/net/sched/sch_cbs.c b/net/sched/sch_cbs.c +index 940e72d6db18..d5e22452d597 100644 +--- a/net/sched/sch_cbs.c ++++ b/net/sched/sch_cbs.c +@@ -185,6 +185,11 @@ static struct sk_buff *cbs_dequeue_soft(struct Qdisc *sch) + s64 credits; + int len; + ++ /* The previous packet is still being sent */ ++ if (now < q->last) { ++ qdisc_watchdog_schedule_ns(&q->watchdog, q->last); ++ return NULL; ++ } + if (q->credits < 0) { + credits = timediff_to_credits(now - q->last, q->idleslope); + +@@ -216,7 +221,12 @@ static struct sk_buff *cbs_dequeue_soft(struct Qdisc *sch) + credits += q->credits; + + q->credits = max_t(s64, credits, q->locredit); +- q->last = now; ++ /* Estimate of the transmission of the last byte of the packet in ns */ ++ if (unlikely(atomic64_read(&q->port_rate) == 0)) ++ q->last = now; ++ else ++ q->last = now + div64_s64(len * NSEC_PER_SEC, ++ atomic64_read(&q->port_rate)); + + return skb; + } +diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c +index d502cc7a8ff7..0221849b7218 100644 +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -15607,7 +15607,7 @@ void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac, + goto nla_put_failure; + + if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) && +- nla_put_u8(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw)) ++ nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw)) + goto nla_put_failure; + + if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) && +diff --git a/net/xfrm/xfrm_device.c b/net/xfrm/xfrm_device.c +index 5611b7521020..8634ce677142 100644 +--- a/net/xfrm/xfrm_device.c ++++ b/net/xfrm/xfrm_device.c +@@ -332,6 +332,7 @@ static int xfrm_dev_event(struct notifier_block *this, unsigned long event, void + return xfrm_dev_feat_change(dev); + + case NETDEV_DOWN: ++ case NETDEV_UNREGISTER: + return xfrm_dev_down(dev); + } + return NOTIFY_DONE; +diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c +index ce1b262ce964..b30c074160e3 100644 +--- a/net/xfrm/xfrm_policy.c ++++ b/net/xfrm/xfrm_policy.c +@@ -309,7 +309,9 @@ EXPORT_SYMBOL(xfrm_policy_destroy); + + static void xfrm_policy_kill(struct xfrm_policy *policy) + { ++ write_lock_bh(&policy->lock); + policy->walk.dead = 1; ++ write_unlock_bh(&policy->lock); + + atomic_inc(&policy->genid); + +diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c +index 1484bc99a537..0b80c7907715 100644 +--- a/net/xfrm/xfrm_user.c ++++ b/net/xfrm/xfrm_user.c +@@ -109,7 +109,8 @@ static inline int verify_sec_ctx_len(struct nlattr **attrs) + return 0; + + uctx = nla_data(rt); +- if (uctx->len != (sizeof(struct xfrm_user_sec_ctx) + uctx->ctx_len)) ++ if (uctx->len > nla_len(rt) || ++ uctx->len != (sizeof(struct xfrm_user_sec_ctx) + uctx->ctx_len)) + return -EINVAL; + + return 0; +@@ -2272,6 +2273,9 @@ static int xfrm_add_acquire(struct sk_buff *skb, struct nlmsghdr *nlh, + xfrm_mark_get(attrs, &mark); + + err = verify_newpolicy_info(&ua->policy); ++ if (err) ++ goto free_state; ++ err = verify_sec_ctx_len(attrs); + if (err) + goto free_state; + +diff --git a/scripts/dtc/dtc-lexer.l b/scripts/dtc/dtc-lexer.l +index 615b7ec6588f..d3694d6cf202 100644 +--- a/scripts/dtc/dtc-lexer.l ++++ b/scripts/dtc/dtc-lexer.l +@@ -38,7 +38,6 @@ LINECOMMENT "//".*\n + #include "srcpos.h" + #include "dtc-parser.tab.h" + +-YYLTYPE yylloc; + extern bool treesource_error; + + /* CAUTION: this will stop working if we ever use yyless() or yyunput() */ +diff --git a/tools/perf/Makefile b/tools/perf/Makefile +index 7902a5681fc8..b8fc7d972be9 100644 +--- a/tools/perf/Makefile ++++ b/tools/perf/Makefile +@@ -35,7 +35,7 @@ endif + # Only pass canonical directory names as the output directory: + # + ifneq ($(O),) +- FULL_O := $(shell readlink -f $(O) || echo $(O)) ++ FULL_O := $(shell cd $(PWD); readlink -f $(O) || echo $(O)) + endif + + # +diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c +index 1117ab86ebd3..d3d3601f41cc 100644 +--- a/tools/perf/util/map.c ++++ b/tools/perf/util/map.c +@@ -85,7 +85,7 @@ static inline bool replace_android_lib(const char *filename, char *newfilename) + return true; + } + +- if (!strncmp(filename, "/system/lib/", 11)) { ++ if (!strncmp(filename, "/system/lib/", 12)) { + char *ndk, *app; + const char *arch; + size_t ndk_length; +diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c +index a6aaac24ce05..876787de7959 100644 +--- a/tools/perf/util/probe-finder.c ++++ b/tools/perf/util/probe-finder.c +@@ -623,14 +623,19 @@ static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod, + return -EINVAL; + } + +- /* Try to get actual symbol name from symtab */ +- symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL); ++ if (dwarf_entrypc(sp_die, &eaddr) == 0) { ++ /* If the DIE has entrypc, use it. */ ++ symbol = dwarf_diename(sp_die); ++ } else { ++ /* Try to get actual symbol name and address from symtab */ ++ symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL); ++ eaddr = sym.st_value; ++ } + if (!symbol) { + pr_warning("Failed to find symbol at 0x%lx\n", + (unsigned long)paddr); + return -ENOENT; + } +- eaddr = sym.st_value; + + tp->offset = (unsigned long)(paddr - eaddr); + tp->address = (unsigned long)paddr; +diff --git a/tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c b/tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c +index 2116df9ad832..c097a3748674 100644 +--- a/tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c ++++ b/tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c +@@ -83,7 +83,7 @@ static struct pci_access *pci_acc; + static struct pci_dev *amd_fam14h_pci_dev; + static int nbp1_entered; + +-struct timespec start_time; ++static struct timespec start_time; + static unsigned long long timediff; + + #ifdef DEBUG +diff --git a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c +index 5b8c4956ff9a..85a8f0cc01a1 100644 +--- a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c ++++ b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c +@@ -21,7 +21,7 @@ struct cpuidle_monitor cpuidle_sysfs_monitor; + + static unsigned long long **previous_count; + static unsigned long long **current_count; +-struct timespec start_time; ++static struct timespec start_time; + static unsigned long long timediff; + + static int cpuidle_get_count_percent(unsigned int id, double *percent, +diff --git a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c +index 051da0a7c454..4a27c55d50d8 100644 +--- a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c ++++ b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c +@@ -29,6 +29,8 @@ struct cpuidle_monitor *all_monitors[] = { + 0 + }; + ++int cpu_count; ++ + static struct cpuidle_monitor *monitors[MONITORS_MAX]; + static unsigned int avail_monitors; + +diff --git a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h +index 2ae50b499e0a..06b3cd6de018 100644 +--- a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h ++++ b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h +@@ -27,7 +27,7 @@ + #endif + #define CSTATE_DESC_LEN 60 + +-int cpu_count; ++extern int cpu_count; + + /* Hard to define the right names ...: */ + enum power_range_e { +diff --git a/tools/scripts/Makefile.include b/tools/scripts/Makefile.include +index 495066bafbe3..8fc6b1ca47dc 100644 +--- a/tools/scripts/Makefile.include ++++ b/tools/scripts/Makefile.include +@@ -1,8 +1,8 @@ + # SPDX-License-Identifier: GPL-2.0 + ifneq ($(O),) + ifeq ($(origin O), command line) +- dummy := $(if $(shell test -d $(O) || echo $(O)),$(error O=$(O) does not exist),) +- ABSOLUTE_O := $(shell cd $(O) ; pwd) ++ dummy := $(if $(shell cd $(PWD); test -d $(O) || echo $(O)),$(error O=$(O) does not exist),) ++ ABSOLUTE_O := $(shell cd $(PWD); cd $(O) ; pwd) + OUTPUT := $(ABSOLUTE_O)/$(if $(subdir),$(subdir)/) + COMMAND_O := O=$(ABSOLUTE_O) + ifeq ($(objtree),)
